Arduino.ru

а кнопки с резистором или без

у меня с резисторами =)

а можно еще последнюю версию кода после "правки"

И еще резисторі к кнопкам какого ниминала?(сами кнопки я так понимаю без фиксации?)

"А ты, вот это, читал!?"(С)Жеглов

Работа с кнопками. В помощь новичку.

 

спасибо почитаю

 

Держи

/* adress eeprom
EEPROM 0 Минимальное значение температуры актуатора
EEPROM 1 Максимальное значение темп актуатора
EEPROM 2 1/0 включение отключение полива (0=off / 1=on)
EEPROM 3 Продолжительность минут полива
EEPROM 4 минута полива
EEPROM 5 час полива
*/

//LCD I2C 20x4
#include <EEPROM.h>
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
LiquidCrystal_I2C lcd(0x27,20,4);
//LCD



//кнопка
// задаем константы кнопок и присваиваем им пины
const int buttonPin = 15;     // центральная кнопка
const int buttonPin_1 = 14;  //левая кнопка 
const int buttonPin_0 = 16;  //правая кнопка
const int ledPin =  13;      // номер выхода светодиода

// глобальные переменные
int centreBtn = 0;         // переменная для хранения состояния центральной кнопки
int leftbtn = 0;     // переменная для хранения состояния левой кнопки
int rightbtn = 0;     // переменная для хранения состояния правой кнопки
String irr_time =""; //переменная строки времени полива
int del = 500; // переменная ожидания между выборами меню(время горения ledpin в милисек)

//переменные автовозврата в loop 
int interval = 50;    // интервал сколько будет длиться цикл while, после чего перейдёт к следующему меню.(кол-во итераций)
//



void setup() {
//LCD
#ifdef AVR
Wire.begin();
#else
Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino Due
#endif
lcd.init();   // initialize the lcd 
lcd.backlight();
//--LCD

// initialize the button pin as a input:

// initialize the LED as an output:
pinMode(ledPin, OUTPUT);
digitalWrite(ledPin, HIGH); 
// initialize serial communication:
Serial.begin(9600);

    
// инициализируем пин, подключенный к кнопке, как вход
pinMode(buttonPin, INPUT);   
pinMode(buttonPin_0, INPUT);   
pinMode(buttonPin_1, INPUT);   

string_irrigation_time();
}


void loop() {

// read the pushbutton input pin:
//digitalWrite(ledPin, HIGH);
  lcd.setCursor(0,0);
  lcd.print("GREEN GARDEN MENU v1");
  lcd.setCursor(0,1);
  lcd.print(irr_time);
  lcd.print("            ");  
  lcd.setCursor(0,2);
  lcd.print("(=very  good  menu=)");
  lcd.setCursor(0,3);
  lcd.print("        MENU        ");

 button_read(); //читаем кнопки
// проверяем нажата ли кнопка
// 
if (centreBtn) {   // проверяем нажата ли кнопка если нажата, то 
digitalWrite(ledPin, LOW);
delay(del);// включаем светодиод   
lcd.clear(); //очищаем экран
digitalWrite(ledPin, HIGH);
menu();
}
}
void menu()
{
actuator_setup();
irrigtion_setup();
irrigation_set_time();

}

void actuator_setup()
{
int x =0;

  lcd.clear(); //очищаем экран

while(x < interval){ // цикл 
x++;


  button_read();

  lcd.setCursor(0,0);
  lcd.print(" -=ACTUATOR SETUP=- ");

  int t_mini = EEPROM.read(0);
  lcd.setCursor(0,1);
  lcd.print("min = ");
  lcd.print(t_mini);
  lcd.print((char)223);

  int t_maxi = EEPROM.read(1);
  lcd.setCursor(11,1);
  lcd.print("max = ");
  lcd.print(t_maxi);
  lcd.print((char)223);                   

  lcd.setCursor(0,2);
  lcd.print("____________________");

  lcd.setCursor(0,3);
  lcd.print("T_MIN   NEXT   T_MAX");
  digitalWrite(ledPin, HIGH);
  
   
if (centreBtn) {   
 digitalWrite(ledPin, LOW);             
 delay(del);// включаем светодиод   
 lcd.clear(); //очищаем экран
 digitalWrite(ledPin, HIGH);
 break; }
                      
 if (leftbtn) {   
 digitalWrite(ledPin, LOW);             
   lcd.clear();
        t_min();
       delay(del);
       lcd.clear(); //очищаем экран
       x =0;   
       digitalWrite(ledPin, HIGH);            
       }       
    
if (rightbtn) {   
       digitalWrite(ledPin, LOW);             
       lcd.clear();
        t_max();
       delay(del);// включаем светодиод   
       lcd.clear(); //очищаем экран
       x =0;           
       digitalWrite(ledPin, HIGH);
      }  
  
 }}


void irrigtion_setup()
{
int y =0;  
lcd.clear(); //очищаем экран
while(y < interval){ //бесконечный цикл 
y++;
button_read();

 lcd.setCursor(0,0);
 lcd.print("-=IRRIGATION SETUP=-");
 int on_off = EEPROM.read(2);
String x;
 if (on_off == 1) {x="ON";}
 if (on_off == 0) {x="OFF";}

 lcd.setCursor(0,1);
 lcd.print("irr=");
 lcd.print(x);


 int duration = EEPROM.read(3);
 lcd.setCursor(10,1);
 lcd.print("dur=");
 lcd.print(duration);
 lcd.print("min");                   
 lcd.setCursor(0,2);
 lcd.print("____________________"); 
 lcd.setCursor(0,3);
 lcd.print("ON/OFF NEXT DURATION");
//                   digitalWrite(ledPin, HIGH);
    if (centreBtn) {   
           digitalWrite(ledPin, LOW);             
           delay(del);// включаем светодиод   
           lcd.clear(); //очищаем экран
            break;
           }
    
    if (rightbtn) {   
           digitalWrite(ledPin, LOW);             
           lcd.clear();
            durration_irrigation();  
           delay(del);// включаем светодиод   
               lcd.clear(); //очищаем экран
           y =0;   
           digitalWrite(ledPin, HIGH);            
           }       
        
    if (leftbtn) {   
           digitalWrite(ledPin, LOW);             
           lcd.clear();
            on_off_irrigation();  
           delay(del);// включаем светодиод   
           lcd.clear(); //очищаем экран
           y =0;            
           digitalWrite(ledPin, HIGH);
          }  
 

 }}

void irrigation_set_time()
{
int x =0;
lcd.clear(); //очищаем экран
while(x < interval){ //бесконечный цикл 
x++;
button_read();
string_irrigation_time(); //выполняем функцию строки времени полива для отображения переменной irr_time
 lcd.setCursor(0,0);
 lcd.print("IRRIGATION SET TIME");
 lcd.setCursor(0,1);
 lcd.print("irr_time= ");
 lcd.print(irr_time); //выводим переменную строки времени полива 

 lcd.setCursor(0,2);
 lcd.print("____________________");

 lcd.setCursor(0,3);
 lcd.print("minuts  NEXT  hours");
 digitalWrite(ledPin, HIGH);
if (centreBtn) {   
       digitalWrite(ledPin, LOW);             
       delay(del);// включаем светодиод   
       lcd.clear(); //очищаем экран
       digitalWrite(ledPin, HIGH);
       break;
       }

if (leftbtn) {   
       digitalWrite(ledPin, LOW);             
       lcd.clear();
        irrigation_set_minuts();
       delay(del);
       lcd.clear(); //очищаем экран
       x =0;   
       digitalWrite(ledPin, HIGH);            
       }       
    
if (rightbtn) {   
       digitalWrite(ledPin, LOW);             
       lcd.clear();
       irrigation_set_hours();
       delay(del);// включаем светодиод   
       lcd.clear(); //очищаем экран
       x =0;            
       digitalWrite(ledPin, HIGH);
      }  

 }}



//////--------------------------------------------------------------------------
//SUB MENU

void t_min()
{

lcd.clear(); //очищаем экран
delay(del);
while(1){ //бесконечный цикл 
button_read();

 lcd.setCursor(0,0);
 lcd.print(" TEMP MINIMUM SETUP");
 int t_min = EEPROM.read(0);
 lcd.setCursor(0,1);
 lcd.print("t = ");
 lcd.print(t_min);
 lcd.print((char)223);
 lcd.print("C");                   
 lcd.setCursor(0,3);
 lcd.print("t_min-1 NEXT t_min+1");
 lcd.setCursor(0,2);
 lcd.print("____________________");

 digitalWrite(ledPin, HIGH);
    if (centreBtn) {   
           digitalWrite(ledPin, LOW);             
           delay(del);// включаем светодиод   
           lcd.clear(); //очищаем экран
           digitalWrite(ledPin, HIGH);
           break;

           }
    
    if (rightbtn) {   
            delay(del);     
            digitalWrite(ledPin, LOW);             
            lcd.clear();
            EEPROM.write(0, t_min + 1);
            digitalWrite(ledPin, HIGH);            
           }       
        
    if (leftbtn) {   
          delay(del); 
          digitalWrite(ledPin, LOW);             
          lcd.clear();
          EEPROM.write(0, t_min - 1);
          digitalWrite(ledPin, HIGH);
          }  
 
 }
}

void t_max()
{

lcd.clear(); //очищаем экран
delay(del);
while(1){ //бесконечный цикл 
button_read();

 lcd.setCursor(0,0);
 lcd.print(" TEMP MAXIMUM SETUP");
 int t_max = EEPROM.read(1);
 lcd.setCursor(0,1);
 lcd.print("t = ");
 lcd.print(t_max);
 lcd.print((char)223);
 lcd.print("C");                   
 lcd.setCursor(0,3);
 lcd.print("t_max-1 NEXT t_max+1");
 lcd.setCursor(0,2);
 lcd.print("____________________");

 digitalWrite(ledPin, HIGH);
    if (centreBtn) {   
           digitalWrite(ledPin, LOW);             
           delay(del);// включаем светодиод   
           lcd.clear(); //очищаем экран
           digitalWrite(ledPin, HIGH);
           break;

           }
    
    if (rightbtn) {   
            delay(del);     
            digitalWrite(ledPin, LOW);             
            lcd.clear();
            EEPROM.write(1, t_max + 1);
            digitalWrite(ledPin, HIGH);            
           }       
        
    if (leftbtn) {   
          delay(del); 
          digitalWrite(ledPin, LOW);             
          lcd.clear();
          EEPROM.write(1, t_max - 1);
          digitalWrite(ledPin, HIGH);
          }  
 
 }
}

