Features:
- control the water in the tank (if to low switch all water tools off)
- control the humidity (if over 70% switch foger off )
- control light (switch light on at 6h00 and off at 23h00)
- control Temp (if under 30°C switch heaters on if over 35°C switch off)
- control Heater (if temp over 45°C switch off under 30°C switch on)
- control rain (set the rain interval to 2h raining delay to 2 min)
- control LCD (2 LCD displays to show infos)
- SD Data logger
- HTML display page (show infos in Auto and in Manual mode switch different output)
- change the stettings over HTML page
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////WIFI CONFIG/////////////////////////////////////////////////////
#include <LTask.h> //WIFI
#include <LWiFi.h> //WIFI
#include <LWiFiServer.h> //WIFI
#include <LWiFiClient.h> //WIFI
#define WIFI_AP "BACK_HOME_1"
#define WIFI_PASSWORD "556890556890"
#define WIFI_AUTH LWIFI_WPA
LWiFiServer server(80);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////I2C BUS CONFIG//////////////////////////////////////////////////
#include <Wire.h> //I2C BUS
#include <LiquidCrystal_I2C.h> //I2C LCD
#include <PortExpander_I2C.h> //PCF8574
#include <RTClib.h> //RTC TINTY Clock
LiquidCrystal_I2C lcd1(0x25,20,4); // set the LCD1 address to 0x25 for a 20 chars and 4 line display
LiquidCrystal_I2C lcd2(0x26,20,4); // set the LCD2 address to 0x26 for a 20 chars and 4 line display
PortExpander_I2C relais_board_1(0x3e); //3e
RTC_DS1307 RTC;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////Temp Sensors////////////////////////////////////////////////////
const int pinTempSensor1 = A1; // port A1
const int pinTempSensor2 = A2; // port A2
int Temp_sens_1; // read wert von temperatur sensor 1
int Temp_sens_2; // read wert von temperatur sensor 2
float temperature_1; //rechnung T wert 1
float temperature_2; //rechnung T wert 2
int B=3975; //B value of the thermistor
float resistance_1; //rechnung R wert 1
float resistance_2; //rechnung R wert 2
char buff[256];
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////IR Sensor///////////////////////////////////////////////////////
#define IR_PROXIMITY_SENSOR A0 // Analog input pin that is attached to the sensor
#define ADC_REF 5//reference voltage of ADC is 5v.If the Vcc switch on the seeeduino
//board switches to 3V3, the ADC_REF should be 3.3
float voltage;//the sensor voltage, you can calculate or find the distance
// to the reflective object according to the figures
//on page 4 or page 5 of the datasheet of the GP2Y0A21YK.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////DHT11///////////////////////////////////////////////////////////
#include <dht11.h> //DHT11
dht11 DHT11_3;
#define DHT11PIN3 7 // port D7
dht11 DHT11_4;
#define DHT11PIN4 4 // port D4
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////Battery/////////////////////////////////////////////////////////
#include <LBattery.h> //Battery
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////CONFIGS/////////////////////////////////////////////////////////
float modus = 0; // 0= AUTO; 1= MANUAL;
float rainDelayOFF = 7200; // Aus Dauer
float rainDelayON = 120; // Ein Dauer
float Hmin =70; // Humindity minimum
float Tmin = 25; // maximale temperature
float Tmax = 30; // minimale temperature
float thermomax = 40; // maximale temperature fr heizmatten
float thermomin = 35; // minimale temperature fr heizmatten
float Lightstart = (6*60*60)+(00*60)+(00); // Einschalt Zeit (06h00)
float Lightstop = (23*60*60)+(00*60)+(00); // Ausschalt Zeit (23h00
float waterlevelmin = 0; // Wasserlevelminimum
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////Values//////////////////////////////////////////////////////////
float VERSION = 0.61; // Version
float ALLESAUS = 0; // Alle Wasserspiele Aus //Don`t edit
float TIME_NOW = 0; //aktuelle Zeit //Don`t edit
float Humy = 0; //aktuelle Humidity //Don`t edit
float Temp = 0; //aktuelle Temp //Don`t edit
float rainTimer = 0; // Rain Timer //Don`t edit
int RAINNEXT = 0; // DISPLAY VALUE //Don`t edit
float DHT11_H3_VALUE = 0; // DISPLAY VALUE //Don`t edit
float DHT11_H3_STATS = 0; // DISPLAY VALUE //Don`t edit
float DHT11_T3_VALUE = 0; // DISPLAY VALUE //Don`t edit
float DHT11_H4_VALUE = 0; // DISPLAY VALUE //Don`t edit
float DHT11_H4_STATS = 0; // DISPLAY VALUE //Don`t edit
float DHT11_T4_VALUE = 0; // DISPLAY VALUE //Don`t edit
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////Linkit One Version/////////////////////////////////////////////////
#include "vmpromng.h"
VMCHAR hostVersion[100] = {0};
VMCHAR buildDateTime[100] = {0};
boolean getVersion(void* userdata)
{
// Retrieve version info string
vm_get_sys_property(MRE_SYS_HOST_VERSION, hostVersion, sizeof(hostVersion));
vm_get_sys_property(MRE_SYS_BUILD_DATE_TIME, buildDateTime, sizeof(buildDateTime));
// Allow remoteCall to return
return true;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////STORAGE/////////////////////////////////////////////////////////
#include <LFlash.h>
#include <LSD.h>
#include <LStorage.h>
// #define Drv LFlash // use Internal 10M Flash
#define Drv LSD // use SD card
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////BOUTTONS///////////////////////////////////////////////////////////
String readString;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////void setup////////////////////////////////////////////////////////////////
void setup()
{
//////////////////////////////////////////////////////WIFI////////////////////////////////////////////////////////////////////
LTask.begin(); // initialize the WIFI
LWiFi.begin(); // initialize the WIFI
Serial.begin(115200);
//while(!Serial.available()); // until something input
//while(Serial.available())Serial.read(); // clear serial data
// keep retrying until connected to AP
Serial.println("Connecting to AP");
while (0 == LWiFi.connect(WIFI_AP, LWiFiLoginInfo(WIFI_AUTH, WIFI_PASSWORD)))
{
delay(1000);
}
Serial.println("Start Server");
server.begin();
Serial.println("Server Started");
//////////////////////////////////////////////////////I2C BUS/////////////////////////////////////////////////////////////////
Wire.begin(); // initialize I2C
RTC.begin(); // initialize RTC
lcd1.init(); // initialize the lcd1
lcd2.init(); // initialize the lcd2
if(! RTC.isrunning())
{
// following line sets the RTC to the date & time this sketch was compiled
RTC.adjust(DateTime(__DATE__, __TIME__));
}
// Relais Board 1
relais_board_1.init();
relais_board_1.digitalWrite(0, HIGH); // turn the LED off --> 230V Relais (NOT IN USE)
relais_board_1.digitalWrite(1, HIGH); // turn the LED off --> Heizung 1
relais_board_1.digitalWrite(2, HIGH); // turn the LED off --> Wasserfallpumpe
relais_board_1.digitalWrite(3, HIGH); // turn the LED off --> Wasserheizung
relais_board_1.digitalWrite(4, HIGH); // turn the LED off --> Nebler
relais_board_1.digitalWrite(5, HIGH); // turn the LED off --> Regenpumpe
relais_board_1.digitalWrite(6, HIGH); // turn the LED off --> Heizung 2
relais_board_1.digitalWrite(7, HIGH); // turn the LED off --> Licht
delay(1000);
// Print a message to the LCD1.
lcd1.backlight();
lcd1.setCursor(3,0);
lcd1.print("Hello, world!");
lcd1.setCursor(5,1);
lcd1.print("Display 1!");
lcd1.setCursor(3,2);
lcd1.print("Terrarium V");
lcd1.setCursor(14,2);
lcd1.print(VERSION);
lcd1.setCursor(2,3);
lcd1.print("By Djpredator69!");
// Print a message to the LCD2.
lcd2.backlight();
lcd2.setCursor(3,0);
lcd2.print("Hello, world!");
lcd2.setCursor(5,1);
lcd2.print("Display 2!");
lcd2.setCursor(3,2);
lcd2.print("Terrarium V");
lcd2.setCursor(14,2);
lcd2.print(VERSION);
lcd2.setCursor(2,3);
lcd2.print("By Djpredator69!");
delay(4000);
lcd1.clear(); // clear lcd1
lcd2.clear(); // clear lcd2
printWifiStatus(); //Wifi infos
lcd2.setCursor(3,1);
lcd2.print("Server Started!");
delay(4000);
lcd1.clear(); // clear lcd1
lcd2.clear(); // clear lcd2
//////////////////////////////////////////////////////////DHT11///////////////////////////////////////////////////////////////
Serial.print("LIBRARY VERSION: ");
Serial.println(DHT11LIB_VERSION);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////Linkit One Version///////////////////////////////////////////////
LTask.remoteCall(getVersion, NULL);
Serial.println("Version Info:");
Serial.println(hostVersion);
Serial.println(buildDateTime);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////STORAGE///////////////////////////////////////////////////////
Drv.begin();
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////Void Loop/////////////////////////////////////////////////////////
void loop()
{
if(modus == 0) //AUTOMATIC
{
////////////////////////////////////////////////////////CALLS///////////////////////////////////////////////////////////////
Timenow(); // Time
light(); // Light
temp_humy(); // Temp Humidity
wasserstand(); // Wasserstand
rain(); // Rain
nebler(); // Nebler
wheizung(); //wandheizung
DISPLAYtoLCD(); // Display all values to LCD1 + LCD2
datalog(); // Data Log
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
else //MANUAL
{
}
HTML(); //Build HTML Page
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////WIFI////////////////////////////////////////////
void printWifiStatus()
{
// print your WiFi shield's IP address:
IPAddress ip = LWiFi.localIP();
lcd1.setCursor(0,0);
lcd1.print("IP");
lcd1.setCursor(5,0);
lcd1.print(ip);
lcd1.setCursor(0,1);
lcd1.print("SubN");
lcd1.setCursor(5,1);
lcd1.print(LWiFi.subnetMask());
lcd1.setCursor(0,2);
lcd1.print("GW");
lcd1.setCursor(5,2);
lcd1.print(LWiFi.gatewayIP());
// print the received signal strength:
long rssi = LWiFi.RSSI();
lcd1.setCursor(0,3);
lcd1.print(LWiFi.SSID());
lcd1.setCursor(17,3);
lcd1.print(rssi);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////Time Now////////////////////////////////////////////////
void Timenow()
{
DateTime now = RTC.now();
int NOW = (now.hour()*60*60)+(now.minute()*60)+(now.second()); // Aktuelle Zeit
if(NOW >= 86401){delay(200); Timenow();}
else if(NOW == 0){delay(200); Timenow();}
else{TIME_NOW = NOW;}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////Light////////////////////////////////////////////////////////
void light()
{
if((TIME_NOW >= Lightstart) && (TIME_NOW <= Lightstop))
{
relais_board_1.digitalWrite(7, LOW); //licht ein
lcd1.backlight(); //LCD 1 ein
lcd2.backlight(); //LCD 2 ein
}else{
relais_board_1.digitalWrite(7, HIGH); //licht aus
lcd1.noBacklight(); //LCD 1 aus
lcd2.noBacklight(); //LCD 2 aus
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////Temp Humidity///////////////////////////////////////////////////
void temp_humy()
{
//werte korecktur
if(DHT11_3.humidity >100){DHT11_3.humidity = 0;}
if(DHT11_4.humidity >100){DHT11_4.humidity = 0;}
if(DHT11_3.temperature >50){DHT11_3.temperature = 0;}
if(DHT11_4.temperature >50){DHT11_4.temperature = 0;}
Humy = ((DHT11_3.humidity)+(DHT11_4.humidity))/2;
Temp = ((DHT11_3.temperature)+(DHT11_4.temperature))/2;
//LCD TEMP HUMIDITY
int chk3 = DHT11_3.read(DHT11PIN3);
switch (chk3)
{ case 0: DHT11_H3_STATS = 1; break;
case -1: DHT11_H3_STATS = 0; break;
case -2: DHT11_H3_STATS = 0; break;
default: DHT11_H3_STATS = 0; break; }
// Sensor 1
///////////////////////////////show this to LCD
DHT11_H3_VALUE = DHT11_3.humidity;
DHT11_T3_VALUE = DHT11_3.temperature;
///////////////////////////////
int chk4 = DHT11_4.read(DHT11PIN4);
switch (chk4)
{ case 0: DHT11_H4_STATS = 1; break;
case -1: DHT11_H4_STATS = 0; break;
case -2: DHT11_H4_STATS = 0; break;
default: DHT11_H4_STATS = 0; break; }
//Sensor 2
///////////////////////////////show this to LCD
DHT11_H4_VALUE = DHT11_4.humidity;
DHT11_T4_VALUE = DHT11_4.temperature;
///////////////////////////////
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////Wasserstand/////////////////////////////////////////////////////
void wasserstand()
{
// Serial.print("sensor voltage = " );
// Serial.println(getVoltage());
//if (getVoltage() <= waterlevelmin)
//{
//relais_board_1.digitalWrite(2, HIGH); // turn the LED off --> Wasserfallpumpe
//relais_board_1.digitalWrite(3, HIGH); // turn the LED off --> Wasserheizung
//ALLESAUS = 1;
//}else
//{
relais_board_1.digitalWrite(2, LOW); // turn the LED on --> Wasserfallpumpe
relais_board_1.digitalWrite(3, LOW); // turn the LED on --> Wasserheizung
ALLESAUS = 0;
//}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////Rain/////////////////////////////////////////////////////////
void rain()
{
if(ALLESAUS == 0) // wasserstand 0=OK
{
if((TIME_NOW <= 86400) && (TIME_NOW >= rainTimer) && (relais_board_1.digitalRead(5) == HIGH ))
{
relais_board_1.digitalWrite(5, LOW); // turn the LED on --> Regenpumpe
rainTimer = TIME_NOW + rainDelayON;
}
else if((TIME_NOW <= 86400) && (TIME_NOW >= rainTimer) && (relais_board_1.digitalRead(5) == LOW ))
{
relais_board_1.digitalWrite(5, HIGH); // turn the LED off --> Regenpumpe
rainTimer = TIME_NOW + rainDelayOFF;
}
///////////////////////////////show this to LCD
RAINNEXT = rainTimer - TIME_NOW;
///////////////////////////////
}
else
{
relais_board_1.digitalWrite(5, HIGH); // turn the LED off --> Regenpumpe
}
// korektur fr die 0 uhr umstellung
if( (TIME_NOW < 60) && (rainTimer > 86400) && (rainTimer < (86400+rainDelayON)) && (relais_board_1.digitalRead(5) == LOW ))
{
rainTimer = rainTimer - 86400;
}
if( (TIME_NOW < 60) && (rainTimer > 86400) && (rainTimer < (86400+rainDelayOFF)) && (relais_board_1.digitalRead(5) == HIGH ))
{
rainTimer = rainTimer - 86400;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////Nebler//////////////////////////////////////////////////////////
void nebler()
{
if(ALLESAUS == 0) // wasserstand 0=OK
{
if(Humy <= Hmin)
{
relais_board_1.digitalWrite(4, LOW); // turn the LED on --> Nebler
}else{
relais_board_1.digitalWrite(4, HIGH); // turn the LED off --> Nebler
}
}
else
{
relais_board_1.digitalWrite(4, HIGH); // turn the LED off --> Nebler
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////Wandheizung/////////////////////////////////////////////////////
void wheizung()
{
Temp_sens_1=analogRead(pinTempSensor1);
resistance_1=(float)(1023-Temp_sens_1)*10000/Temp_sens_1; //get the resistance of the sensor;
temperature_1=1/(log(resistance_1/10000)/B+1/298.15)-273.15;//convert to temperature via datasheet ;
Temp_sens_2=analogRead(pinTempSensor2);
resistance_2=(float)(1023-Temp_sens_2)*10000/Temp_sens_2; //get the resistance of the sensor;
temperature_2=1/(log(resistance_2/10000)/B+1/298.15)-273.15;//convert to temperature via datasheet ;
if(Temp <= Tmin)
{
if(temperature_1 <= thermomin)
{relais_board_1.digitalWrite(1, LOW);} // turn the LED on --> Heizung 1
if(temperature_1 >= thermomax)
{relais_board_1.digitalWrite(1, HIGH);} // turn the LED off --> Heizung 1
if(temperature_2 <= thermomin)
{relais_board_1.digitalWrite(6, LOW);} // turn the LED on --> Heizung 2
if(temperature_2 >= thermomax)
{relais_board_1.digitalWrite(6, HIGH);} // turn the LED off --> Heizung 2
}
if(Temp >=Tmax)
{
relais_board_1.digitalWrite(1, HIGH); // turn the LED off --> Heizung 1
relais_board_1.digitalWrite(6, HIGH); // turn the LED off --> Heizung 2
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////LCD Display/////////////////////////////////////////////////////
void DISPLAYtoLCD()
{
lcd1.clear(); // clear lcd1
lcd2.clear(); // clear lcd2
///////////////////////////////////////////////Temp and Humidity Sensor 1
lcd1.setCursor(9, 0);
if(DHT11_H3_STATS == 1)
{
lcd1.print("OK");
}else{
lcd1.print("XX");
}
lcd1.setCursor(0, 0);
lcd1.print("H:");
lcd1.setCursor(2, 0);
lcd1.print(DHT11_H3_VALUE);
lcd1.setCursor(7, 0);
lcd1.print("%");
lcd1.setCursor(12, 0);
lcd1.print("T:");
lcd1.setCursor(14, 0);
lcd1.print(DHT11_T3_VALUE);
lcd1.setCursor(19, 0);
lcd1.print("C");
///////////////////////////////////////////////Temp and Humidity Sensor 2
lcd1.setCursor(9, 1);
if(DHT11_H4_STATS == 1)
{
lcd1.print("OK");
}else{
lcd1.print("XX");
}
lcd1.setCursor(0, 1);
lcd1.print("H:");
lcd1.setCursor(2, 1);
lcd1.print(DHT11_H4_VALUE);
lcd1.setCursor(7, 1);
lcd1.print("%");
lcd1.setCursor(12, 1);
lcd1.print("T:");
lcd1.setCursor(14, 1);
lcd1.print(DHT11_T4_VALUE);
lcd1.setCursor(19, 1);
lcd1.print("C");
///////////////////////////////////////////////Next Rain delay
lcd1.setCursor(0, 2);
lcd1.print("Rain next: ");
lcd1.setCursor(12, 2);
lcd1.print(RAINNEXT);
///////////////////////////////////////////////Battery
lcd1.setCursor(0, 3);
lcd1.print("Battery");
if(LBattery.isCharging() == 1){ //Battery load
lcd1.setCursor(8, 3);
lcd1.print("LOADING ");
}else{
lcd1.setCursor(8, 3);
lcd1.print("IN USE ");
}
lcd1.setCursor(16, 3);
lcd1.print(LBattery.level());
lcd1.setCursor(19, 3);
lcd1.print("%");
///////////////////////////////////////////////Clock
DateTime now = RTC.now();
lcd2.setCursor(0, 0);
lcd2.print(now.hour(), DEC);
lcd2.setCursor(2, 0);
lcd2.print(":");
lcd2.setCursor(3, 0);
lcd2.print(now.minute(), DEC);
lcd2.setCursor(5, 0);
lcd2.print(":");
lcd2.setCursor(6, 0);
lcd2.print(now.second(), DEC);
lcd2.setCursor(8, 0);
lcd2.print(" ");
lcd2.setCursor(10, 0);
lcd2.print(now.day(), DEC);
lcd2.setCursor(15, 0);
lcd2.print("/");
lcd2.setCursor(13, 0);
lcd2.print(now.month(), DEC);
lcd2.setCursor(12, 0);
lcd2.print("/");
lcd2.setCursor(16, 0);
lcd2.print(now.year(), DEC);
///////////////////////////////////////////////Wasserstand
lcd2.setCursor(0, 1);
lcd2.print("Wasserstand :");
lcd2.setCursor(0, 2);
lcd2.print(getVoltage());
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////IR Sensor///////////////////////////////////////////////////////////////
float getVoltage()
{
int sensor_value;
int sum;
// read the analog in value:
for (int i = 0;i < 20;i ++)//Continuous sampling 20 times
{
sensor_value = analogRead(IR_PROXIMITY_SENSOR);
sum += sensor_value;
}
sensor_value = sum / 20;
float voltage;
voltage = (float)sensor_value*ADC_REF/1024;
return voltage;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////DATALOG/////////////////////////////////////////////////////////
void datalog()
{
DateTime now = RTC.now();
// make a string for assembling the data to log:
String dataString = "";
// open the file. note that only one file can be open at a time,
// so you have to close this one before opening another.
LFile dataFile = Drv.open("datalog.txt", FILE_WRITE);
// if the file is available, write to it:
if (dataFile) {
//Date Time
dataFile.print("DATE TIME : ");
dataFile.println("");
dataFile.print(String(now.hour(), DEC));
dataFile.print(":");
dataFile.print(String(now.minute(), DEC));
dataFile.print(":");
dataFile.print(String(now.second(), DEC));
dataFile.print(" - ");
dataFile.print(String(now.day(), DEC));
dataFile.print("/");
dataFile.print(String(now.month(), DEC));
dataFile.print("/");
dataFile.print(String(now.year(), DEC));
dataFile.println("");
//Wasserstand
dataFile.print("Wasserstand : ");
dataFile.print(String(getVoltage()));
dataFile.println(",");
//DHT11 sensor 1
dataFile.print("Humidity 1 : ");
dataFile.print(String(DHT11_H3_VALUE));
dataFile.println("");
dataFile.print("Temp 1 : ");
dataFile.print(String(DHT11_T3_VALUE));
dataFile.println("");
//DHT11 sensor 2
dataFile.print("Humidity 2 : ");
dataFile.print(String(DHT11_H4_VALUE));
dataFile.println("");
dataFile.print("Temp 2 : ");
dataFile.print(String(DHT11_T4_VALUE));
dataFile.println("");
//Rain next
dataFile.print("Rain next : ");
dataFile.print(String(RAINNEXT));
dataFile.println("");
//Battery
dataFile.print("Battery : ");
if(LBattery.isCharging() == 1){ //Battery load
dataFile.print(String("LOADING "));
}else{
dataFile.print(String("IN USE "));
}
dataFile.print(String(LBattery.level()));
dataFile.print("%");
dataFile.println("");
//rainTimer
dataFile.print("rainTimer : ");
dataFile.print(String(rainTimer));
dataFile.println("");
//TIME_NOW
dataFile.print("TIME_NOW: ");
dataFile.print(String(TIME_NOW));
dataFile.println("");
//lerre zeilen
dataFile.println("");
dataFile.println("");
dataFile.close();
}
// if the file isn't open, pop up an error:
else {
Serial.println("error opening datalog.txt");
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////HTML////////////////////////////////////////////////////////////
void HTML()
{
////////////////////////////////////////////////////WIFI//////////////////////////////////////////////////////////////////////
LWiFiClient client = server.available();
if (client)
{
//Serial.println("new client");
// an http request ends with a blank line
boolean currentLineIsBlank = true;
unsigned long timer_out = millis();
while (client.connected())
{
if(millis()-timer_out > 5000)break;
if (client.available())
{
// we basically ignores client request, but wait for HTTP request end
// int c = client.read();
// Serial.print((char)c);
char c = client.read();
//read char by char HTTP request
if (readString.length() < 100)
{
//store characters to string
readString += c;
//Serial.print(c);
}
if (c == '\n' && currentLineIsBlank)
{
// Serial.println("send response");
// send a standard http response header
// Serial.println(readString); //print to serial monitor for debuging
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close"); // the connection will be closed after completion of the response
if(modus==0)//AUTOMATIC
{client.println("Refresh: 5");} // refresh the page automatically every 5 sec
client.println();
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("<HEAD>");
client.println("<TITLE>Terrarium</TITLE>");
client.println("</HEAD>");
client.println("<BODY>");
client.println("<H1 align=\"center\">Terrarium</H1>");
client.println("<table border=1 align=\"center\" width=\"600\">");
//CLOCK
DateTime now = RTC.now();
client.print("<tr><td colspan=2 align=\"center\">");
client.print(now.hour(), DEC);
client.print(":");
client.print(now.minute(), DEC);
client.print(":");
client.print(now.second(), DEC);
client.print(" - ");
client.print(now.day(), DEC);
client.print("/");
client.print(now.month(), DEC);
client.print("/");
client.print(now.year(), DEC);
client.print("</td>");
if(modus==0)
{
client.print("<td align=\"center\">");
client.print("AUTOMATIC");
client.print("</td>");
}
else
{
client.print("<td align=\"center\">");
client.print("MANUAL");
client.print("</td>");
}
client.println("</tr>");
//WASSERSTAND
client.print("<tr><td align=\"center\">");
client.print("Wasserstand : ");
client.print("</td><td align=\"center\">");
client.print(getVoltage());
client.print(" mV");
client.print("</td><td align=\"center\">");
client.print("Zustand :");
if(ALLESAUS == 0) // wasserstand 0=OK
{
client.print("</td><td bgcolor=\"#00FF00\" align=\"center\">");
client.print("OK");
}else{
client.print("</td><td bgcolor=\"#FF0000\" align=\"center\">");
client.print("NOT OK");
}
client.println("</td></tr>");
//TEMP HUMY
client.print("<tr><td align=\"center\">");
client.print("Temperatur :");
client.print("</td>");
if(Temp > Tmin && Temp < Tmax) // wasserstand 0=OK
{
client.print("<td bgcolor=\"#00FF00\" align=\"center\">");
client.print(Temp);
client.print(" C");
}else{
client.print("<td bgcolor=\"#FF0000\" align=\"center\">");
client.print(Temp);
client.print(" C");
}
client.print("</td><td align=\"center\">");
client.print("Humidity :");
client.print("</td>");
if(Humy > Hmin) // wasserstand 0=OK
{
client.print("<td bgcolor=\"#00FF00\" align=\"center\">");
client.print(Humy);
client.print(" %");
}else{
client.print("<td bgcolor=\"#FF0000\" align=\"center\">");
client.print(Humy);
client.print(" %");
}
client.println("</td></tr>");
//RELAISBOARD R1
client.print("<tr><td>");
if (relais_board_1.digitalRead(0) == LOW)
{
client.print("Realais 230V ist ");
client.print("</td><td bgcolor=\"#00FF00\" align=\"center\">");
client.print("EIN");
client.print("</td><td align=\"center\">");
if(modus==0){client.print("AUTO");}else
{
client.print("<a href=\"/?OFF1\" >OFF</a>");
}
client.print("</td><td>");
client.print("");
client.println("</td></tr>");
}else{
client.print("Realais 230V ist ");
client.print("</td><td bgcolor=\"#FF0000\" align=\"center\">");
client.print("AUS");
client.print("</td><td align=\"center\">");
if(modus==0){client.print("AUTO");}else
{
client.print("<a href=\"/?ON1\" >ON</a>");
}
client.print("</td><td>");
client.print("");
client.println("</td></tr>");
}
//RELAISBOARD R2
client.print("<tr><td>");
if (relais_board_1.digitalRead(1) == LOW)
{
client.print("Heizung 1 ist ");
client.print("</td><td bgcolor=\"#00FF00\" align=\"center\">");
client.print("EIN");
client.print("</td><td align=\"center\">");
if(modus==0){client.print("AUTO");}else
{
client.print("<a href=\"/?OFF2\" >OFF</a>");
...
This file has been truncated, please download it to see its full contents.
Comments