1420 lines
35 KiB
C++
1420 lines
35 KiB
C++
/*
|
|
* CanGrow - simply DIY automatic plant grow system (for cannabis).
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Includes
|
|
*
|
|
*/
|
|
|
|
// external Libraries
|
|
#include <SPI.h>
|
|
#include <Wire.h>
|
|
#include <Adafruit_GFX.h>
|
|
#include <Adafruit_SSD1306.h>
|
|
#include "DHT.h"
|
|
#include <ESP8266WiFi.h>
|
|
#include <ESP8266WebServer.h>
|
|
#include <EEPROM.h>
|
|
#include <ArduinoJson.h>
|
|
#include <NTPClient.h>
|
|
#include <WiFiUdp.h>
|
|
|
|
/*
|
|
*
|
|
* Variables
|
|
*
|
|
*/
|
|
|
|
// valSoilmoisture - contains the value of getSoilmoisture()
|
|
byte valSoilmoisture;
|
|
// valTemperature - contains the value of getTemperature()
|
|
float valTemperature;
|
|
// valTemperature - contains the value of getHumidity()
|
|
float valHumidity;
|
|
// valWaterlevel - contains the value of getWaterlevel()
|
|
|
|
|
|
|
|
|
|
/*
|
|
* EEPROM saved variables
|
|
*/
|
|
|
|
|
|
|
|
|
|
//
|
|
// WiFi
|
|
//
|
|
char WIFIssid[32];
|
|
char WIFIpassword[64];
|
|
// WIFIuseDHCP - if true, get IP by DHCP
|
|
bool WIFIuseDHCP;
|
|
IPAddress WIFIip(192,168,4,20);
|
|
IPAddress WIFInetmask(255,255,255,0);
|
|
IPAddress WIFIgateway(192,168,4,254);
|
|
IPAddress WIFIdns(0,0,0,0);
|
|
char WebUiUsername[16] = "cangrow";
|
|
char WebUiPassword[32] = "cangrow";
|
|
|
|
//
|
|
// System
|
|
//
|
|
// configured - if true, run setup assistant
|
|
bool configured;
|
|
// NTP Offset
|
|
int ntpOffset;
|
|
// MoistureSensor_Type - contains which moisture sensor to use
|
|
// 0: analog capacitive sensor
|
|
// 1: I2C chirp sensor from catnip electronics
|
|
byte MoistureSensor_Type;
|
|
// SoilmoistureLow - contains the value , when soil moisture is assumed to be low,
|
|
byte SoilmoistureLow;
|
|
// UsePump - is the pump used? bool
|
|
bool UsePump;
|
|
// UseFan - is the fan used? bool
|
|
byte PumpOnTime;
|
|
bool UseFan;
|
|
|
|
//
|
|
// Grow Stuff
|
|
//
|
|
|
|
unsigned int NtpOffset;
|
|
|
|
// GrowName - contains the name of the grow/plant. Up to 32 byte
|
|
char GrowName[32];
|
|
// GrowStart - contains unix timestamp from date where grow starts (00:00)
|
|
// unsigned long is 8 byte
|
|
unsigned long GrowStart;
|
|
// DayOfGrow contains on which day the grow is
|
|
byte DayOfGrow;
|
|
// DaysVeg - contains how many days to be in vegetation phase
|
|
byte DaysVeg;
|
|
// DaysBloom - contains how many days to be in bloom phase
|
|
byte DaysBloom;
|
|
// LighthoursVeg - contains how many hours the Growlight is on in Veg
|
|
byte LighthoursVeg;
|
|
// LighthoursBloom - contains how many hours the Growlight is on in Bloom
|
|
byte LighthoursBloom;
|
|
// SunriseHour - contains to which hour of day the growlight turns on
|
|
byte SunriseHour;
|
|
// SunriseHour - contains to which minute of SunriseHour the growlight turns on
|
|
byte SunriseMinute;
|
|
// PINled_PWM - contains the PWM value for dimming the grow light
|
|
byte PINled_PWM;
|
|
|
|
|
|
|
|
|
|
/*
|
|
*
|
|
* Constants
|
|
*
|
|
*/
|
|
|
|
|
|
/*
|
|
* WiFi
|
|
*/
|
|
|
|
const char* APssid = "CanGrow-unconfigured";
|
|
/*
|
|
* TODO - does not work atm. idk why.
|
|
* const char* APpass = "CanGrow";
|
|
const int APchannel = 6;
|
|
const bool APhidden = false;
|
|
*
|
|
*/
|
|
|
|
|
|
/*
|
|
* NTP
|
|
*/
|
|
|
|
WiFiUDP ntpUDP;
|
|
NTPClient timeClient(ntpUDP);
|
|
|
|
/*
|
|
*
|
|
* Webserver
|
|
*
|
|
*/
|
|
|
|
ESP8266WebServer webserver(80);
|
|
|
|
/*
|
|
* HTML constants for header, footer, css, ...
|
|
*/
|
|
|
|
// Template: const char HTMLexamplepage[] PROGMEM = R"EOF()EOF";
|
|
const char HTMLheader[] PROGMEM = R"EOF(
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<meta charset="UTF-8">
|
|
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
|
<title>CanGrow</title>
|
|
<link rel="stylesheet" href="/style.css">
|
|
</head>
|
|
<body>
|
|
<ul class="nav">
|
|
<li><a href="/">CanGrow</a></li>
|
|
<li><a id="growSettings" href="/growSettings">Grow settings</a></li>
|
|
<li><a id="systemSettings" href="/systemSettings">System settings</a></li>
|
|
<li><a href="/wifiSettings">WiFi settings</a></li>
|
|
<li><a href="/help">Help</a></li>
|
|
<li><span id="GrowName"></span></li>
|
|
</ul>
|
|
<div class="center">
|
|
|
|
)EOF";
|
|
|
|
const char HTMLfooter[] PROGMEM = R"EOF(
|
|
</div>
|
|
</body>
|
|
</html>
|
|
)EOF";
|
|
|
|
const char HTMLstyleCSS[] PROGMEM = R"EOF(
|
|
body {
|
|
color: #cae0d0;
|
|
background-color: #1d211e;
|
|
font-family: helvetica;
|
|
}
|
|
|
|
.center {
|
|
width: 60%; min-width: 420px;
|
|
margin: auto;
|
|
|
|
}
|
|
|
|
h1, h2, h3, h4, h5 {
|
|
text-align: center;
|
|
}
|
|
|
|
a:link, a:visited {
|
|
color: #04AA6D;
|
|
}
|
|
|
|
a:hover {
|
|
color: #64AA6D;
|
|
}
|
|
|
|
a:active {
|
|
color: #04AA6D;
|
|
}
|
|
|
|
.infomsg {
|
|
background: #04AA6D;
|
|
color: #fff;
|
|
border-radius: 3px;
|
|
padding: 4px;
|
|
width: fit-content; min-width: 200px; max-width: 420px;
|
|
margin: auto;
|
|
font-weight: bold;
|
|
text-align: center;
|
|
text-decoration: none;
|
|
text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.5);
|
|
}
|
|
|
|
/* from https://gist.github.com/iamhelenliu/5755179 - thank you! */
|
|
.nav {
|
|
background: #333;
|
|
width: 60%; min-width: 420px;
|
|
margin: auto;
|
|
margin-bottom: 10px;
|
|
padding: 0;
|
|
position: relative;
|
|
border-radius: 3px;
|
|
}
|
|
|
|
.nav li {
|
|
display: inline-block;
|
|
list-style: none;
|
|
}
|
|
|
|
.nav li:first-of-type {
|
|
background: #026b45;
|
|
border-top-left-radius: 3px;
|
|
border-bottom-left-radius: 3px;
|
|
}
|
|
|
|
.nav li a , .nav span {
|
|
color: #ddd;
|
|
display: block;
|
|
font-family: "Lucida Sans Unicode", "Lucida Grande", sans-serif;
|
|
font-size:0.8em;
|
|
padding: 10px 20px;
|
|
text-decoration: none;
|
|
text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.5);
|
|
}
|
|
.nav li a:hover {
|
|
background: #04AA6D;
|
|
color: #fff;
|
|
border-radius: 3px;
|
|
}
|
|
|
|
.nav li a:active {
|
|
color: #cae0d0;
|
|
}
|
|
|
|
|
|
|
|
)EOF";
|
|
|
|
const char HTMLhelp[] PROGMEM = R"EOF(
|
|
<h1>CanGrow help</h1>
|
|
Here you will get some helpful help.
|
|
)EOF";
|
|
|
|
/*
|
|
*
|
|
* Pin assignments
|
|
*
|
|
* D0 - MOSFET Fan
|
|
* D1, D2 - I2C
|
|
* D3 - DHT11
|
|
* D4 - PIN_WIPE
|
|
* D5 - MOSFET Pump
|
|
* D6 - MOSFET Grow LED, PWM
|
|
* D7 - waterlevel (set HIGH to read value)
|
|
* D8 - analog soil moisture (set HIGH to read value)
|
|
* A0 - analog input for soil moisture and waterlevel readings
|
|
*
|
|
* D4 and D7 cannot be HIGH at the same time!
|
|
*/
|
|
|
|
// D0 is HIGH at boot, no PWM
|
|
const uint8_t PINfan = D0;
|
|
// If D3 is pulled to LOW, boot fails
|
|
const uint8_t PINdht = D3;
|
|
// D4 is HIGH at boot, boot fail if pulled to LOW
|
|
// During Start Screen you can pull D4 to LOW to wipe saved data in EEPROM
|
|
// DO NOT PULL D4 DOWN AT WHEN POWERING ON !!! BOOT WILL FAIL
|
|
const uint8_t PIN_WIPE = D4;
|
|
const uint8_t PINpump = D5;
|
|
const uint8_t PINled = D6; //
|
|
const uint8_t PINwaterlevel = D7;
|
|
const uint8_t PINsoilmoisture = D8;
|
|
const uint8_t PINanalog = A0;
|
|
|
|
|
|
/*
|
|
* millis timer
|
|
*
|
|
*/
|
|
unsigned long outputPrevTime = 0;
|
|
|
|
|
|
/*
|
|
* Status vars
|
|
*
|
|
*/
|
|
int D6status = false;
|
|
|
|
|
|
|
|
/* I2C Stuff
|
|
*
|
|
*/
|
|
#define WIRE Wire
|
|
|
|
|
|
/*
|
|
* DHT Stuff
|
|
*
|
|
*/
|
|
#define DHTTYPE DHT11
|
|
DHT dht(PINdht, DHTTYPE);
|
|
|
|
/*
|
|
* Display Stuff
|
|
*/
|
|
Adafruit_SSD1306 display = Adafruit_SSD1306(128, 32, &WIRE);
|
|
// 'CanGrow_Logo', 128x32px
|
|
const unsigned char bmpCanGrow_Logo [] PROGMEM = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x03, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x03, 0xc0, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x07, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x03, 0xe0, 0x00, 0x1f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x0e, 0x03, 0x00, 0x00, 0x00, 0x00, 0x03, 0xe0, 0x00, 0x38, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x1c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x07, 0xe0, 0x00, 0x70, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x18, 0x03, 0x00, 0x00, 0x00, 0x04, 0x07, 0xe0, 0x20, 0x60, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x18, 0x03, 0x00, 0x00, 0x00, 0x06, 0x07, 0xe0, 0xe0, 0x60, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x18, 0x00, 0x00, 0x00, 0x00, 0x03, 0x87, 0xe1, 0xc0, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x30, 0x00, 0x3f, 0xc3, 0xff, 0x03, 0xc7, 0xe3, 0xc0, 0xcf, 0xf9, 0xff, 0xe3, 0xfc, 0xc1, 0x83,
|
|
0x30, 0x00, 0x7f, 0xe3, 0xff, 0x83, 0xe7, 0xe7, 0xc0, 0xcf, 0xfb, 0xff, 0xe7, 0xfe, 0xc3, 0x87,
|
|
0x30, 0x00, 0xe0, 0x73, 0x80, 0xc1, 0xf7, 0xef, 0xc0, 0xc0, 0x1b, 0x80, 0x0e, 0x03, 0xc3, 0x86,
|
|
0x30, 0x00, 0xc0, 0x33, 0x00, 0xc1, 0xff, 0xff, 0x80, 0xc0, 0x1b, 0x00, 0x0c, 0x03, 0xc7, 0x8e,
|
|
0x30, 0x01, 0xc0, 0x37, 0x00, 0xc0, 0xff, 0xff, 0x80, 0xc0, 0x3b, 0x00, 0x1c, 0x03, 0xc7, 0x8c,
|
|
0x60, 0x01, 0xc0, 0x37, 0x00, 0xc0, 0xff, 0xff, 0x01, 0x80, 0x3f, 0x00, 0x18, 0x03, 0xcf, 0x9c,
|
|
0x60, 0x00, 0x00, 0x37, 0x00, 0xc0, 0x7f, 0xfe, 0x01, 0x80, 0x37, 0x00, 0x18, 0x03, 0xcf, 0x9c,
|
|
0x60, 0x00, 0x00, 0x76, 0x01, 0xc0, 0x1f, 0xfc, 0x01, 0x80, 0x36, 0x00, 0x18, 0x06, 0xdf, 0xb8,
|
|
0x60, 0x00, 0x7f, 0xe6, 0x01, 0x9f, 0x9f, 0xfc, 0xf9, 0x80, 0x36, 0x00, 0x18, 0x06, 0xdd, 0xb8,
|
|
0x60, 0x00, 0xff, 0xe6, 0x01, 0x87, 0xff, 0xff, 0xf1, 0x80, 0x76, 0x00, 0x18, 0x06, 0xdd, 0xb0,
|
|
0xc0, 0x01, 0xc0, 0xee, 0x01, 0x83, 0xff, 0xff, 0xc3, 0x00, 0x7e, 0x00, 0x30, 0x06, 0xf9, 0xf0,
|
|
0xc0, 0x0b, 0x80, 0x6e, 0x01, 0x81, 0xff, 0xff, 0x83, 0x00, 0x6e, 0x00, 0x30, 0x06, 0xf9, 0xe0,
|
|
0xc0, 0x1b, 0x00, 0xec, 0x01, 0x80, 0x1f, 0xf8, 0x03, 0x00, 0x6c, 0x00, 0x30, 0x0e, 0xf1, 0xe0,
|
|
0xc0, 0x3b, 0x00, 0xcc, 0x03, 0x80, 0x3f, 0xfc, 0x03, 0x00, 0xec, 0x00, 0x30, 0x0c, 0xf1, 0xc0,
|
|
0xc0, 0x7b, 0x01, 0xcc, 0x03, 0x00, 0x7f, 0xfe, 0x03, 0x01, 0xec, 0x00, 0x30, 0x1c, 0xe1, 0xc0,
|
|
0x7f, 0xf1, 0xff, 0xdc, 0x03, 0x00, 0xf0, 0x8f, 0x01, 0xff, 0xfc, 0x00, 0x1f, 0xf8, 0xe1, 0xc0,
|
|
0x3f, 0xe0, 0xff, 0xcc, 0x03, 0x00, 0x00, 0x80, 0x00, 0xff, 0xcc, 0x00, 0x0f, 0xf0, 0xc1, 0x80,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
// Array of all bitmaps for convenience. (Total bytes used to store images in PROGMEM = 528)
|
|
const int bmpallArray_LEN = 1;
|
|
const unsigned char* bmpallArray[1] = {
|
|
bmpCanGrow_Logo
|
|
};
|
|
|
|
|
|
/*
|
|
*
|
|
*
|
|
* Functions
|
|
*
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Chirp functions
|
|
*/
|
|
void writeI2CRegister8bit(int addr, int value) {
|
|
Wire.beginTransmission(addr);
|
|
Wire.write(value);
|
|
Wire.endTransmission();
|
|
}
|
|
|
|
unsigned int readI2CRegister16bit(int addr, int reg) {
|
|
Wire.beginTransmission(addr);
|
|
Wire.write(reg);
|
|
Wire.endTransmission();
|
|
delay(20);
|
|
Wire.requestFrom(addr, 2);
|
|
unsigned int t = Wire.read() << 8;
|
|
t = t | Wire.read();
|
|
return t;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Sensor functions
|
|
*
|
|
*/
|
|
|
|
int getWaterlevel() {
|
|
|
|
/*
|
|
* waterlevelRAW
|
|
* ===========
|
|
* 0 - 199 : CRITICAL
|
|
* 200 - 399 : WARNING
|
|
* >400 : OK
|
|
*
|
|
* waterlevel
|
|
* ==========
|
|
* 2 : CRITICAL
|
|
* 1 : WARNING
|
|
* 0 : OK
|
|
*/
|
|
|
|
int waterlevelWARN = 200;
|
|
int waterlevelOK = 400;
|
|
int waterlevelRAW = 0;
|
|
int waterlevel = 0;
|
|
|
|
// enable Vcc for water level sensor
|
|
digitalWrite(PINwaterlevel, HIGH);
|
|
// wait a bit to let the circuit stabilize
|
|
// TODO: replace delay() with millis()
|
|
delay(100);
|
|
// get the value
|
|
waterlevelRAW = analogRead(PINanalog);
|
|
// disable Vcc for the sensor to prevent electrolysis effect and release analog pin
|
|
digitalWrite(PINwaterlevel, LOW);
|
|
|
|
if( waterlevelRAW >= waterlevelOK) {
|
|
waterlevel = 0;
|
|
} else if( waterlevelRAW >= waterlevelWARN) {
|
|
waterlevel = 1;
|
|
} else {
|
|
waterlevel = 2;
|
|
}
|
|
|
|
return waterlevel;
|
|
}
|
|
|
|
float getTemperature(bool tempSensor) {
|
|
/*
|
|
* tempSensor
|
|
* ==========
|
|
* 0/false : DHT11 temp sensor
|
|
* 1/true : chirp I2C temp sensor
|
|
*/
|
|
|
|
float temperature = 0;
|
|
|
|
if(tempSensor == false ) {
|
|
// read temperature from DHT11
|
|
temperature = dht.readTemperature();
|
|
} else {
|
|
// read temperature from chrip I2C
|
|
temperature = readI2CRegister16bit(0x20, 5) * 0.10 ;
|
|
}
|
|
|
|
return temperature;
|
|
}
|
|
|
|
float getHumidity() {
|
|
float humidity = dht.readHumidity();
|
|
return humidity;
|
|
}
|
|
|
|
int getSoilmoisture(byte moistureSensor) {
|
|
/*
|
|
* moistureSensor
|
|
* ==============
|
|
* 0 : analog capacitive moisture sensor
|
|
* 1 : chirp I2C moisture sensor
|
|
*/
|
|
|
|
// value to return
|
|
int soilmoisture;
|
|
// value for wet
|
|
int wet;
|
|
// value for dry
|
|
int dry;
|
|
|
|
if(moistureSensor == 0 ) {
|
|
// read analog value from analog moisture sensor
|
|
wet = 180;
|
|
dry= 590;
|
|
|
|
digitalWrite(PINsoilmoisture, HIGH);
|
|
// wait a bit to let the circuit stabilize
|
|
delay(100);
|
|
// get analog input value
|
|
soilmoisture = analogRead(PINanalog);
|
|
// disable Vcc for the sensor to release analog pin
|
|
digitalWrite(PINsoilmoisture, LOW);
|
|
} else {
|
|
// read soil moisture from chrip I2C
|
|
wet = 560;
|
|
dry= 250;
|
|
|
|
// get raw value from I2C chirp sensor
|
|
soilmoisture = readI2CRegister16bit(0x20, 0);
|
|
}
|
|
|
|
return map(soilmoisture, wet, dry, 100, 0);
|
|
}
|
|
|
|
int getLightchirp() {
|
|
// get the "light value" from I2C chirp module
|
|
writeI2CRegister8bit(0x20, 3); //request light measurement
|
|
int lightchirp = readI2CRegister16bit(0x20, 4);
|
|
return lightchirp;
|
|
}
|
|
|
|
|
|
void wipeEEPROM() {
|
|
Serial.println(":: wipe EEPROM ::");
|
|
|
|
// wipeMsg is helper variable to know if the Serial.print Message was
|
|
// already sent
|
|
byte wipeMsg = 0;
|
|
while(digitalRead(PIN_WIPE) == LOW ) {
|
|
// only show the Serial message once
|
|
if(wipeMsg == 0) {
|
|
Serial.println("Please release PIN_WIPE to erase all data saved in EEPROM");
|
|
Serial.println("LAST CHANCE TO KEEP THE DATA BY RESETTING NOW!!");
|
|
// increase i to show the serial message only once
|
|
wipeMsg = 1;
|
|
}
|
|
delay(500);
|
|
}
|
|
|
|
// write a 0 to all 512 bytes of the EEPROM
|
|
Serial.print("wiping EEPROM... ");
|
|
for (int i = 0; i < 512; i++) { EEPROM.write(i, 0); }
|
|
|
|
// commit everything to EEPROM and end here
|
|
EEPROM.end();
|
|
|
|
Serial.println("DONE");
|
|
|
|
// set D4 PIN_WIPE internal LED to Output to give feedback WIPE
|
|
// was done
|
|
pinMode(PIN_WIPE, OUTPUT);
|
|
|
|
Serial.println("!! Device will restart in 3 seconds !!");
|
|
|
|
// let the internal led blink fast to signalize wipe is done
|
|
for(byte i = 0; i <= 24 ; i++) {
|
|
if(i % 2) {
|
|
digitalWrite(PIN_WIPE, LOW);
|
|
} else {
|
|
digitalWrite(PIN_WIPE, HIGH);
|
|
}
|
|
delay(125);
|
|
}
|
|
ESP.restart();
|
|
}
|
|
|
|
|
|
bool loadEEPROM() {
|
|
Serial.println(":: loading EEPROM ::");
|
|
|
|
|
|
// read var WIFIssid from address 0, 32 byte long
|
|
// read this first, because we decide on the ssid length (>0?) if
|
|
// we run in unconfigured AP mode, nor not
|
|
EEPROM.get(0, WIFIssid);
|
|
|
|
// when length is > 0 then read furter EEPROM config data
|
|
if(strlen(WIFIssid)) {
|
|
/*
|
|
* WIFI settings
|
|
*/
|
|
|
|
// read var WIFIpassword from address 32, 64 byte long
|
|
EEPROM.get(32, WIFIpassword);
|
|
// read var WIFIip from address 96, 16 byte long
|
|
EEPROM.get(96, WIFIip);
|
|
// read var WIFInetmask from address 112, 16 byte long
|
|
EEPROM.get(112, WIFInetmask);
|
|
// read var WIFIgateway from address 128, 16 byte long
|
|
EEPROM.get(128, WIFIgateway);
|
|
// read var WIFIgateway from address 128, 16 byte long
|
|
EEPROM.get(144, WIFIdns);
|
|
// read var WIFIuseDHCP from Address 160, 1 byte long
|
|
EEPROM.get(160, WIFIuseDHCP);
|
|
|
|
|
|
/*
|
|
* System settings
|
|
*/
|
|
/*
|
|
* configured
|
|
*
|
|
* read var configured from address 511 - I put this to the end to
|
|
* prevent confusion with the 1 byte offset in the address when it
|
|
* would be at the beginning - more a cosmetic thing
|
|
*
|
|
* All boolean variables are at the end of the EEPROM
|
|
*/
|
|
|
|
|
|
// size is 1 byte
|
|
EEPROM.get(161, configured);
|
|
// size is 1 byte
|
|
EEPROM.get(162, UseFan);
|
|
// size is 1 byte
|
|
EEPROM.get(163, UsePump);
|
|
// size is 1 byte
|
|
EEPROM.get(164, PumpOnTime);
|
|
// size is 1 byte
|
|
EEPROM.get(165, MoistureSensor_Type);
|
|
// size is 1 byte
|
|
EEPROM.get(166, SoilmoistureLow);
|
|
// size is 2 byte
|
|
EEPROM.get(167, ntpOffset);
|
|
|
|
// TODO auth does not work atm
|
|
// EEPROM.get(160, WebUiUsername);
|
|
// EEPROM.get(176, WebUiPassword);
|
|
|
|
/*
|
|
* Grow settings
|
|
*/
|
|
|
|
//TBD
|
|
|
|
|
|
|
|
// print values to Serial output
|
|
Serial.print("WIFIssid: ");
|
|
Serial.println(WIFIssid);
|
|
Serial.print("WIFIpassword: ");
|
|
Serial.println(WIFIpassword);
|
|
Serial.print("Use DHCP: ");
|
|
Serial.println(WIFIuseDHCP);
|
|
|
|
Serial.print("UseFan: ");
|
|
Serial.println(UseFan);
|
|
Serial.print("UsePump: ");
|
|
Serial.println(UsePump);
|
|
Serial.print("PumpOnTime: ");
|
|
Serial.println(PumpOnTime);
|
|
Serial.print("MoistureSensor_Type: ");
|
|
Serial.println(MoistureSensor_Type);
|
|
Serial.print("SoilmoistureLow: ");
|
|
Serial.println(SoilmoistureLow);
|
|
Serial.print("ntpOffset: ");
|
|
Serial.println(ntpOffset);
|
|
|
|
|
|
Serial.print("configured: ");
|
|
Serial.println(configured);
|
|
} else {
|
|
Serial.println("EEPROM value WIFIssid is empty");
|
|
}
|
|
Serial.println(":: EEPROM loaded ::");
|
|
|
|
return(strlen(WIFIssid));
|
|
}
|
|
|
|
void wifiConnect() {
|
|
Serial.println(":: Connecting to WiFi ::");
|
|
Serial.print("SSID: ");
|
|
Serial.println(WIFIssid);
|
|
|
|
// Start WiFi connection
|
|
WiFi.begin(WIFIssid, WIFIpassword);
|
|
if(WIFIuseDHCP == false) {
|
|
WiFi.config(WIFIip, WIFIdns, WIFIgateway, WIFInetmask);
|
|
}
|
|
|
|
// wait until WiFi connection is established
|
|
while (WiFi.status() != WL_CONNECTED) {
|
|
delay(500);
|
|
Serial.print(".");
|
|
}
|
|
Serial.println(" CONNECTED!");
|
|
Serial.print("IP: ");
|
|
Serial.println(WiFi.localIP());
|
|
Serial.println("Get actual time from NTP");
|
|
timeClient.begin();
|
|
timeClient.update();
|
|
Serial.println(timeClient.getFormattedTime());
|
|
Serial.println(timeClient.getEpochTime());
|
|
}
|
|
|
|
void wifiAp() {
|
|
Serial.println(":: Creating Accesspoint ::");
|
|
|
|
// configure WiFi Access Point
|
|
WiFi.softAPConfig(WIFIip, WIFIgateway, WIFInetmask);
|
|
// start Access Point
|
|
// TODO make AP with password - does not work atm. idk why.
|
|
WiFi.softAP(APssid);
|
|
Serial.print("SSID: ");
|
|
Serial.println(APssid);
|
|
Serial.print("CanGrow IP address: ");
|
|
Serial.println(WiFi.softAPIP());
|
|
Serial.println("The login credentials for the WebUI are 'cangrow' for username and password");
|
|
}
|
|
|
|
/*
|
|
* Setup
|
|
*
|
|
*/
|
|
void setup() {
|
|
// Start EEPROM
|
|
EEPROM.begin(512);
|
|
|
|
// setup pins
|
|
pinMode(PINfan, OUTPUT);
|
|
pinMode(PINdht, INPUT);
|
|
pinMode(PINwaterlevel, OUTPUT);
|
|
pinMode(PINsoilmoisture, OUTPUT);
|
|
pinMode(PINled, OUTPUT);
|
|
pinMode(PINpump, OUTPUT);
|
|
|
|
|
|
// set all OUTPUT to low
|
|
digitalWrite(PINfan, LOW);
|
|
digitalWrite(PINwaterlevel, LOW);
|
|
digitalWrite(PINsoilmoisture, LOW);
|
|
digitalWrite(PINled, LOW);
|
|
digitalWrite(PINpump, LOW);
|
|
|
|
// Start Serial
|
|
Serial.begin(115200);
|
|
|
|
// Write an empty line, because before there is some garbage in serial
|
|
// output
|
|
Serial.println("");
|
|
Serial.println(".:: CanGrow Start ::.");
|
|
|
|
// initialise Wire for I2C
|
|
Wire.begin();
|
|
|
|
// initialise I2C display
|
|
display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // Address 0x3C for 128x32
|
|
display.clearDisplay();
|
|
display.display();
|
|
|
|
// set display settings
|
|
display.setTextSize(1);
|
|
display.setTextColor(SSD1306_WHITE, SSD1306_BLACK);
|
|
|
|
// display Logo
|
|
display.drawBitmap(0, 0, bmpCanGrow_Logo, 128, 32, WHITE);
|
|
display.display();
|
|
|
|
// reset chirp
|
|
writeI2CRegister8bit(0x20, 6); //TODO: Do only, when configured
|
|
|
|
// initialise DHT11
|
|
dht.begin(); //TODO: Do only, when configured
|
|
|
|
Serial.println("To wipe the EEPROM saved data, set D4 (PIN_WIPE) to LOW - NOW! (2 seconds left)");
|
|
// wait a few seconds to let the user pull D4 down to wipe EEPROM
|
|
// and we can enjoy the boot screen meanwhile :p
|
|
// meanwhile blink with the led onboad :)
|
|
// 333 * 6 =~ 2 seconds
|
|
pinMode(PIN_WIPE, OUTPUT);
|
|
for(byte i = 0; i <= 6 ; i++) {
|
|
if(i % 2) {
|
|
digitalWrite(PIN_WIPE, LOW);
|
|
} else {
|
|
digitalWrite(PIN_WIPE, HIGH);
|
|
}
|
|
delay(333);
|
|
}
|
|
// set back to HIGH because thats the default
|
|
digitalWrite(PIN_WIPE, HIGH);
|
|
//delay(2000);
|
|
|
|
pinMode(PIN_WIPE, INPUT);
|
|
// read status from PIN_WIPE to WIPE
|
|
// when PIN_WIPE is set to LOW, wipe EEPROM
|
|
if(digitalRead(PIN_WIPE) == LOW) {
|
|
// wipe EEPROM
|
|
wipeEEPROM();
|
|
}
|
|
|
|
/*
|
|
* load EEPROM and Setup WiFi
|
|
*
|
|
* call loadEEPROM() which returns a bool
|
|
* When true, CanGrow is already configured and EEPROM values are applied
|
|
* When false, CanGrow is unconfigured and we need to run the setup assistant
|
|
*/
|
|
|
|
|
|
// load stored values from EEPROM and check what var configured is returned
|
|
if(loadEEPROM()) {
|
|
|
|
// connect to wifi
|
|
wifiConnect();
|
|
|
|
// configured is 0, setup Access Point
|
|
} else {
|
|
|
|
// start an wifi accesspoint
|
|
wifiAp();
|
|
|
|
}
|
|
// set web handler
|
|
WebHandler();
|
|
// start webserver
|
|
webserver.begin();
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
*
|
|
*
|
|
* Loop
|
|
*
|
|
*
|
|
*/
|
|
void loop() {
|
|
//Serial.println("yolo");
|
|
webserver.handleClient();
|
|
}
|
|
|
|
|
|
/*
|
|
* Web Handler
|
|
*/
|
|
|
|
void WebHandler() {
|
|
/*
|
|
* Webserver handlers
|
|
* here are the generic webserver handlers like 404 not found
|
|
* wifiSettings, ...
|
|
*
|
|
* if you are looking for the single webpages handler, have a look to
|
|
*
|
|
* WebHandler_unconfigured() and WebHandler_configured()
|
|
*/
|
|
// generic handler
|
|
// WiFi Stuff
|
|
webserver.on("/wifiSettings", HTTP_GET, WEBwifiSettings);
|
|
webserver.on("/wifiSettings/save", HTTP_POST, POSTwifiSettings);
|
|
webserver.on("/style.css", HTTP_GET, WEBstyleCSS);
|
|
|
|
// help
|
|
webserver.on("/help", HTTP_GET, WEBhelp);
|
|
// does not work atm TODO
|
|
webserver.on("/logout", [](){ webserver.send(401, "text/html", "logged out!"); });
|
|
|
|
// 404 handling
|
|
// favicon.ico is a special one, because its requested everytime and i dont wont to deliver the
|
|
// failed whole page every call. we can save up this 0,5kb traffic :o)
|
|
webserver.on("/favicon.ico", [](){ webserver.send(404, "text/html", "404 - not found"); });
|
|
webserver.onNotFound(WEB404);
|
|
|
|
|
|
// when wifi is unconfigured (WIFIssid <1) then root are Wifi settings
|
|
if(strlen(WIFIssid) < 1) {
|
|
webserver.on("/", HTTP_GET, WEBwifiSettings);
|
|
webserver.on("/systemSettings", HTTP_GET, WEBwifiSettings);
|
|
webserver.on("/growSettings", HTTP_GET, WEBwifiSettings);
|
|
} else {
|
|
|
|
// now we need to receive systemSettings
|
|
webserver.on("/systemSettings/save", HTTP_POST, POSTsystemSettings);
|
|
|
|
// when system settings are unconfigured , then system settings are root
|
|
if(configured == false) {
|
|
webserver.on("/", HTTP_GET, WEBsystemSettings);
|
|
webserver.on("/systemSettings", HTTP_GET, WEBsystemSettings);
|
|
webserver.on("/growSettings", HTTP_GET, WEBsystemSettings);
|
|
|
|
|
|
} else {
|
|
webserver.on("/systemSettings", HTTP_GET, WEBsystemSettings);
|
|
}
|
|
|
|
|
|
webserver.on("/growSettings", HTTP_GET, WEBgrowSettings);
|
|
// now we need to receive growSettings
|
|
webserver.on("/growSettings/save", HTTP_POST, POSTgrowSettings);
|
|
// when grow is unconfigured (GrowStart <1) then Grow settings are root
|
|
if(GrowStart < 1) {
|
|
webserver.on("/", HTTP_GET, WEBgrowSettings);
|
|
} else {
|
|
webserver.on("/", HTTP_GET, WEBroot);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void WebAuth() {
|
|
/*
|
|
* TODO
|
|
* DOES NOT WORK WHEN CONNECTED TO EXISTING WIFI
|
|
* IDK WHY
|
|
*
|
|
*/
|
|
char webAuthRealm[] = "CanGrowRealm";
|
|
if(!webserver.authenticate(WebUiUsername, WebUiPassword)) {
|
|
String body = FPSTR(HTMLheader);
|
|
body += "<h1>Login failed.</h1>";
|
|
body += FPSTR(HTMLfooter);
|
|
webserver.requestAuthentication(DIGEST_AUTH, webAuthRealm, body);
|
|
}
|
|
}
|
|
|
|
void WebAuthApi() {
|
|
/*
|
|
* TODO
|
|
* DOES NOT WORK WHEN CONNECTED TO EXISTING WIFI
|
|
* IDK WHY
|
|
*
|
|
*/
|
|
char webAuthRealm[] = "CanGrowRealm";
|
|
if(!webserver.authenticate(WebUiUsername, WebUiPassword)) {
|
|
webserver.requestAuthentication(DIGEST_AUTH, webAuthRealm);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
*
|
|
* Web pages
|
|
*
|
|
*/
|
|
|
|
// not really a webpage, but CSS is important for them :p
|
|
void WEBstyleCSS() {
|
|
webserver.send(200, "text/css", HTMLstyleCSS);
|
|
}
|
|
|
|
void WEB404() {
|
|
String body = FPSTR(HTMLheader);
|
|
body += "<h1>404 - not found</h1>";
|
|
body += FPSTR(HTMLfooter);
|
|
webserver.send(404, "text/html", body);
|
|
}
|
|
|
|
void WEBlogout() {
|
|
String body = FPSTR(HTMLheader);
|
|
body += "<h1>you are logged out.</h1>";
|
|
body += FPSTR(HTMLfooter);
|
|
|
|
// TODO does not work atm
|
|
webserver.send(401, "text/html", body);
|
|
}
|
|
|
|
void WEBhelp() {
|
|
String body = FPSTR(HTMLheader);
|
|
body += FPSTR(HTMLhelp);
|
|
body += JSreplaceStr("GrowName", "abcdefgh");
|
|
body += FPSTR(HTMLfooter);
|
|
webserver.send(200, "text/html", body);
|
|
}
|
|
|
|
/*
|
|
* Root pages
|
|
*/
|
|
|
|
void WEBroot() {
|
|
String body = FPSTR(HTMLheader);
|
|
body += "<h1>configured!</h1>";
|
|
body += "<p>";
|
|
body += timeClient.getFormattedTime();
|
|
body += "</p>";
|
|
body += FPSTR(HTMLfooter);
|
|
|
|
webserver.send(200, "text/html", body);
|
|
}
|
|
|
|
/*
|
|
* Config pages
|
|
*/
|
|
|
|
void WEBwifiSettings() {
|
|
byte ssidsAvail = WiFi.scanNetworks();
|
|
String body = FPSTR(HTMLheader);
|
|
if(strlen(WIFIssid) == 0) {
|
|
body += "<h1>Welcome!</h1>";
|
|
body += "<p>CanGrow is actually unconfigured. You need to Setup your WiFi first down below.<br>";
|
|
body += "<br>After you entered your WiFi connection details, you need to restart and are step closer to your grow 🥦";
|
|
body += "<br>";
|
|
body += "</p>";
|
|
}
|
|
body += "<h2>WiFi config</h2>\n";
|
|
if(webserver.hasArg("success")) {
|
|
body += "<div class='infomsg'>Successfully saved!<br>Please restart the device.</div>";
|
|
}
|
|
body += "<p>Select your wifi network from the SSID list.<br>To use DHCP leave IP, Subnet, Gateway and DNS fields blank!</p>";
|
|
body += "<form method='post' action='/wifiSettings/save'>\n";
|
|
body += "SSID: <select id='WIFIssid' name='WIFIssid' required>\n";
|
|
body += "<option disabled value='' selected hidden>-Select your network-</option>";
|
|
// build option list for selecting wifi
|
|
Serial.println("Available Wifis: ");
|
|
for(int i = 0 ; i < ssidsAvail; i++) {
|
|
String wifiName = WiFi.SSID(i);
|
|
Serial.println(wifiName);
|
|
body += "<option value='";
|
|
body += wifiName;
|
|
body += "'>";
|
|
body += wifiName;
|
|
body += "</option>\n";
|
|
}
|
|
body += "</select><br>\n";
|
|
body += "Password: <input type='password' name='WIFIpassword'><br>\n";
|
|
body += "IP: <input type='text' name='WIFIip'><br>\n";
|
|
body += "Subnet mask: <input type='text' name='WIFInetmask'><br>\n";
|
|
body += "Gateway: <input type='text' name='WIFIgateway'><br>\n";
|
|
body += "DNS: <input type='text' name='WIFIdns'><br>\n";
|
|
body += "<input type='submit' value='Save'>\n";
|
|
body += "</form>\n";
|
|
body += FPSTR(HTMLfooter);
|
|
|
|
webserver.send(200, "text/html", body);
|
|
}
|
|
|
|
void WEBsystemSettings() {
|
|
String body = FPSTR(HTMLheader);
|
|
|
|
if(configured == false) {
|
|
body += "<h1>Step 2: System settings</h1>";
|
|
body += "<p>Please configure all settings<br>";
|
|
body += "</p>";
|
|
}
|
|
|
|
body += "<h2>System settings</h2>";
|
|
if(webserver.hasArg("success")) {
|
|
body += "<div class='infomsg'>Successfully saved!<br>Please restart the device.</div>";
|
|
}
|
|
body += "<p>here you can set which features and sensors you use<br>";
|
|
body += "</p>";
|
|
|
|
/*
|
|
* // size is 1 byte
|
|
EEPROM.put(162, UseFan);
|
|
// size is 1 byte
|
|
EEPROM.put(163, UsePump);
|
|
// size is 1 byte
|
|
EEPROM.put(164, PumpOnTime);
|
|
// size is 1 byte
|
|
EEPROM.put(165, MoistureSensor_Type);
|
|
// size is 1 byte
|
|
EEPROM.put(166, SoilmoistureLow);
|
|
// size is 2 byte
|
|
EEPROM.put(167, ntpOffset);
|
|
* */
|
|
|
|
|
|
body += "<form method='post' action='/systemSettings/save'>\n";
|
|
|
|
body += "Use fan: <select id='UseFan' name='UseFan' required>\n";
|
|
body += "<option disabled value='' selected hidden>---</option>\n";
|
|
body += "<option value='1'>Yes</option>\n";
|
|
body += "<option value='0'>No</option>\n";
|
|
body += "</select><br>\n";
|
|
|
|
|
|
body += "Use pump: <select id='UsePump' name='UsePump' required>\n";
|
|
body += "<option disabled value='' selected hidden>---</option>\n";
|
|
body += "<option value='1'>Yes</option>\n";
|
|
body += "<option value='0'>No</option>\n";
|
|
body += "</select><br>\n";
|
|
|
|
body += "Pump on time: <input type='text' name='PumpOnTime' required><br>\n";
|
|
|
|
body += "Moisture sensor type: <select id='MoistureSensor_Type' name='MoistureSensor_Type' required>\n";
|
|
body += "<option disabled value='' selected hidden>---</option>\n";
|
|
body += "<option value='0'>Analog capacitive</option>\n";
|
|
body += "<option value='1'>I2C chirp</option>\n";
|
|
body += "</select><br>\n";
|
|
|
|
body += "Soil moisture low: <input type='text' name='SoilmoistureLow' required><br>\n";
|
|
|
|
body += "NTP offset: <input type='text' name='ntpOffset' required><br>\n";
|
|
|
|
body += "<input type='submit' value='Save'>\n";
|
|
body += "</form>\n";
|
|
|
|
body += FPSTR(HTMLfooter);
|
|
|
|
webserver.send(200, "text/html", body);
|
|
}
|
|
|
|
/*
|
|
* Grow pages
|
|
*/
|
|
void WEBgrowSettings() {
|
|
String body = FPSTR(HTMLheader);
|
|
|
|
if(strlen(GrowName) < 1) {
|
|
body += "<h1>Step 3: Grow settings</h1>";
|
|
body += "<p>Please configure all settings<br>";
|
|
body += "</p>";
|
|
}
|
|
|
|
body += "<h2>Grow Settings</h2>";
|
|
if(webserver.hasArg("success")) {
|
|
body += "<div class='infomsg'>Successfully saved!<br>Please restart the device.</div>";
|
|
}
|
|
body += "<p>Here you can set everything grow related, like light hours, how much water, LED brightness<br>";
|
|
body += "</p>";
|
|
|
|
body += "<form method='post' action='/growSettings/save'>\n";
|
|
|
|
body += "Brightness <input type='range' id='PINled_PWM' name='PINled_PWM' min='1' max='255' step='5' />";
|
|
|
|
body += "<input type='submit' value='Save'>\n";
|
|
body += "</form>\n";
|
|
body += FPSTR(HTMLfooter);
|
|
|
|
webserver.send(200, "text/html", body);
|
|
}
|
|
|
|
|
|
/*
|
|
*
|
|
* POSTs
|
|
*
|
|
*/
|
|
|
|
void POSTgrowSettings() {
|
|
PINled_PWM = webserver.arg("PINled_PWM").toInt();
|
|
|
|
analogWrite(D4, PINled_PWM);
|
|
|
|
Serial.println(":: POSTgrowSettings ::");
|
|
|
|
Serial.print("PINled_PWM: ");
|
|
Serial.println(PINled_PWM);
|
|
|
|
webserver.sendHeader("Location", String("/growSettings?success"), true);
|
|
webserver.send(302, "text/plain", "growSettings/save: success!");
|
|
}
|
|
|
|
|
|
void POSTsystemSettings() {
|
|
ntpOffset = webserver.arg("ntpOffset").toInt();
|
|
MoistureSensor_Type = webserver.arg("MoistureSensor_Type").toInt();
|
|
SoilmoistureLow = webserver.arg("SoilmoistureLow").toInt();
|
|
UsePump = webserver.arg("UsePump").toInt();
|
|
PumpOnTime = webserver.arg("PumpOnTime").toInt();
|
|
UseFan = webserver.arg("UseFan").toInt();
|
|
|
|
configured = true;
|
|
|
|
// size is 1 byte
|
|
EEPROM.put(161, configured);
|
|
// size is 1 byte
|
|
EEPROM.put(162, UseFan);
|
|
// size is 1 byte
|
|
EEPROM.put(163, UsePump);
|
|
// size is 1 byte
|
|
EEPROM.put(164, PumpOnTime);
|
|
// size is 1 byte
|
|
EEPROM.put(165, MoistureSensor_Type);
|
|
// size is 1 byte
|
|
EEPROM.put(166, SoilmoistureLow);
|
|
// size is 2 byte
|
|
EEPROM.put(167, ntpOffset);
|
|
|
|
EEPROM.commit();
|
|
|
|
Serial.println(":: POSTsystemSettings ::");
|
|
|
|
Serial.print("configured: ");
|
|
Serial.println(configured);
|
|
Serial.print("UseFan: ");
|
|
Serial.println(UseFan);
|
|
Serial.print("UsePump: ");
|
|
Serial.println(UsePump);
|
|
Serial.print("PumpOnTime: ");
|
|
Serial.println(PumpOnTime);
|
|
Serial.print("MoistureSensor_Type: ");
|
|
Serial.println(MoistureSensor_Type);
|
|
Serial.print("SoilmoistureLow: ");
|
|
Serial.println(SoilmoistureLow);
|
|
Serial.print("ntpOffset: ");
|
|
Serial.println(ntpOffset);
|
|
|
|
webserver.sendHeader("Location", String("/systemSettings?success"), true);
|
|
webserver.send(302, "text/plain", "systemSettings/save: success!");
|
|
}
|
|
|
|
|
|
void POSTwifiSettings() {
|
|
String WIFIssid_new = webserver.arg("WIFIssid");
|
|
String WIFIpassword_new = webserver.arg("WIFIpassword");
|
|
String WIFIip_new = webserver.arg("WIFIip");
|
|
String WIFInetmask_new = webserver.arg("WIFInetmask");
|
|
String WIFIgateway_new = webserver.arg("WIFIgateway");
|
|
String WIFIdns_new = webserver.arg("WIFIdns");
|
|
|
|
// convert String we got from webserver.arg to EEPROM friendly char[]
|
|
WIFIssid_new.toCharArray(WIFIssid, 32);
|
|
WIFIpassword_new.toCharArray(WIFIpassword, 64);
|
|
|
|
// if WIFIip_new was not set, we assume DHCP should be used
|
|
if(WIFIip_new.length() > 0) {
|
|
WIFIip.fromString(WIFIip_new);
|
|
WIFInetmask.fromString(WIFInetmask_new);
|
|
WIFIgateway.fromString(WIFIgateway_new);
|
|
WIFIdns.fromString(WIFIdns_new);
|
|
//
|
|
WIFIuseDHCP = false;
|
|
} else {
|
|
WIFIuseDHCP = true;
|
|
}
|
|
|
|
|
|
|
|
EEPROM.put(0, WIFIssid);
|
|
EEPROM.put(32, WIFIpassword);
|
|
EEPROM.put(96, WIFIip);
|
|
EEPROM.put(112, WIFInetmask);
|
|
EEPROM.put(128, WIFIgateway);
|
|
EEPROM.put(144, WIFIdns);
|
|
EEPROM.put(160, WIFIuseDHCP);
|
|
EEPROM.commit();
|
|
|
|
|
|
Serial.println(":: POSTwifiSettings ::");
|
|
|
|
Serial.print("WIFIssid: ");
|
|
Serial.println(WIFIssid_new);
|
|
Serial.println(WIFIssid);
|
|
Serial.print("WIFIpassword: ");
|
|
Serial.println(WIFIpassword_new);
|
|
Serial.println(WIFIpassword);
|
|
Serial.print("WIFIip: ");
|
|
Serial.println(WIFIip_new);
|
|
Serial.print("WIFInetmask: ");
|
|
Serial.println(WIFInetmask_new);
|
|
Serial.print("WIFIgateway: ");
|
|
Serial.println(WIFIgateway_new);
|
|
Serial.print("WIFIdns: ");
|
|
Serial.println(WIFIdns_new);
|
|
Serial.print("WIFIuseDHCP: ");
|
|
Serial.println(WIFIuseDHCP);
|
|
|
|
|
|
webserver.sendHeader("Location", String("/wifiSettings?success"), true);
|
|
webserver.send(302, "text/plain", "wifiSettings/save: success!");
|
|
|
|
}
|
|
|
|
String JSreplaceStr(String elementID, String content) {
|
|
String jsReturn = "<script>document.getElementById('" + elementID + "').innerHTML='" + content + "';</script>";
|
|
return jsReturn;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
*
|
|
*
|
|
* PLAYGROUND / TRASH
|
|
*
|
|
*
|
|
*/
|
|
|
|
/*
|
|
|
|
unsigned long currentTime = millis();
|
|
|
|
int valSoilmoisture0 = getSoilmoisture(0);
|
|
int valSoilmoisture1 = getSoilmoisture(1);
|
|
|
|
float valTemperature0 = getTemperature(0);
|
|
float valTemperature1 = getTemperature(1);
|
|
|
|
float valHumidity = getHumidity();
|
|
|
|
int valWaterlevel = getWaterlevel();
|
|
|
|
switch(valWaterlevel) {
|
|
|
|
case 0:
|
|
digitalWrite(PINled, HIGH);
|
|
digitalWrite(PINpump, LOW);
|
|
digitalWrite(PINfan, LOW);
|
|
break;
|
|
case 1:
|
|
digitalWrite(PINled, LOW);
|
|
digitalWrite(PINpump, HIGH);
|
|
digitalWrite(PINfan, LOW);
|
|
break;
|
|
case 2:
|
|
digitalWrite(PINled, LOW);
|
|
digitalWrite(PINpump, LOW);
|
|
digitalWrite(PINfan, HIGH);
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
// OUTPUT
|
|
if(currentTime - outputPrevTime >= 1000) {
|
|
|
|
|
|
// set display cursor to top left
|
|
display.setCursor(0,0);
|
|
// display text
|
|
display.print("I2C: ");
|
|
display.print(valSoilmoisture1);
|
|
display.print(", ");
|
|
display.println(valTemperature1);
|
|
|
|
Serial.print("I2C: ");
|
|
Serial.print(valSoilmoisture1);
|
|
Serial.print(", ");
|
|
Serial.println(valTemperature1);
|
|
|
|
|
|
display.print("DHT11: ");
|
|
display.print(valTemperature0);
|
|
display.print(", ");
|
|
display.println(valHumidity);
|
|
|
|
Serial.print("DHT11: ");
|
|
Serial.print(valTemperature0);
|
|
Serial.print(", ");
|
|
Serial.println(valHumidity);
|
|
|
|
|
|
display.print("Water Status: ");
|
|
display.println(valWaterlevel);
|
|
|
|
Serial.print("Water Status: ");
|
|
Serial.println(valWaterlevel);
|
|
|
|
display.print("ASM: ");
|
|
display.print(valSoilmoisture0);
|
|
display.println(", ");
|
|
|
|
Serial.print("ASM: ");
|
|
Serial.println(valSoilmoisture0);
|
|
|
|
// print everything on the display
|
|
display.display();
|
|
|
|
Serial.println("Test");
|
|
|
|
outputPrevTime = currentTime;
|
|
*/
|
|
|
|
|
|
/* if(D6status == true) {
|
|
digitalWrite(PINled, LOW);
|
|
digitalWrite(PINpump, LOW);
|
|
digitalWrite(PINfan, LOW);
|
|
D6status = false;
|
|
Serial.println("D6 is off now");
|
|
} else {
|
|
digitalWrite(PINled, HIGH);
|
|
digitalWrite(PINpump, HIGH);
|
|
digitalWrite(PINfan, HIGH);
|
|
D6status = true;
|
|
Serial.println("D6 is ON now");
|
|
}
|
|
*/
|
|
|
|
/*
|
|
for(int dutyCycle = 0; dutyCycle < 255; dutyCycle++){
|
|
// changing the LED brightness with PWM
|
|
analogWrite(PINled, dutyCycle);
|
|
delay(1);
|
|
}
|
|
|
|
// decrease the LED brightness
|
|
for(int dutyCycle = 255; dutyCycle > 0; dutyCycle--){
|
|
// changing the LED brightness with PWM
|
|
analogWrite(PINled, dutyCycle);
|
|
delay(1);
|
|
}
|
|
*/
|
|
|
|
|
|
|