void on_off_irrigation()
{

lcd.clear(); //очищаем экран
delay(del);
while(1){ //бесконечный цикл 
button_read();

 lcd.setCursor(0,0);
 lcd.print(" ON/OFF  IRRIGATION ");
 int on_off = EEPROM.read(2);
 String x;
 if (on_off == 1) {x="ON";}
 if (on_off == 0) {x="OFF";}
 lcd.setCursor(0,1);
 lcd.print("now irrigation = ");
 
 lcd.print(x);
 lcd.setCursor(0,2);
 lcd.print("____________________");                                      
 lcd.setCursor(0,3);
 lcd.print("ON      NEXT     OFF");


 digitalWrite(ledPin, HIGH);
    if (centreBtn) {   
           digitalWrite(ledPin, LOW);             
           delay(del);// включаем светодиод   
           lcd.clear(); //очищаем экран
           digitalWrite(ledPin, HIGH);
           break;

           }
    
    if (rightbtn) {   
            delay(del);     
            digitalWrite(ledPin, LOW);             
            lcd.clear();
            EEPROM.write(2, 0);
            digitalWrite(ledPin, HIGH);            
           }       
        
    if (leftbtn) {   
          delay(del); 
          digitalWrite(ledPin, LOW);             
          lcd.clear();
          EEPROM.write(2, 1);
          digitalWrite(ledPin, HIGH);
          }  
 
 }
}
void durration_irrigation()
{

lcd.clear(); //очищаем экран
delay(del);
while(1){ //бесконечный цикл 
button_read();

 lcd.setCursor(0,0);
 lcd.print("DURRATION IRRIGATIN");
 int duration = EEPROM.read(3);
 lcd.setCursor(0,1);
 lcd.print("durration = ");
 lcd.print(duration);
 lcd.print("min");                   
 lcd.setCursor(0,3);
 lcd.print("-1min   NEXT   +1min");
 lcd.setCursor(0,2);
 lcd.print("____________________");

 digitalWrite(ledPin, HIGH);
    if (centreBtn) {   
           digitalWrite(ledPin, LOW);             
           delay(del);// включаем светодиод   
           lcd.clear(); //очищаем экран
           digitalWrite(ledPin, HIGH);
           break;

           }
    
    if (rightbtn) {   
            delay(del);     
            digitalWrite(ledPin, LOW);             
            lcd.clear();
            EEPROM.write(3, duration + 1);
            digitalWrite(ledPin, HIGH);            
           }       
        
    if (leftbtn) {   
          delay(del); 
          digitalWrite(ledPin, LOW);             
          lcd.clear();
          EEPROM.write(3, duration - 1);
          digitalWrite(ledPin, HIGH);
          }  
 
 }
}

void irrigation_set_minuts()
{

lcd.clear(); //очищаем экран
delay(del);
while(1){ //бесконечный цикл 
button_read();

 lcd.setCursor(0,0);
 lcd.print("SET MINUTES");
 int minuts = EEPROM.read(4);
 lcd.setCursor(0,1);
 lcd.print("minuts = ");
 lcd.print(minuts);
 lcd.print("min");                   
 lcd.setCursor(0,3);
 lcd.print("-1min   NEXT   +1min");
 lcd.setCursor(0,2);
 lcd.print("____________________");

 digitalWrite(ledPin, HIGH);
    if (centreBtn) {   
           digitalWrite(ledPin, LOW);             
           delay(del);// включаем светодиод   
           lcd.clear(); //очищаем экран
           digitalWrite(ledPin, HIGH);
           break;
           }
    
    if (rightbtn) {   
            delay(del);     
            digitalWrite(ledPin, LOW);             
            lcd.clear();
            minuts = minuts + 1;
            if (minuts >59){minuts=0;}
            EEPROM.write(4, minuts);
            digitalWrite(ledPin, HIGH);            
           }       
        
    if (leftbtn) {   
          delay(del); 
          digitalWrite(ledPin, LOW);             
          lcd.clear();
          minuts = minuts - 1;
          if (minuts < 0) {minuts=59;}
          EEPROM.write(4, minuts);
          digitalWrite(ledPin, HIGH);
          }  
 
 }

}
void irrigation_set_hours()
{

lcd.clear(); //очищаем экран
delay(del);
while(1){ //бесконечный цикл
button_read();

 lcd.setCursor(0,0);
 lcd.print("SET hours");
 int hours = EEPROM.read(5);
 lcd.setCursor(0,1);
 lcd.print("hours = ");
 lcd.print(hours);
 lcd.print("h");                   
 lcd.setCursor(0,3);
 lcd.print("-1hour  NEXT  +1hour");
 lcd.setCursor(0,2);
 lcd.print("____________________");

 digitalWrite(ledPin, HIGH);
    if (centreBtn) {   
           digitalWrite(ledPin, LOW);             
           delay(del);// включаем светодиод   
               lcd.clear(); //очищаем экран
               digitalWrite(ledPin, HIGH);
               break;
           
           }
    
    if (rightbtn) {   
            delay(del);     
            digitalWrite(ledPin, LOW);             
            lcd.clear();
            hours = hours + 1;
            if (hours >23){hours=0;}
            EEPROM.write(5, hours);
            digitalWrite(ledPin, HIGH);            
           }       
        
    if (leftbtn) {   
          delay(del); 
          digitalWrite(ledPin, LOW);             
          lcd.clear();
          hours = hours - 1;
          if (hours < 0) {hours=23;}
          EEPROM.write(5, hours);
          digitalWrite(ledPin, HIGH);
          }  
 }
}
void string_irrigation_time() // функция формирования строки времни полива
{
irr_time = ""; //очистим глобальную переменную навсякий случай. 


 int minuts = EEPROM.read(4); //читаем память
 int hours = EEPROM.read(5);
 if (hours >= 0 && hours <=9) {irr_time += 0; irr_time += hours;} else{irr_time += hours;} //дописываем нолик для hours
 
 irr_time += ":";
 if (minuts >= 0 && minuts <=9){irr_time += 0; irr_time += minuts;} else{irr_time += minuts;} //дописываем нолик для minuts
 
 
 irr_time += ":";
 irr_time += "00"; //собрали строку времени полива
// lcd.setCursor(0,1);
// lcd.print("irr_time=");
// lcd.print(irr_time);
}

void button_read() //функция проверки нажатия кнопки
{
centreBtn = digitalRead(buttonPin); //запоминаем значение кнопки
rightbtn = digitalRead(buttonPin_0); //запоминаем значение кнопки
leftbtn = digitalRead(buttonPin_1); //запоминаем значение кнопки
}

 

Спасибо.Я использовал старый вариант меню переделав его под 16*2дисплей добавив свою часть с термостатом.Но после обьеденеия перестала работать моя часть все компилируется но не работает ,часть с меню работает отлично.Если dachnik не против я могу выложить здесь то что вышло.

выкладывай

// adress eeprom
/*EEPROM 0 //(Минимальное значение температуры актуатора) теперратура мин
EEPROM 1 //(Максимальное значение темп актуатора) температура макс
EEPROM 2 1/0 //включение отключение полива (0=off / 1=on)
EEPROM 3 //Продолжительность минут полива
EEPROM 4 //минута полива
EEPROM 5 //час полива
//цикл*/
//-------------------------------------м----------------------------------------------
int led2 = 4;//  "сигнал таймер переворот"
int led3 = 2;// сигнал нагреватель
int led4 = 5;// сигнал туманогенератор
//-------------------------------------м----------------------------------------------
 
//LCD I2C 20x4
#include <DS1307RTC.h>
#include <Time.h>
#include <EEPROM.h>
//#include <LiquidCrystal_I2C.h>
#include <Wire.h>
#include <LiquidCrystal.h>
//LiquidCrystal_I2C lcd(0x27,20,4);
//LCD
#include "DHT.h"
//------------------------------------мое----------------------------------------------------
#define DHTPIN 3 // куда подключен термодатчик
 
#define DHTTYPE DHT11   // DHT 11 используемый термодатчик
DHT dht(DHTPIN, DHTTYPE);
 
LiquidCrystal lcd(8, 9, 10, 11, 12, 13);
//------------------------------------мое----------------------------------------------------
 
//кнопка
// задаем константы
const int buttonPin = 15;     // номер входа, подключенный к кнопке
const int buttonPin_1 = 16;  //левая кнопка
const int buttonPin_0 = 14;  //правая кнопка
const int led =  17;      // номер выхода светодиода
/*
#define buttonEnterPin = 15;
#define buttonPlusPin = 14;
#define buttonMinusPin = 16;
#define EnterPressed   !digitalRead(buttonEnterPin);
#define PlusPressed    !digitalRead(buttonPlusPin);
#define MinusPressed   !digitalRead(buttonMinusPin);
*/
// переменные
int buttonState = 0;         // переменная для хранения состояния кнопки
int buttonState_1 = 0;         // переменная для хранения состояния кнопки
int buttonState_0 = 0;    // previous state of the button
 
 
void setup() {
//------------------------------------мое---------------------------------
Serial.begin(9600);
  dht.begin();
  int day;
  while (!Serial) ; // wait for serial
  delay(200);
  pinMode(led, OUTPUT);//индикатор кнопки
  pinMode(led2, OUTPUT);// сигнал "таймер"
  pinMode(led3, OUTPUT);// сигнал нагрева
  pinMode(led4,OUTPUT);//сигнал туманогенератора
  Serial.println("DS1307RTC Read Test");
  Serial.println("-------------------");
//------------------------------------мое---------------------------------
  //LCD
#ifdef AVR
Wire.begin();
#else
Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino Due
#endif
//lcd.init();   // initialize the lcd
lcd.begin(16, 2);
//------------------------------------мое---------------------------------
// печатаем первую строку
  lcd.print("Inkubator" );
 lcd.setCursor(1, 1);
 delay(500);
  // печатаем вторую строку
  lcd.print("tamerlan-1");
  delay(500);
  lcd.clear();
//------------------------------------мое---------------------------------
//lcd.backlight();
//--LCD
 
// initialize the button pin as a input:
 
// initialize the LED as an output:
 
// initialize serial communication:
Serial.begin(9600);
 
//pinMode(ledPin, OUTPUT);    
// инициализируем пин, подключенный к кнопке, как вход
pinMode(buttonPin, INPUT);  
pinMode(buttonPin_0, INPUT);  
pinMode(buttonPin_1, INPUT);  
}
 
 
void loop() {
//-------------------------------------m----------------------------------------------
float h = dht.readHumidity();//обозначение влажности
  float t = dht.readTemperature(); //обозначение температуры
  float x =EEPROM.read(2);//день месяца соответствующий проклевыванию
  tmElements_t tm; //вывод на экран дата и влажность
  {//lcd.setCursor(0, 1);
  //print2digits(tm.Day);
  //lcd.write('/');
  //print2digits(tm.Month);
  //lcd.write('/');
  //lcd.print(tmYearToCalendar(tm.Year));
  /*lcd.write('h');
  print2digits (h);
  //lcd.write("*H ");*/
 lcd.setCursor(0, 0);//вывод на экран время и температура
 print2digits(tm.Hour);
  lcd.write(':');
  print2digits(tm.Minute);
  lcd.write('`');
  print2digits(tm.Second);
  lcd.write(' ');
  print2digits(tm.Day);
  lcd.write('/');
  print2digits(tm.Month);
  //lcd.write('/');
  //lcd.print(tmYearToCalendar(tm.Year));
  //lcd.write('h');
  //print2digits (h);
  //lcd.write("*H ");
  //lcd.write('t');
  //print2digits (t);
  //lcd.write("*C ");
  //delay(1000);
  if (RTC.read(tm)) //информацыя в sereal monitor
  {
    Serial.print("Ok, Time = ");
    Serial.print(tm.Hour);
    Serial.write(':');
    Serial.print(tm.Minute);
    Serial.write(':');
    Serial.print(tm.Second);
    Serial.print(", Date (D/M/Y) = ");
    Serial.print(tm.Day);
    Serial.write('/');
    Serial.print(tm.Month);
    Serial.write('/');
    Serial.print(tmYearToCalendar(tm.Year));
    Serial.println();
  } else {
    if (RTC.chipPresent()) {
      Serial.println("The DS1307 is stopped.  Please run the SetTime");
      Serial.println("example to initialize the time and begin running.");
      Serial.println();
    } else {
      Serial.println("DS1307 read error!  Please check the circuitry.");
      Serial.println();
    }
    delay(900);
  }
  //delay(500);
//-------------------------------------m---------------------------------------------- 
// read the pushbutton input pin:
  //lcd.setCursor(0,0);
  //lcd.print("Ink MENU v1");
  //lcd.setCursor(0,1);
  //lcd.print("(very good menu)");
  lcd.setCursor(0,1);
  lcd.print("      MENU      ");
  lcd.setCursor(0,1);
  lcd.write('t');
  print2digits (t);
  lcd.write("*C");
  lcd.setCursor(12,1);
  lcd.write('h');
  print2digits (h);
  lcd.write("*H ");
   
buttonState = digitalRead(buttonPin);
// проверяем нажата ли кнопка
// если нажата, то buttonState будет HIGH:
if (buttonState == HIGH) {  
digitalWrite(led, HIGH);
delay(1000);// включаем светодиод  
lcd.clear(); //очищаем экран
menu();
}
}
}
//-------------------------------------терморегулятор--------------------------------
void termo/*string_irrigation_time*/() // функция формирования строки времни полива
{
 tmElements_t tm; //вывод на экран дата и влажность
 float h = dht.readHumidity();//обозначение влажности
  float t = dht.readTemperature(); //обозначение температуры
  float x =EEPROM.read(2);//день месяца соответствующий проклевыванию
  String irr_time = ""; //объявление переменной строки
 
 
int minuts = EEPROM.read(4); //читаем память
int hours = EEPROM.read(5);
 /*if (hours >= 0 && hours <=9) {irr_time += 0; irr_time += hours;} else{irr_time += hours;} //дописываем нолик
  
 irr_time += ":";
 if (minuts >= 0 && minuts <=9){irr_time += 0; irr_time += minuts;} else{irr_time += minuts;}
  
  
 irr_time += ":";
 irr_time += "00";*/
// lcd.setCursor(0,1);
 //lcd.print("irr_time=");
 //lcd.print(irr_time);
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
if ((tm.Minute)= minuts)/*((tm.Second)>58)if((tm.Day)<=x)*/{//условия таймера
 digitalWrite(led2, HIGH);//включает переворот
 // поворот по часовой стрелке
   Serial.println("povorot po chasovoi");
  //myStepper.step(stepsPerRevolution);
  //Serial.print("Taimer On!!   ");//вывод инфо состояния
 lcd.setCursor(15,1);//вывод инфо состояния на LCD
 lcd.print("%");
  
 /*  // step one revolution in the other direction:
  Serial.println("povorot protiv chasovoi");
  myStepper.step(-stepsPerRevolution);
   */
 }
 else
 {
 digitalWrite(led2, LOW);
 Serial.print("Taimer OFF");
 }
 //****************************************************************
 if (t<EEPROM.read(0))//условия терморегуляции
 {
 digitalWrite(led3,HIGH);
 Serial.print("Vkluchen nagrev!!");//вывод инфо состояния
 lcd.setCursor(15, 0);
 lcd.print("^");//вывод инфо состояния на LCD
 //delay (500);
 }
 else
 { digitalWrite(led3,LOW);
 Serial.print("Temp ok  ");//вывод инфо состояния
 lcd.setCursor(15, 0);
 lcd.print("~");//вывод инфо на LCD
 }
  
 //***********************************************************
 if (h<EEPROM.read(1))//условия регуляции влажности
 {
 digitalWrite(led4,HIGH);
 Serial.print("Vkluchen tuman!!");//вывод инфо состояния
 lcd.setCursor(14, 0);
 lcd.print("#");//вывод инфо состояния на LCD
 //delay (500);
 }
 else
 { digitalWrite(led4,LOW);
 Serial.print("Vlagnost ok  ");//вывод инфо состояния
 lcd.setCursor(14, 0);
 lcd.print("~");//вывод инфо состояния
 }
  
 //************************************************************
 }
//-------------------------------------терморегулятор конец--------------------------
 
void menu()
{
actuator_setup();//температура
irrigtion_setup();//переворот
irrigation_set_time(); //влажность
}
 
void actuator_setup()//установка температуры
{
lcd.clear(); //очищаем экран
while(1){ //бесконечный цикл
buttonState = digitalRead(buttonPin); //запоминаем значение кнопки
buttonState_0 = digitalRead(buttonPin_0); //запоминаем значение кнопки
buttonState_1 = digitalRead(buttonPin_1); //запоминаем значение кнопки
 
/*lcd.setCursor(0,0);
lcd.print(" -=TEMP SETUP=- ");//Actuator setup
lcd.clear();*/
int t_mini = EEPROM.read(0);
lcd.setCursor(0,0);
lcd.print("min=");
lcd.print(t_mini);
lcd.print((char)223);
 
int t_maxi = EEPROM.read(1);
lcd.setCursor(9,0);
lcd.print("max=");
lcd.print(t_maxi);
lcd.print((char)223);                  
 
//lcd.setCursor(0,2);
//lcd.print("________________");
 
lcd.setCursor(0,1);
lcd.print("T_MIN NEXT T_MAX");
digitalWrite(led, HIGH);
if (buttonState == HIGH) {  
 digitalWrite(led, LOW);            
 delay(1000);// включаем светодиод  
 lcd.clear(); //очищаем экран
 digitalWrite(led, HIGH);
 break; }
                       
 if (buttonState_1 == HIGH) {  
 digitalWrite(led, LOW);            
   lcd.clear();
        t_min();
       delay(500);
       lcd.clear(); //очищаем экран
           
       digitalWrite(led, HIGH);           
       }      
     
if (buttonState_0 == HIGH) {  
       digitalWrite(led, LOW);            
       lcd.clear();
        t_max();
       delay(500);// включаем светодиод  
       lcd.clear(); //очищаем экран
                    
       digitalWrite(led, HIGH);
      } 
      
     }}
 
 
void irrigtion_setup()
{
lcd.clear(); //очищаем экран
while(1){ //бесконечный цикл
buttonState = digitalRead(butto/запоминаем значение кнопки
buttonState_0 = digitalRead(buttonPin_0); //запоминаем значение кнопки
buttonState_1 = digitalRead(buttonPin_1); //запоминаем значение кнопки
 
 /*lcd.setCursor(0,0);
 lcd.print("=Perevorot SET=");//IRRIGATION*/
 int on_off = EEPROM.read(2);
String z;
 if (on_off == 1) {z="ON";}
 if (on_off == 0) {z="OFF";}
 
 lcd.setCursor(0,0);
 lcd.print("per=");
 lcd.print(z);
 
 
 int duration = EEPROM.read(3);//продолжительность
 lcd.setCursor(9,0);
 lcd.print("prod=");
 lcd.print(duration);
 lcd.print("min");                  
 //lcd.setCursor(0,1);
 //lcd.print("____________________");
 lcd.setCursor(0,1);
 lcd.print("ON/OFF NEXT prod");
//                   digitalWrite(ledPin, HIGH);
    if (buttonState == HIGH) {  
           digitalWrite(led, LOW);            
           delay(500);// включаем светодиод  
           lcd.clear(); //очищаем экран
            break;
           }
     
    if (buttonState_0 == HIGH) {  
           digitalWrite(led, LOW);            
           lcd.clear();
            durration_irrigation(); 
           delay(500);// включаем светодиод  
               lcd.clear(); //очищаем экран
               
           digitalWrite(led, HIGH);           
           }      
         
    if (buttonState_1 == HIGH) {  
           digitalWrite(led, LOW);            
           lcd.clear();
            on_off_irrigation(); 
           delay(500);// включаем светодиод  
           lcd.clear(); //очищаем экран
                        
           digitalWrite(led, HIGH);
          } 
  
 }}
 
void irrigation_set_time()//настройка времени переворота
{
lcd.clear(); //очищаем экран
while(1){ //бесконечный цикл
buttonState = digitalRead(buttonPin); //запоминаем значение кнопки
buttonState_0 = digitalRead(buttonPin_0); //запоминаем значение кнопки
buttonState_1 = digitalRead(buttonPin_1); //запоминаем значение кнопки
 lcd.setCursor(0,0);
 lcd.print("Povor SET TIME");//"IRIGAT SET TIME"
 //lcd.setCursor(0,1);
 //lcd.print("pov_time= "); string_irrigation_time();
 
 /*lcd.setCursor(0,0);
 lcd.print("____________________");*/
 
 lcd.setCursor(0,1);
 lcd.print("minut NEXT hour");
 digitalWrite(led, HIGH);
if (buttonState == HIGH) {  
       digitalWrite(led, LOW);            
       delay(1000);// включаем светодиод  
           lcd.clear(); //очищаем экран
           break;
       digitalWrite(led, HIGH);
       }
 
if (buttonState_1 == HIGH) {  
       digitalWrite(led, LOW);            
       lcd.clear();
        irrigation_set_minuts();
       delay(500);
       lcd.clear(); //очищаем экран
           
       digitalWrite(led, HIGH);           
       }      
     
if (buttonState_0 == HIGH) {  
       digitalWrite(led, LOW);            
       lcd.clear();
       irrigation_set_hours();
       delay(500);// включаем светодиод  
       lcd.clear(); //очищаем экран
                    
       digitalWrite(led, HIGH);
      } 
  
 }}
 
 
 
//////--------------------------------------------------------------------------
//SUB MENU
 
void t_min()
{
 
lcd.clear(); //очищаем экран
delay(1000);
while(1){ //бесконечный цикл
buttonState = digitalRead(buttonPin); //запоминаем значение кнопки
buttonState_0 = digitalRead(buttonPin_0); //запоминаем значение кнопки
buttonState_1 = digitalRead(buttonPin_1); //запоминаем значение кнопки
 
 lcd.setCursor(0,0);
 lcd.print("tMinSET");
 int t_min = EEPROM.read(0);
 lcd.setCursor(8,0);
 lcd.print("t=");
 lcd.print(t_min);
 lcd.print((char)223);
 lcd.print("C");                  
 lcd.setCursor(0,1);
 lcd.print("tmin-1NEXTtmin+1");
 //lcd.setCursor(0,1);
 //lcd.print("________________");
 
 digitalWrite(led, HIGH);
    if (buttonState == HIGH) {  
           digitalWrite(led, LOW);            
           delay(1000);// включаем светодиод  
               lcd.clear(); //очищаем экран
               break;
           digitalWrite(led, HIGH);
           }
     
    if (buttonState_0 == HIGH) {  
            delay(500);    
            digitalWrite(led, LOW);            
            lcd.clear();
            EEPROM.write(0, t_min + 1);
            digitalWrite(led, HIGH);           
           }      
         
    if (buttonState_1 == HIGH) {  
          delay(500);
          digitalWrite(led, LOW);            
          lcd.clear();
          EEPROM.write(0, t_min - 1);
          digitalWrite(led, HIGH);
          } 
  
 }
}
 
void t_max()
{
 
lcd.clear(); //очищаем экран
delay(1000);
while(1){ //бесконечный цикл
buttonState = digitalRead(buttonPin); //запоминаем значение кнопки
buttonState_0 = digitalRead(buttonPin_0); //запоминаем значение кнопки
buttonState_1 = digitalRead(buttonPin_1); //запоминаем значение кнопки
 
 lcd.setCursor(0,0);
 lcd.print("tMaxSET");
 int t_max = EEPROM.read(1);
 lcd.setCursor(8,0);
 lcd.print("t=");
 lcd.print(t_max);
 lcd.print((char)223);
 lcd.print("C");                  
 lcd.setCursor(0,1);
 lcd.print("tmax-1NEXTtmax+1");
 //lcd.setCursor(0,0);
 //lcd.print("________________");
 
 digitalWrite(led, HIGH);
    if (buttonState == HIGH) {  
           digitalWrite(led, LOW);            
           delay(1000);// включаем светодиод  
               lcd.clear(); //очищаем экран
               break;
           digitalWrite(led, HIGH);
           }
     
    if (buttonState_0 == HIGH) {  
            delay(500);    
            digitalWrite(led, LOW);            
            lcd.clear();
            EEPROM.write(1, t_max + 1);
            digitalWrite(led, HIGH);           
           }      
         
    if (buttonState_1 == HIGH) {  
          delay(500);
          digitalWrite(led, LOW);            
          lcd.clear();
          EEPROM.write(1, t_max - 1);
          digitalWrite(led, HIGH);
          } 
  
 }
}
 
void on_off_irrigation()//вкл/выкл переворот
{
 
lcd.clear(); //очищаем экран
delay(1000);
while(1){ //бесконечный цикл
buttonState = digitalRead(buttonPin); //запоминаем значение кнопки
buttonState_0 = digitalRead(buttonPin_0); //запоминаем значение кнопки
buttonState_1 = digitalRead(buttonPin_1); //запоминаем значение кнопки
 
 /*lcd.setCursor(0,0);
 lcd.print("ON/OFF Povorot");//IRRIGATION*/
 int on_off = EEPROM.read(2);
 String z;
 if (on_off == 1) {z="ON";}
 if (on_off == 0) {z="OFF";}
 lcd.setCursor(0,0);
 lcd.print("now povor=");//irrignation
 lcd.setCursor(11,0);
 lcd.print(z);
 //lcd.setCursor(0,2);
 //lcd.print("____________________");                                     
 //lcd.clear();
 lcd.setCursor(0,1);
 lcd.print("ON   NEXT  OFF");
 
 
 digitalWrite(led, HIGH);
    if (buttonState == HIGH) {  
           digitalWrite(led, LOW);            
           delay(1000);// включаем светодиод  
               lcd.clear(); //очищаем экран
               break;
           digitalWrite(led, HIGH);
           }
     
    if (buttonState_0 == HIGH) {  
            delay(500);    
            digitalWrite(led, LOW);            
            lcd.clear();
            EEPROM.write(2, 0);
            digitalWrite(led, HIGH);           
           }      
         
    if (buttonState_1 == HIGH) {  
          delay(500);
          digitalWrite(led, LOW);            
          lcd.clear();
          EEPROM.write(2, 1);
          digitalWrite(led, HIGH);
          } 
  
 }
}
void durration_irrigation()
{
 
lcd.clear(); //очищаем экран
delay(1000);
while(1){ //бесконечный цикл
buttonState = digitalRead(buttonPin); //запоминаем значение кнопки
buttonState_0 = digitalRead(buttonPin_0); //запоминаем значение кнопки
buttonState_1 = digitalRead(buttonPin_1); //запоминаем значение кнопки
 
 /*lcd.setCursor(0,0);
 lcd.print("povor do");*/
 int duration = EEPROM.read(3);
 lcd.setCursor(0,0);
 lcd.print("povor=");
 lcd.print(duration);
 lcd.print("day");                  
//lcd.clear();
 lcd.setCursor(0,1);
 lcd.print("-1day NEXT +1day");
 //lcd.setCursor(0,2);
 //lcd.print("____________________");
 
 digitalWrite(led, HIGH);
    if (buttonState == HIGH) {  
           digitalWrite(led, LOW);            
           delay(1000);// включаем светодиод  
               lcd.clear(); //очищаем экран
               break;
           digitalWrite(led, HIGH);
           }
     
    if (buttonState_0 == HIGH) {  
            delay(500);    
            digitalWrite(led, LOW);            
            lcd.clear();
            EEPROM.write(3, duration + 1);
            digitalWrite(led, HIGH);           
           }      
         
    if (buttonState_1 == HIGH) {  
          delay(500);
          digitalWrite(led, LOW);            
          lcd.clear();
          EEPROM.write(3, duration - 1);
          digitalWrite(led, HIGH);
          } 
  
 }
}
//---------------------------------------------------peredelano-------------------------------
void irrigation_set_minuts()//время поворота минуты
{
 
lcd.clear(); //очищаем экран
delay(1000);
while(1){ //бесконечный цикл
buttonState = digitalRead(buttonPin); //запоминаем значение кнопки
buttonState_0 = digitalRead(buttonPin_0); //запоминаем значение кнопки
buttonState_1 = digitalRead(buttonPin_1); //запоминаем значение кнопки
 
 /*lcd.setCursor(0,0);
 lcd.print("SET MINUT");*/
 int minuts = EEPROM.read(4);
 lcd.setCursor(0,0);
 lcd.print("minuts=");
 lcd.print(minuts);
 lcd.print("min");                  
 //lcd.clear();
 lcd.setCursor(0,1);
 lcd.print("-1min NEXT +1min");
 //lcd.setCursor(0,2);
// lcd.print("____________________");
 
 digitalWrite(led, HIGH);
    if (buttonState == HIGH) {  
           digitalWrite(led, LOW);            
           delay(1000);// включаем светодиод  
               lcd.clear(); //очищаем экран
               break;
           digitalWrite(led, HIGH);
           }
     
    if (buttonState_0 == HIGH) {  
            delay(500);    
            digitalWrite(led, LOW);            
            lcd.clear();
            minuts = minuts + 1;
            if (minuts >59){minuts=0;}
            EEPROM.write(4, minuts);
            digitalWrite(led, HIGH);           
           }      
         
    if (buttonState_1 == HIGH) {  
          delay(500);
          digitalWrite(led, LOW);            
          lcd.clear();
          minuts = minuts - 1;
          if (minuts < 0) {minuts=59;}
          EEPROM.write(4, minuts);
          digitalWrite(led, HIGH);
          } 
  
 }
 
}
void irrigation_set_hours()
{
 
lcd.clear(); //очищаем экран
delay(1000);
while(1){ //бесконечный цикл
buttonState = digitalRead(buttonPin); //запоминаем значение кнопки
buttonState_0 = digitalRead(buttonPin_0); //запоминаем значение кнопки
buttonState_1 = digitalRead(buttonPin_1); //запоминаем значение кнопки
 
 /*lcd.setCursor(0,0);
 lcd.print("SET hours");*/
 int hours = EEPROM.read(5);
 lcd.setCursor(0,0);
 lcd.print("hours = ");
 lcd.print(hours);
 lcd.print("h");
//lcd.clear();
 lcd.setCursor(0,1);
 lcd.print("-1hourNEXT+1hour");
 //lcd.setCursor(0,2);
// lcd.print("____________________");
 
 digitalWrite(led, HIGH);
    if (buttonState == HIGH) {  
           digitalWrite(led, LOW);            
           delay(1000);// включаем светодиод  
               lcd.clear(); //очищаем экран
               break;
           digitalWrite(led, HIGH);
           }
     
    if (buttonState_0 == HIGH) {  
            delay(500);    
            digitalWrite(led, LOW);            
            lcd.clear();
            hours = hours + 1;
            if (hours >23){hours=0;}
            EEPROM.write(5, hours);
            digitalWrite(led, HIGH);           
           }      
         
    if (buttonState_1 == HIGH) {  
          delay(500);
          digitalWrite(led, LOW);            
          lcd.clear();
          hours = hours - 1;
          if (hours < 0) {hours=23;}
          EEPROM.write(5, hours);
          digitalWrite(led, HIGH);
          } 
  
 }
 
}
 
//----------------------------------------m-----------------------------------------------
void print2digits(int number) {
  if (number >= 0 && number < 10) {
    lcd.write('0');
  }
  lcd.print(number);
}
//----------------------------------------m-----------------------------------------------

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

а где у тебя в loop() вызывается функция termo()? я вижу, что только меню вызывается....

Здравствуйте а возможно добавить подсветку в зимнее время. досвет.

Нет ничего невозможного, было бы время и руки... =)

Мне понравился ваш проект. Возможно доделать по заказу если надо даже оплачу работу. И хотелось его соеденить по wi-fi с пк и работа через программу типо Manager. 

Дайте свои координаты, пообщаемся, чтобы тут не засорять.

Нашел http://forum.amperka.ru/threads/%D0%9C%D0%B8%D0%BD%D0%B8-%D1%82%D0%B5%D0%BF%D0%BB%D0%B8%D1%86%D0%B0-v2-0.1786/

но дисплей надо зделать

Здравствуйте. Я снова в деле) Я поставил задачи/ вопросы для реализации моего дипломного проекта. Как Вы помните (наверное) у меня макет умной теплицы. Мои задачи/вопросы:

1.       Автономное орошение (полив) почвы теплицы, подавая воду близко к корню растения.

2.       Автономная подача воды в теплице по 2-м параметрам:

a.       По определенному периоду времени;

b.      По влажности почвы.

3.       Автономное отопление теплицы по  данным датчика измерения температуры воздуха.

4.       Автономная вентиляция теплицы (открытие окон, вентиляция)???

5.       Автоматическое открывание и закрывание штор в теплице в зависимости от времени суток (в зимнее время).

Как Вам? Не слишком много ли я беру на себя? Возможно ли их реализовать?

Зачем измерение влажности в теплице если так по определению осадков не предвидится ? По таймеру надежней. 

после полива влажность там огого... Даже конденсат выпадает.

По мне, выбери, что-то одно. Пример, датчик влажности почвы сказал то надо полить, земля пролилась и через минуту включается таймер и заливает ещё. В итоге растения залиты, помидорам плохо.... огурцам хз=)  

Если речь идёт о зимнем периоде отопления, то так же надо добавить обогрев почвы. т.к. в ледяной земле расти ничего не будет.... По мне дешевле будет открывать форточки, чем тратить эл-во на вентиляцию канальниками. ты хочешь закрывать шторы зимой когда итак нет света? ИМХО это актульно для культур которые чувствительны к светопериоду. Для овощей не нужно. Лучше добавить возможность досветки лампами в зимнее время года, когда световой день короткий и солнца почти нет.

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

Шторы будут отражать поток холодного воздуха в ночное время. Так как солнечного луча нет и воздух будет холодным. Это я в одном сайте прочитал, про отражающие шторы)

Про освещение, да. Можно добавить.

Вот, теперь вопрос. Как мне найти серво привод для моих штор?

Сперва хочу просто открыть/закрыть шторы, только потом добавить туда фоторезистор. Можете подсказать?

Предлагаю отказаться от идеи со шторами и вопрос отпадёт =) если у тебя обогрев есть, то шторы не нужны. моё мнение.

нее, так ведь ничего такого там не останется из функционала проекта) проект должен быть не плохим, ибо получить отлично ;)))

Лучше мотор посоветуйте ;)

Ничего по этому подсказать не могу, не интересовался таким вопросом. Поисковик в помощь =)

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

в зависимости от конструкции штор. но уверен, что вполне справится моторчик от автомобильного стеклоподьемника, вместе с редуктором и шкивом для троссика или, если крутить нужно не очень много, можно взять многооборотную серву пример 6 оборотов, они обычно используются для моделей яхт.

Всем привет, было время поработал ещё над прошивкой. Добавил возможность рулить сразу 4мя линиями полива. Записи логов на SDшку. Ну и всяких мелочей...  С каждым разом всё сложней становится ориентация в коде=)

/* adress eeprom
EEPROM 0 Минимальное значение температуры актуатора
EEPROM 1 Максимальное значение темп актуатора
 1 линия полива
EEPROM 2 1/0 включение отключение полива (0=off / 1=on)
EEPROM 3 Продолжительность минут полива
EEPROM 4 минута полива
EEPROM 5 час полива
 2 линия полива
EEPROM 6 1/0 включение отключение полива (0=off / 1=on)
EEPROM 7 Продолжительность минут полива
EEPROM 8 минута полива
EEPROM 9 час полива
 3 линия полива
EEPROM 10 1/0 включение отключение полива (0=off / 1=on)
EEPROM 11 Продолжительность минут полива
EEPROM 12 минута полива
EEPROM 13 час полива
 4 линия полива
EEPROM 14 1/0 включение отключение полива (0=off / 1=on)
EEPROM 15 Продолжительность минут полива
EEPROM 16 минута полива
EEPROM 17 час полива
*/

//LCD I2C 20x4
#include <EEPROM.h>
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
LiquidCrystal_I2C lcd(0x27,20,4);
//LCD



//кнопка
// задаем константы кнопок и присваиваем им пины
const int buttonPin = 15;     // центральная кнопка
const int buttonPin_1 = 14;  //левая кнопка 
const int buttonPin_0 = 16;  //правая кнопка
const int ledPin =  13;      // номер выхода светодиода индикатора
const int irr_valve_1 = 30; //№ pin'a первая линия полива
const int irr_valve_2 = 31; //№ pin'a вторая линия полива
const int irr_valve_3 = 32; //№ pin'a третья линия полива
const int irr_valve_4 = 33; //№ pin'a четвёртая линия полива

// пины управления актуатором
const int open_actuator = 34; //открыть актуатор пином 34
const int close_actuator = 35; //закрыть актуатор пином 35

//пин управления насосом, который заполняет бочку для полива
const int nasos = 36;
const int sensor_min_level_tank = 26; //дискретный датчик нижнего уровня воды на 26 пине.
const int sensor_max_level_tank = 27;
int sensor_min_level_state= 1; //
int sensor_max_level_state= 1;



/*
int on_off_1 = EEPROM.read(2);
int dur_1 = EEPROM.read(3);
int min_dur_1 = EEPROM.read(4);
int hour_dur_1 = EEPROM.read(5);

int on_off_2 = EEPROM.read(6);
int dur_2 = EEPROM.read(7);
int min_dur_2 = EEPROM.read(8);
int hour_dur_2 = EEPROM.read(9);

int on_off_3 = EEPROM.read(10);
int dur_3 = EEPROM.read(11);
int min_dur_3 = EEPROM.read(12);
int hour_dur_3 = EEPROM.read(13);

int on_off_4 = EEPROM.read(14);
int dur_4 = EEPROM.read(15);
int min_dur_4 = EEPROM.read(16);
int hour_dur_4 = EEPROM.read(17);
*/
// глобальные переменные
int centreBtn = 0;         // переменная для хранения состояния центральной кнопки
int leftbtn = 0;     // переменная для хранения состояния левой кнопки
int rightbtn = 0;     // переменная для хранения состояния правой кнопки
/*
String irr_time =""; //переменная строки времени полива
String irr_time_2 =""; //переменная строки времени полива
String irr_time_3 =""; //переменная строки времени полива
String irr_time_4 =""; //переменная строки времени полива

String end_irr_time ="";
String end_irr_time_2 ="";
String end_irr_time_3 ="";
String end_irr_time_4 ="";
*/
int del = 500; // переменная ожидания между выборами меню(время горения ledpin в милисек)
//подсветка LCD
//int r=0;
long previousMillis = 0;        // храним время
long interval_2 = 10000; //задержка подсветки
long interval_3 = 1000; //задержка записи на SD
// интервал 
//переменные автовозврата в loop 
int interval = 50;    // интервал сколько будет длиться цикл while, после чего перейдёт к следующему меню.(кол-во итераций)
//

int valve_1[5] = {1,2,3,4,5};
int valve_2[5] = {2,6,7,8,9};
int valve_3[5] = {3,10,11,12,13};
int valve_4[5] = {4,14,15,16,17};


//ds1307 модуль часов реального времени
#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 rtc;
//строка времени
String Date; //строка даты

String Time; //времени
//--ds1307

//ds1820 temp
#include <OneWire.h>
#include <DallasTemperature.h>
 // Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE_BUS 3
 // Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
 // Pass our oneWire reference to Dallas Temperature. 
DallasTemperature sensors(&oneWire);
//float in_tempC;
//float out_tempC;
//--ds1820

//SD card
#include <SPI.h>
#include <SD.h>
File myFile;

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void setup() {
//LCD
#ifdef AVR
Wire.begin();
#else
Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino Due
#endif
lcd.init();   // initialize the lcd 
lcd.backlight();
//--LCD

// initialize the button pin as a input:

// initialize the LED as an output:
pinMode(ledPin, OUTPUT);
pinMode(irr_valve_1, OUTPUT);
pinMode(irr_valve_2, OUTPUT);
pinMode(irr_valve_3, OUTPUT);
pinMode(irr_valve_4, OUTPUT);

pinMode(open_actuator, OUTPUT);
pinMode(close_actuator, OUTPUT);


digitalWrite(irr_valve_1, HIGH);
digitalWrite(irr_valve_2, HIGH);
digitalWrite(irr_valve_3, HIGH);
digitalWrite(irr_valve_4, HIGH);

digitalWrite(open_actuator, HIGH);
digitalWrite(close_actuator, HIGH);

digitalWrite(ledPin, HIGH); 
// initialize serial communication:
Serial.begin(9600);

    
// инициализируем пин, подключенный к кнопке, как вход
pinMode(buttonPin, INPUT);   
pinMode(buttonPin_0, INPUT);   
pinMode(buttonPin_1, INPUT);   

pinMode(nasos, OUTPUT);
pinMode(sensor_min_level_tank, INPUT);
pinMode(sensor_max_level_tank, INPUT);



//ds1307
#ifdef AVR
  Wire.begin();
#else
  Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino Due
#endif
  rtc.begin();

  if (! rtc.isrunning()) {
    Serial.println("RTC is NOT running!");
    // following line sets the RTC to the date & time this sketch was compiled 
    rtc.adjust(DateTime(__DATE__, __TIME__)); //строка установки системного времени во время компиляции скеча
  }
//--ds1307  

//sd
pinMode(53, OUTPUT);
if (!SD.begin(53)) {
    Serial.println("initialization SD flash card failed!");
    return;
  }
  Serial.println("initialization SD flash card done.");

}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//#########################################################################################################
void loop() {
//if (LCD_LED){lcd.backlight();}
time();
termostat();
//temp();  

irrigation(valve_1[0],valve_1[1],valve_1[2],valve_1[3],valve_1[4], irr_valve_1);
irrigation(valve_2[0],valve_2[1],valve_2[2],valve_2[3],valve_2[4], irr_valve_2);
irrigation(valve_3[0],valve_3[1],valve_3[2],valve_3[3],valve_3[4], irr_valve_3);
irrigation(valve_4[0],valve_4[1],valve_4[2],valve_4[3],valve_4[4], irr_valve_4);



lcd.setCursor(0,0);
  lcd.print("in= ");
  lcd.print(temp_in());
  lcd.print(" out= ");
  lcd.print(temp_out()); 
//  lcd.setCursor(0,1);
//  lcd.print(irr_time);
  lcd.print("");  
//  lcd.print(end_irr_time);
  lcd.print("");  
//  lcd.print(EEPROM.read(2));
  
  lcd.setCursor(0,2);
  lcd.print(Date);
  lcd.print("  ");
  lcd.print(Time);
  lcd.setCursor(0,3);
  lcd.print("        MENU        ");

  button_read(); //читаем кнопки // проверяем нажата ли кнопка
 
  if (centreBtn) {   // проверяем нажата ли кнопка если нажата, то 
//    LCD_LED = 1;
//    lcd.backlight();
    lcd.backlight();
    digitalWrite(ledPin, LOW);
    delay(del);// включаем светодиод   
    lcd.clear(); //очищаем экран
    digitalWrite(ledPin, HIGH);
    menu();
}

if (leftbtn) {   //включить подсветочку
   lcd.backlight(); 
  open_windows(); 
   //digitalWrite(ledPin, LOW);             
   //LCD_LED();      
   //delay(del);
   //digitalWrite(ledPin, HIGH);            
       }     
if (rightbtn) {
    lcd.backlight(); 
  close_windows(); 
} 

LCD_LED_OFF(); //таймер отключения подсветки



}
//##########################################################################################################33

void menu()
{
actuator_setup();
irrigtion_setup();
irrigation_set_time();

}

void actuator_setup()
{
int x =0;

  lcd.clear(); //очищаем экран

while(1){ // цикл 
x++;
if (x>interval){break;}

  button_read();

  lcd.setCursor(0,0);
  lcd.print(" -=ACTUATOR SETUP=- ");

  int t_mini = EEPROM.read(0);
  lcd.setCursor(0,1);
  lcd.print("min = ");
  lcd.print(t_mini);
  lcd.print((char)223);

  int t_maxi = EEPROM.read(1);
  lcd.setCursor(11,1);
  lcd.print("max = ");
  lcd.print(t_maxi);
  lcd.print((char)223);                   

  lcd.setCursor(0,2);
  lcd.print("____________________");

  lcd.setCursor(0,3);
  lcd.print("T_MIN   NEXT   T_MAX");
  digitalWrite(ledPin, HIGH);
  
   
if (centreBtn) {   
 digitalWrite(ledPin, LOW);             
 delay(del);// включаем светодиод   
 lcd.clear(); //очищаем экран
 digitalWrite(ledPin, HIGH);
 break; }
                      
 if (leftbtn) {   
 digitalWrite(ledPin, LOW);             
   lcd.clear();
        t_min();
       delay(del);
       lcd.clear(); //очищаем экран
       x =0;   
       digitalWrite(ledPin, HIGH);            
       }       
    
if (rightbtn) {   
       digitalWrite(ledPin, LOW);             
       lcd.clear();
        t_max();
       delay(del);// включаем светодиод   
       lcd.clear(); //очищаем экран
       x =0;           
       digitalWrite(ledPin, HIGH);
      }  
  
 }}


void irrigtion_setup()
{
int y =0;  
lcd.clear(); //очищаем экран
while(1){ //бесконечный цикл 
y++;
if (y>interval){break;} //выйти из цикла при y>interval
button_read();

 lcd.setCursor(0,0);
 lcd.print("-=IRRIGATION SETUP=-");
// int on_off = EEPROM.read(2);
//String x;
// if (on_off == 1) {x="ON";}
// if (on_off == 0) {x="OFF";}



 lcd.setCursor(0,1);
 lcd.print("1 ch=");
 lcd.print(on_or_off(valve_1[1])); //вызываем функцию on_or_off передаём ей параметр 2 символ массива, возвращаем string ON или OFF

 lcd.setCursor(10,1);
 lcd.print("3 ch=");
 lcd.print(on_or_off(valve_3[1]));
 
  lcd.setCursor(0,2);
 lcd.print("2 ch=");
 lcd.print(on_or_off(valve_2[1]));
 
  lcd.setCursor(10,2);
lcd.print("4 ch=");
 lcd.print(on_or_off(valve_4[1]));

/*
 int duration = EEPROM.read(3);
 lcd.setCursor(10,1);
 lcd.print("dur=");
 lcd.print(duration);
 lcd.print("min");                   
 lcd.setCursor(0,2);
 lcd.print("____________________"); 
 */
 lcd.setCursor(0,3);

 lcd.print("ON/OFF NEXT DURATION");
//                   digitalWrite(ledPin, HIGH);
    if (centreBtn) {   
           digitalWrite(ledPin, LOW);             
           delay(del);// включаем светодиод   
           lcd.clear(); //очищаем экран
            break;
           }
    
    if (rightbtn) {   
           digitalWrite(ledPin, LOW);             
           lcd.clear();
            durration_irrigation(valve_1[0],valve_1[1],valve_1[2],valve_1[3],valve_1[4]);
            durration_irrigation(valve_2[0],valve_2[1],valve_2[2],valve_2[3],valve_2[4]);
            durration_irrigation(valve_3[0],valve_3[1],valve_3[2],valve_3[3],valve_3[4]);
            durration_irrigation(valve_4[0],valve_4[1],valve_4[2],valve_4[3],valve_4[4]);
            
           delay(del);// включаем светодиод   
               lcd.clear(); //очищаем экран
           y =0;   
           digitalWrite(ledPin, HIGH);            
           }       
        
    if (leftbtn) {   
           digitalWrite(ledPin, LOW);             
           lcd.clear();
            on_off_irrigation(valve_1[0],valve_1[1]);
            on_off_irrigation(valve_2[0],valve_2[1]);
            on_off_irrigation(valve_3[0],valve_3[1]);
            on_off_irrigation(valve_4[0],valve_4[1]);
            
            
            //on_off_irrigation();  
           delay(del);// включаем светодиод   
           lcd.clear(); //очищаем экран
           y =0;            
           digitalWrite(ledPin, HIGH);
          }  
 

 }}

void irrigation_set_time()
{
int x =0;
lcd.clear(); //очищаем экран
while(1){ //бесконечный цикл 
x++;
if (x>interval){break;}
button_read();
//string_irrigation_time(); //выполняем функцию строки времени полива для отображения переменной irr_time
 lcd.setCursor(0,0);
 lcd.print("IRRIGATION SET TIME");
 lcd.setCursor(0,1);
 lcd.print("1: ");
 lcd.print(string_irrigation_time(valve_1[0],valve_1[1],valve_1[2],valve_1[3],valve_1[4]));
 lcd.print(" ");
 lcd.print(string_irrigation_time(valve_3[0],valve_3[1],valve_3[2],valve_3[3],valve_3[4]));
 lcd.setCursor(0,2);
 lcd.print("2: ");
 lcd.print(string_irrigation_time(valve_2[0],valve_2[1],valve_2[2],valve_2[3],valve_2[4]));
 lcd.print(" ");
 lcd.print(string_irrigation_time(valve_4[0],valve_4[1],valve_4[2],valve_4[3],valve_4[4]));
// lcd.print(irr_time); //выводим переменную строки времени полива 



 lcd.setCursor(0,3);
 lcd.print("hours   NEXT  minuts");
 digitalWrite(ledPin, HIGH);
if (centreBtn) {   
       digitalWrite(ledPin, LOW);             
       delay(del);// включаем светодиод   
       lcd.clear(); //очищаем экран
       digitalWrite(ledPin, HIGH);
       break;
       }

if (leftbtn) {   
       digitalWrite(ledPin, LOW);             
       lcd.clear();
       irrigation_set_hours(valve_1[0],valve_1[1],valve_1[2],valve_1[3],valve_1[4]);
       irrigation_set_hours(valve_2[0],valve_2[1],valve_2[2],valve_2[3],valve_2[4]);
       irrigation_set_hours(valve_3[0],valve_3[1],valve_3[2],valve_3[3],valve_3[4]);
       irrigation_set_hours(valve_4[0],valve_4[1],valve_4[2],valve_4[3],valve_4[4]);
       delay(del);
       lcd.clear(); //очищаем экран
       x =0;   
       digitalWrite(ledPin, HIGH);            
       }       
    
if (rightbtn) {   
       digitalWrite(ledPin, LOW);             
       lcd.clear();
        irrigation_set_minuts(valve_1[0],valve_1[1],valve_1[2],valve_1[3],valve_1[4]);
        irrigation_set_minuts(valve_2[0],valve_2[1],valve_2[2],valve_2[3],valve_2[4]);
        irrigation_set_minuts(valve_3[0],valve_3[1],valve_3[2],valve_3[3],valve_3[4]);
        irrigation_set_minuts(valve_4[0],valve_4[1],valve_4[2],valve_4[3],valve_4[4]);

       delay(del);// включаем светодиод   
       lcd.clear(); //очищаем экран
       x =0;            
       digitalWrite(ledPin, HIGH);
      }  

 }}



//////--------------------------------------------------------------------------
//SUB MENU

void t_min()
{

lcd.clear(); //очищаем экран
delay(del);
while(1){ //бесконечный цикл 
button_read();

 lcd.setCursor(0,0);
 lcd.print(" TEMP MINIMUM SETUP");
 int t_min = EEPROM.read(0);
 lcd.setCursor(0,1);
 lcd.print("t = ");
 lcd.print(t_min);
 lcd.print((char)223);
 lcd.print("C");                   
 lcd.setCursor(0,3);
 lcd.print("t_min-1 NEXT t_min+1");
 lcd.setCursor(0,2);
 lcd.print("____________________");

 digitalWrite(ledPin, HIGH);
    if (centreBtn) {   
           digitalWrite(ledPin, LOW);             
           delay(del);// включаем светодиод   
           lcd.clear(); //очищаем экран
           digitalWrite(ledPin, HIGH);
           break;

           }
    
    if (rightbtn) {   
            delay(del);     
            digitalWrite(ledPin, LOW);             
            lcd.clear();
            EEPROM.write(0, t_min + 1);
            digitalWrite(ledPin, HIGH);            
           }       
        
    if (leftbtn) {   
          delay(del); 
          digitalWrite(ledPin, LOW);             
          lcd.clear();
          EEPROM.write(0, t_min - 1);
          digitalWrite(ledPin, HIGH);
          }  
 
 }
}

void t_max()
{

lcd.clear(); //очищаем экран
delay(del);
while(1){ //бесконечный цикл 
button_read();

 lcd.setCursor(0,0);
 lcd.print(" TEMP MAXIMUM SETUP");
 int t_max = EEPROM.read(1);
 lcd.setCursor(0,1);
 lcd.print("t = ");
 lcd.print(t_max);
 lcd.print((char)223);
 lcd.print("C");                   
 lcd.setCursor(0,3);
 lcd.print("t_max-1 NEXT t_max+1");
 lcd.setCursor(0,2);
 lcd.print("____________________");

 digitalWrite(ledPin, HIGH);
    if (centreBtn) {   
           digitalWrite(ledPin, LOW);             
           delay(del);// включаем светодиод   
           lcd.clear(); //очищаем экран
           digitalWrite(ledPin, HIGH);
           break;

           }
    
    if (rightbtn) {   
            delay(del);     
            digitalWrite(ledPin, LOW);             
            lcd.clear();
            EEPROM.write(1, t_max + 1);
            digitalWrite(ledPin, HIGH);            
           }       
        
    if (leftbtn) {   
          delay(del); 
          digitalWrite(ledPin, LOW);             
          lcd.clear();
          EEPROM.write(1, t_max - 1);
          digitalWrite(ledPin, HIGH);
          }  
 
 }
}

void on_off_irrigation(int ch,int on_off_x)
{

lcd.clear(); //очищаем экран
delay(del);
while(1){ //бесконечный цикл 
button_read();

 lcd.setCursor(0,0);
 lcd.print("ON/OFF IRRIGATION");
 //int on_off = EEPROM.read(on_off_x);
 //String x;
 //if (on_off == 1) {x="ON";}
 //if (on_off == 0) {x="OFF";}


 lcd.setCursor(0,2);
 lcd.print("irrigation = ");
 lcd.print(on_or_off(on_off_x));
 //lcd.print(on_off);
 lcd.setCursor(0,1);
 lcd.print("chanel N=");
 lcd.print(ch);
 lcd.setCursor(0,3);
 lcd.print("ON      NEXT     OFF");


 digitalWrite(ledPin, HIGH);
    if (centreBtn) {   
           digitalWrite(ledPin, LOW);             
           delay(del);// включаем светодиод   
           lcd.clear(); //очищаем экран
           digitalWrite(ledPin, HIGH);
           break;

           }
    
    if (rightbtn) {   
            delay(del);     
            digitalWrite(ledPin, LOW);             
            lcd.clear();
            EEPROM.write(on_off_x, 0);
            digitalWrite(ledPin, HIGH);            
           }       
        
    if (leftbtn) {   
          delay(del); 
          digitalWrite(ledPin, LOW);             
          lcd.clear();
          EEPROM.write(on_off_x, 1);
          digitalWrite(ledPin, HIGH);
          }  
 
 }
}
void durration_irrigation(int ch,int on_off_x, int dur, int min_dur, int hour_dur)
{

lcd.clear(); //очищаем экран
delay(del);
while(1){ //бесконечный цикл 
button_read();
string_end_irrigation_time(ch, on_off_x, dur, min_dur, hour_dur);
 lcd.setCursor(0,0);
 lcd.print("DURRATION IRRIGATIN");
 int duration = EEPROM.read(dur);
 lcd.setCursor(0,1);
 lcd.print("ch N=");
 lcd.print(ch);
 lcd.print(" dur=");
 lcd.print(duration);
 lcd.print(" min");                   
 lcd.setCursor(0,3);
 lcd.print("-1min   NEXT   +1min");
 lcd.setCursor(0,2);
 lcd.print(string_irrigation_time(ch, on_off_x, dur, min_dur, hour_dur)); 
 lcd.print("    ");
 lcd.print(string_end_irrigation_time(ch, on_off_x, dur, min_dur, hour_dur));

 digitalWrite(ledPin, HIGH);
    if (centreBtn) {   
           digitalWrite(ledPin, LOW);             
           delay(del);// включаем светодиод   
           lcd.clear(); //очищаем экран
           digitalWrite(ledPin, HIGH);
           break;

           }
    
    if (rightbtn) {   
            delay(del);     
            digitalWrite(ledPin, LOW);             
            lcd.clear();
            EEPROM.write(dur, duration + 1);
            digitalWrite(ledPin, HIGH);            
           }       
        
    if (leftbtn) {   
          delay(del); 
          digitalWrite(ledPin, LOW);             
          lcd.clear();
          EEPROM.write(dur, duration - 1);
          digitalWrite(ledPin, HIGH);
          }  
 
 }
}

void irrigation_set_minuts(int ch,int on_off_x, int dur, int min_dur, int hour_dur)
{

lcd.clear(); //очищаем экран
delay(del);
while(1){ //бесконечный цикл 
button_read();
//string_irrigation_time();
 lcd.setCursor(0,0);
 lcd.print("SET IRR-TION MINUTES");
 int minuts = EEPROM.read(min_dur);
 lcd.setCursor(0,1);
 lcd.print("ch N_");
 lcd.print(ch);
 lcd.print("= ");
 
 lcd.print(string_irrigation_time(ch, on_off_x, dur, min_dur, hour_dur));
// lcd.print("min");                   
 lcd.setCursor(0,2);
 lcd.print("____________________");
 lcd.setCursor(0,3);
 lcd.print("-1min   NEXT   +1min");
 digitalWrite(ledPin, HIGH);
  
    if (centreBtn) {   
           digitalWrite(ledPin, LOW);             
           delay(del);// включаем светодиод   
           lcd.clear(); //очищаем экран
           digitalWrite(ledPin, HIGH);
           break;
           }
    
    if (rightbtn) {   
            delay(del);     
            digitalWrite(ledPin, LOW);             
            lcd.clear();
            minuts = minuts + 1;
            if (minuts >59){minuts=0;}
            EEPROM.write(min_dur, minuts);
            digitalWrite(ledPin, HIGH);            
           }       
        
    if (leftbtn) {   
          delay(del); 
          digitalWrite(ledPin, LOW);             
          lcd.clear();
          minuts = minuts - 1;
          if (minuts < 0) {minuts=59;}
          EEPROM.write(min_dur, minuts);
          digitalWrite(ledPin, HIGH);
          }  
 
 }

}
void irrigation_set_hours(int ch,int on_off_x, int dur, int min_dur, int hour_dur)
{

lcd.clear(); //очищаем экран
delay(del);
while(1){ //бесконечный цикл
button_read();
//string_irrigation_time();
 lcd.setCursor(0,0);
 lcd.print(" SET IRR-TION HOURS");
 int hours = EEPROM.read(hour_dur);
 lcd.setCursor(0,1);
  lcd.print("ch N_");
 lcd.print(ch);
 lcd.print("= ");
 lcd.print(string_irrigation_time(ch, on_off_x, dur, min_dur, hour_dur));
// lcd.print("min");                   
 lcd.setCursor(0,2);
 lcd.print("____________________");
 lcd.setCursor(0,3);
 lcd.print("-1hour  NEXT  +1hour");

 digitalWrite(ledPin, HIGH);
    if (centreBtn) {   
           digitalWrite(ledPin, LOW);             
           delay(del);// включаем светодиод   
               lcd.clear(); //очищаем экран
               digitalWrite(ledPin, HIGH);
               break;
           
           }
    
    if (rightbtn) {   
            delay(del);     
            digitalWrite(ledPin, LOW);             
            lcd.clear();
            hours = hours + 1;
            if (hours >23){hours=0;}
            EEPROM.write(hour_dur, hours);
            digitalWrite(ledPin, HIGH);            
           }       
        
    if (leftbtn) {   
          delay(del); 
          digitalWrite(ledPin, LOW);             
          lcd.clear();
          hours = hours - 1;
          if (hours < 0) {hours=23;}
          EEPROM.write(hour_dur, hours);
          digitalWrite(ledPin, HIGH);
          }  
 }
}
String string_irrigation_time(int ch, int on_off_x, int dur, int min_dur, int hour_dur) // функция формирования строки времни полива
{
String irr_time = ""; //очистим глобальную переменную навсякий случай. 


 int minuts = EEPROM.read(min_dur); //читаем память
 int hours = EEPROM.read(hour_dur);
 if (hours >= 0 && hours <=9) {irr_time += 0; irr_time += hours;} else{irr_time += hours;} //дописываем нолик для hours
 
 irr_time += ":";
 if (minuts >= 0 && minuts <=9){irr_time += 0; irr_time += minuts;} else{irr_time += minuts;} //дописываем нолик для minuts
 
 
 irr_time += ":";
 irr_time += "00"; //собрали строку времени полива
// lcd.setCursor(0,1);
// lcd.print("irr_time=");
// lcd.print(irr_time);
return irr_time;
}

String string_end_irrigation_time(int ch, int on_off_x, int dur, int min_dur, int hour_dur) // функция формирования строки времни полива
{
String end_irr_time = ""; //очистим глобальную переменную навсякий случай. 

 int minuts = EEPROM.read(min_dur) + EEPROM.read(dur); //читаем память
 int hours = EEPROM.read(hour_dur);
 if (minuts > 59) {int x = minuts / 60; hours += x; int y = x * 60; minuts -= y;}
 if (hours >= 0 && hours <=9) {end_irr_time += 0; end_irr_time += hours;} else{end_irr_time += hours;} //дописываем нолик для hours
 
 end_irr_time += ":";
 if (minuts >= 0 && minuts <=9){end_irr_time += 0; end_irr_time += minuts;} else{end_irr_time += minuts;} //дописываем нолик для minuts
  
 end_irr_time += ":";
 end_irr_time += "00"; //собрали строку времени полива
// lcd.setCursor(0,1);
// lcd.print("irr_time=");
// lcd.print(irr_time);
return end_irr_time;
}

void button_read() //функция проверки нажатия кнопки
{
centreBtn = digitalRead(buttonPin); //запоминаем значение кнопки
rightbtn = digitalRead(buttonPin_0); //запоминаем значение кнопки
leftbtn = digitalRead(buttonPin_1); //запоминаем значение кнопки
}
void LCD_LED_OFF()//таймер отключения подсветки
{
  unsigned long currentMillis = millis();
  //проверяем не прошел ли нужный интервал, если прошел то
  if(currentMillis - previousMillis > interval_2) {
   // сохраняем время последнего переключения
   previousMillis = currentMillis; 
 lcd.noBacklight();        
//  lcd.setCursor(0,3);
 // lcd.print("led");
 // if(r==0)
//      {lcd.print("led off"); r=1;  lcd.noBacklight();    } 
 // else if(r==1)//если кнопка НЕ нажата 
  //    {lcd.print("led on"); r=0;   lcd.backlight();     } 
}
}

void time() //функция строки времени
{    
//  int x;
  DateTime now = rtc.now();
    Date = "";
    Date += now.year();
    Date += "/";
     if (now.month() >=0 && now.month() <=9)
     {
      Date += "0";
      Date += now.month();
     } else {Date += now.month();}
  Date += "/";
     if (now.day() >= 0 && now.day() <=9)
     {
       Date += "0";
       Date += now.day();
     } else {Date += now.day();}
   //dataString += " ";
     Time ="";
     if (now.hour() >= 0 && now.hour() <=9 )
     { 
       
       Time += "0";
       Time += now.hour();
     } else {Time += now.hour();}
   Time += ":";
     if (now.minute() >= 0 && now.minute() <=9 )
     {
       Time += "0";
       Time += now.minute();
     } else {Time += now.minute();}
    Time += ":";
      if (now.second() >= 0 && now.second() <= 9)
      {
      Time += "0";
      Time += now.second();
      }
     else {Time += now.second();}
 //   Time += " ";
}
float temp_in()
 {
   sensors.requestTemperatures(); // Send the command to get temperatures
  float in_tempC = sensors.getTempCByIndex(0);
return in_tempC;
}

float temp_out()
 {
   sensors.requestTemperatures(); // Send the command to get temperatures
float out_tempC = sensors.getTempCByIndex(1);
return out_tempC;
 }

void irrigation(int ch, int on_off_x, int dur, int min_dur, int hour_dur, int irr_valve)
{
 int x=EEPROM.read(on_off_x);
 if (x == 1){
//  string_irrigation_time(ch, on_off_x, dur, min_dur, hour_dur);
//  string_end_irrigation_time(ch, on_off_x, dur, min_dur, hour_dur);
    if(string_irrigation_time(ch, on_off_x, dur, min_dur, hour_dur) == Time)
    {
      digitalWrite(irr_valve, LOW); 
      Serial.print("ch: ");
      Serial.print(ch);
      Serial.print(" ");
      Serial.print("pin: ");
      Serial.print(irr_valve);
      Serial.print(" ");
      Serial.print("Status: ");
      Serial.println(" ON");
      
      String file_name = "irrigat.txt";
      String  value = "";
              value += ch;
             value += ";1;";
             sd_write (file_name, value);
      
    }
    if(string_end_irrigation_time(ch, on_off_x, dur, min_dur, hour_dur) == Time)
    {
      digitalWrite(irr_valve, HIGH);
      Serial.print("ch: ");
      Serial.print(ch);
      Serial.print(" ");
      Serial.print("pin: ");
      Serial.print(irr_valve);
      Serial.print(" ");
      Serial.print("Status: ");
      Serial.println(" OFF");
      
      String file_name = "irrigat.txt";
      String  value = "" ;
              value += ch;
             value += ";0;";
             sd_write (file_name, value);
}
}

}

String on_or_off (int on_off)
{
int z = EEPROM.read(on_off);
  String x;
 if (z == 1) {x="ON";}
 if (z == 0) {x="OFF";}
 return x;
}

int termostat ()
{
int temp_min = EEPROM.read(0);
int temp_max = EEPROM.read(1);
  if (temp_out() > temp_max && digitalRead(close_actuator)==LOW)
  {
    open_windows();
  }

  if (temp_out() < temp_min && digitalRead(open_actuator)==LOW)
  {
  close_windows();
  }
}
void open_windows()
{
    digitalWrite(close_actuator, HIGH);
    delay(1000);
    digitalWrite(open_actuator, LOW);

//    lcd.setCursor(0,0);
 //   lcd.print("Open window");   
    lcd.setCursor(0,1);
    lcd.print("OPEN ACTUATOR");
String file_name = "actuator.txt";
String value = "1";
sd_write (file_name, value);
}
void close_windows()
{
    digitalWrite(open_actuator, HIGH);
    delay(1000);
    digitalWrite(close_actuator, LOW);

//    lcd.setCursor(0,0);
 //   lcd.print("Open window");   
    lcd.setCursor(0,1);
    lcd.print("CLOSE ACTUATOR");
    String file_name = "actuator.txt";
    String value = "0";
    sd_write (file_name, value);
}
int _nasos()
{
sensor_min_level_state = digitalRead(sensor_min_level_tank);
sensor_max_level_state = digitalRead(sensor_max_level_tank);
if (sensor_min_level_state == LOW) 
 {
 digitalWrite(nasos, HIGH);
      String file_name = "nasos.txt";
      String value = "0";
      sd_write (file_name, value);
 }
if (sensor_max_level_state == HIGH)
 {
 digitalWrite(nasos,LOW);
      String file_name = "nasos.txt";
      String value = "1";
      sd_write (file_name, value);
 }

}

int sd_write (String file_name, String value)
{
unsigned long currentMillis = millis();
  //проверяем не прошел ли нужный интервал, если прошел то
  if(currentMillis - previousMillis > interval_3) {
   // сохраняем время последнего переключения
   previousMillis = currentMillis; 
 
char f_n[file_name.length()+1];
file_name.toCharArray(f_n, file_name.length()+1);
myFile = SD.open(f_n , FILE_WRITE);
//myFile = SD.open(file_name.c_str() , FILE_WRITE);
  
  // if the file opened okay, write to it:
  if (myFile) {
    Serial.print("Writing to ");
    Serial.print(f_n);
//    Serial.print(file_name.c_str());
    Serial.print(" ");
    myFile.print(Date);
    myFile.print(";");
    myFile.print(Time);
    myFile.print(";");
    myFile.println(value);
    	// close the file:
    myFile.close();
    Serial.print("done. Writed: ");
    Serial.print(Date);
    Serial.print(";");
    Serial.print(Time);
    Serial.print(";");
    Serial.println(value);
    return(1);
  } else {
    // if the file didn't open, print an error:
    Serial.println("error opening sd card. File: ");
    Serial.print(file_name.c_str());
    return(0);
    
  }
  }
}

 

Не только сложней, но и перешли рубеж в 32к , прошивка весит 34 466 байт -  для уно-нано много, для мега мало. Надо бы этот проект оставить на 32, а дальше новый проект Умная теплица №2.

я вроде писал что перешёл на мегу из-за нехватки памяти и pinнов на уно.

получится идеальный проект - нанотехнологичный.

*видишь суслика? - нанотехнологии!

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

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

Таймер есть смысл использовать с единственной целью - обеспечить самый минимум, на тот случай если произойдет сбойчик в определении влажности и тп...  Таймер должен включать полив если прошло слишком много времени после последнего включения. Короче принцип тот же как запуск скринсейвера ну или что то типа WDT.

Probelzaelo, Вы практик или теоретик ? 

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

Вы делали полив на основе датчика влажности ? Так чтобы он не один день поработал, поливал теплицу, а не горшок ?

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

А полив по датчику влажности приносит другие проблемы:

1. электроды окисляются. Нержавейка в том числе (чем-то покрывается)

4. Калибровку на каждую грядку одинаково сделать невозможно

3. Датчик будет показывать разные значения в зависимости от место положения относительно системы орошения - вкапывать датчик под каждое растение это не рационально.

4. Почву возле электродом нужно рыхлить постоянно - иначе она быстро трамбуется и меняет свои свойства по намачиваемости относительно первоначально выставленных.

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

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

нужен проект ti-tan@yandex.ru

Если уж на то пошло, то специалист. это и практик и теоретик с одним флаконом.

первое -Электроды бывают совсем не металлические.

Второе измерительная схема вносит не малый вклад в окислительные процессы.

Обсалютно одинаково и не нужно. Все относительно, а полупроцентная точность тут не нужна.

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

Да, за датчиками нужно следить. нельзя надеяться что воткнутый в землю датчик проработает на отлично весь сезон. Датчики нуждаются в обслуживании - периодической чистке, мойке, замене, калибровке. это гораздо реже чем регулярный полив. можно с этой задачей и смириться.

Прекрасно. получается значит...

Все правильно потребности культуры главный норматив. если бы еще эту культуры научить включать поливалку...

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

 

Всем привет. Прошлый сезон в теплице сделали капельный полив и столкнулись с проблемой засорения сопл, также т.к. погода была холодная и мокрая, полив по таймеру привел к переливу. Решил осваивать Arduino и все автомитизировать. В январе только привезли. 3 месяца ждал.

В наличии есть такой сенсор влажности, yl-38 + yl-69. Еще не подключал. Может кто имел практику с таким сенсором?

Засорение сопл это стандартная проблема... Жёсткая вода, грязь, налёт....

По сенсору: cразу меняй на электроды из нержавейки=) Эта тема уже не раз обсуждалась. И этот сенсор больше подходит для одного горшка.  И подумай, как ты одним сенсором будешь определять влажность нескольких грядок? В идеале сенсор надо ставить под каждое растение.

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

 Понимаю что стандартная проблема. Я вот, пробовал использовать топливный фильтр для авто. Помогает конечно, но приходилось менять каждую вторую неделю. Наверное нужен отстойник для воды. У меня вода подается из общей бочки самотеком.

Про проблемы сдатчика влажности читал в обсуждениях. Контакты окисляются только в рабочем состоянии сенсора? Конечно по хорошему, надо за ними следить, ставить сенсор под каждое растение и поливать каждое по необходимости. Но мне кажется это уже слишком. И как полить одно растение?

Согласен что сенсор необходим и актуален только для горшка или для общей картины в теплице. И следить за ним тоже необходимо.

Подключил свой сенсор и вот что сранно незамкнутый показывает 1023, в воде 430-480, а в мокрой земле 250, непонимаю почему  в воде показывает влажность меньше чем в мокрой земле?

Вчера спалил 4 канальный релейный модуль. 5 вольтовый подключил к 12 вольтам, что то переклинело меня:). Жаль.

Вода относительно чистая, а в земле разные соли - электропроводность выше.

Если на платке есть транзисторные ключи, то спалил наверняка их, не реле. Заменить можно.

Вот так поливают каждое по отдельности ))

http://www.youtube.com/watch?v=dL1PuS4LVWQ

 

Про влажность понятно.

На плате есть транзистеры с маркеровкой J3Y. Возможно и они. Думаю починим.

Это сильно зависит от глубины погружения сенсора, т.к. "горизонт" у грядок даже на наших болотах может быть чуть разный. И если для цветочного горшка достаточно 10 см, то на грунт, как мне кажется, надо щупы делать длиной сантиметров 20-25 (как раз длина 3мм сварочного электрода).

прозвонить и поменять, на любые N-P-N в том же размере. но я бы предварительно прозвонил и релюшки. они тоже запросто могли накрыться при пробое транзисторов. все же 2.5 раза перенапряжение ...

Интересное решение.

http://www.s-manuals.com/ru/smd/j3

http://www.s-manuals.com/pdf/datasheet/s/8/s8050_galaxy.pdf

Судя по даташиту - не должны они были сгореть от 12 вольт