You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
473 lines
12 KiB
473 lines
12 KiB
#include <Arduino.h>
|
|
#include <Wire.h>
|
|
#include "RTClib.h"
|
|
#include <ArduinoJson.h>
|
|
#include <SoftwareSerial.h>
|
|
#include <Streaming.h>
|
|
#include <SPI.h>
|
|
#define RELAY_ON 0
|
|
#define RELAY_OFF 1
|
|
// #define ESP_TO_ARDUINO_PIN 2
|
|
SoftwareSerial s(5, 6); //RX,TX
|
|
RTC_DS1307 rtc;
|
|
|
|
struct ballast
|
|
{
|
|
int id;
|
|
int shour;
|
|
int smin;
|
|
uint32_t fadePeriod;
|
|
int ehour;
|
|
int emin;
|
|
int stage;
|
|
int brightness;
|
|
int pin;
|
|
unsigned long fadeStartMillis;
|
|
int relayPin;
|
|
};
|
|
struct ballast ballast1, ballast2, ballast3;
|
|
// struct ballast ballasts[3];
|
|
|
|
void setupBallast(ballast *b);
|
|
void setupBallast(ballast *b, JsonObject &root, int i);
|
|
void doBallast(ballast *b);
|
|
void updateBallast(ballast *b, JsonObject &root);
|
|
void manualMode(ballast *b);
|
|
int getFreeRam();
|
|
const size_t bufferSize = JSON_ARRAY_SIZE(3) + JSON_OBJECT_SIZE(2) + 3 * JSON_OBJECT_SIZE(5) + 180;
|
|
|
|
unsigned long currentMillis;
|
|
unsigned long loopMillis;
|
|
unsigned long loopPeriod = 1000;
|
|
unsigned long data_send_millis;
|
|
unsigned long data_send_period = 2000;
|
|
static bool manualFlag;
|
|
|
|
// char roul[] = "is a fag";
|
|
|
|
// char data[60];
|
|
|
|
void setup()
|
|
{
|
|
// put your setup code here, to run once:
|
|
Serial.begin(115200);
|
|
//rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
|
|
//Tell me esp that arduino has turned on
|
|
s.begin(9600);
|
|
// analogWrite(13, 255);
|
|
digitalWrite(13, 1);
|
|
|
|
// strcpy(roul,"");
|
|
|
|
//while (!Serial) continue;
|
|
// DateTime now = rtc.now();
|
|
//StaticJsonBuffer<400> jsonBuffer1;
|
|
DynamicJsonBuffer jsonBuffer(bufferSize);
|
|
// StaticJsonBuffer<100> jsonBuffer;
|
|
JsonObject &root = jsonBuffer.parseObject(s);
|
|
// root.printTo(data);
|
|
// while(root == JsonObject::invalid())
|
|
// {
|
|
// Serial.println(F("Error code1");
|
|
// }
|
|
setupBallast(&ballast1, root, 1);
|
|
setupBallast(&ballast2, root, 2);
|
|
setupBallast(&ballast3, root, 3);
|
|
root.prettyPrintTo(Serial);
|
|
Serial.println(F("Settings initialized via json"));
|
|
if (root["manual"] == F("True"))
|
|
{
|
|
manualFlag = true;
|
|
}
|
|
|
|
loopMillis = millis();
|
|
data_send_millis = millis();
|
|
}
|
|
|
|
// // static bool newData = false;
|
|
|
|
void loop()
|
|
{
|
|
|
|
while (!rtc.begin())
|
|
{
|
|
Serial.println(F("Couldn't find RTC"));
|
|
//while (1);
|
|
delay(100);
|
|
}
|
|
|
|
while (!rtc.isrunning())
|
|
{
|
|
Serial.println(F("RTC is NOT running!"));
|
|
}
|
|
|
|
if (s.available() > 0)
|
|
{
|
|
// delay(100);
|
|
DynamicJsonBuffer jsonBuffer(bufferSize);
|
|
// const size_t bufsize = JSON_ARRAY_SIZE(3) + JSON_OBJECT_SIZE(2) + 3*JSON_OBJECT_SIZE(5);
|
|
// StaticJsonBuffer<bufsize> jsonBuffer;
|
|
// StaticJsonBuffer<bufferSize> jsonBuffer;
|
|
JsonObject &root = jsonBuffer.parseObject(s);
|
|
// if(root.succes())
|
|
Serial << F("Received JSON") << endl;
|
|
root.prettyPrintTo(Serial);
|
|
// // data = "";
|
|
// root.printTo(data);
|
|
// // newData = true;
|
|
// }
|
|
|
|
// if (newData)
|
|
// {
|
|
// Serial.println(F("Parsing data"));
|
|
// DynamicJsonBuffer jsonBuffer(bufferSize);
|
|
// JsonObject &root = jsonBuffer.parseObject(data);
|
|
// root.prettyPrintTo(Serial);
|
|
updateBallast(&ballast1, root);
|
|
updateBallast(&ballast2, root);
|
|
updateBallast(&ballast3, root);
|
|
if (root["manual"] == "True")
|
|
{
|
|
manualFlag = true;
|
|
Serial.println(F("Manual set to true"));
|
|
}
|
|
else if (root["manual"] == "False")
|
|
{
|
|
manualFlag = false;
|
|
Serial.println(F("Manual set to false"));
|
|
}
|
|
// newData = false;
|
|
}
|
|
|
|
currentMillis = millis();
|
|
if (currentMillis - loopMillis >= loopPeriod)
|
|
{
|
|
|
|
if (manualFlag == true)
|
|
{
|
|
Serial.println(F("Manual Mode"));
|
|
manualMode(&ballast1);
|
|
manualMode(&ballast2);
|
|
manualMode(&ballast3);
|
|
}
|
|
else
|
|
{
|
|
doBallast(&ballast1);
|
|
doBallast(&ballast2);
|
|
doBallast(&ballast3);
|
|
}
|
|
|
|
Serial << F("Free RAM: ") << getFreeRam() << endl;
|
|
loopMillis = currentMillis;
|
|
}
|
|
|
|
currentMillis = millis();
|
|
if (currentMillis - data_send_millis >= data_send_period)
|
|
{
|
|
StaticJsonBuffer<50> jsonBuffer;
|
|
JsonObject& root = jsonBuffer.createObject();
|
|
JsonArray& lcd_data = root.createNestedArray("lcdData");
|
|
char time_buffer[10];
|
|
DateTime now = rtc.now();
|
|
sprintf(time_buffer,"%02d:%02d",now.hour(),now.minute());
|
|
// root["hello"] = ("world");
|
|
lcd_data.add("90%%");
|
|
lcd_data.add(time_buffer);
|
|
root.printTo(s);
|
|
root.printTo(Serial);
|
|
data_send_millis = millis();
|
|
Serial << endl;
|
|
}
|
|
delay(100);
|
|
}
|
|
|
|
void setupBallast(ballast *b)
|
|
{
|
|
b->id = 1;
|
|
b->shour = 14;
|
|
b->smin = 0;
|
|
b->fadePeriod = 60 * 60000;
|
|
//b->stage = 0;
|
|
b->brightness = 0;
|
|
b->pin = 11;
|
|
}
|
|
void setupBallast(ballast *b, JsonObject &root, int i)
|
|
{
|
|
pinMode(b->pin, OUTPUT);
|
|
pinMode(b->relayPin, OUTPUT);
|
|
JsonArray &settings = root["settings"];
|
|
JsonObject &settings0 = settings[0];
|
|
JsonObject &settings1 = settings[1];
|
|
JsonObject &settings2 = settings[2];
|
|
if (i == 1)
|
|
{
|
|
b->id = 1;
|
|
b->shour = settings0["shour"];
|
|
unsigned long fP = settings0["fadePeriod"];
|
|
b->fadePeriod = fP * 60000;
|
|
b->smin = settings0["smin"];
|
|
b->ehour = settings0["ehour"];
|
|
b->emin = settings0["emin"];
|
|
b->brightness = 0;
|
|
b->pin = 11;
|
|
b->relayPin = 2;
|
|
b->fadeStartMillis = millis();
|
|
}
|
|
else if (i == 2)
|
|
{
|
|
b->id = 2;
|
|
b->shour = settings1["shour"];
|
|
unsigned long fP = settings1["fadePeriod"];
|
|
b->fadePeriod = fP * 60000;
|
|
b->smin = settings1["smin"];
|
|
b->ehour = settings1["ehour"];
|
|
b->emin = settings1["emin"];
|
|
b->brightness = 0;
|
|
b->pin = 10;
|
|
b->relayPin = 4;
|
|
b->fadeStartMillis = millis();
|
|
}
|
|
else if (i == 3)
|
|
{
|
|
b->id = 3;
|
|
b->shour = settings2["shour"];
|
|
unsigned long fP = settings2["fadePeriod"];
|
|
b->fadePeriod = fP * 60000;
|
|
b->smin = settings2["smin"];
|
|
b->ehour = settings2["ehour"];
|
|
b->emin = settings2["emin"];
|
|
b->brightness = 0;
|
|
b->pin = 9;
|
|
b->relayPin = 7;
|
|
b->fadeStartMillis = millis();
|
|
}
|
|
}
|
|
|
|
void updateBallast(ballast *b, JsonObject &root)
|
|
{
|
|
JsonArray &settings = root["settings"];
|
|
JsonObject &settings0 = settings[0];
|
|
JsonObject &settings1 = settings[1];
|
|
JsonObject &settings2 = settings[2];
|
|
if (b->id == 1)
|
|
{
|
|
b->shour = settings0["shour"];
|
|
unsigned long fP = settings0["fadePeriod"];
|
|
b->fadePeriod = fP * 60000;
|
|
b->smin = settings0["smin"];
|
|
b->ehour = settings0["ehour"];
|
|
b->emin = settings0["emin"];
|
|
}
|
|
if (b->id == 2)
|
|
{
|
|
b->shour = settings1["shour"];
|
|
unsigned long fP = settings1["fadePeriod"];
|
|
b->fadePeriod = fP * 60000;
|
|
b->smin = settings1["smin"];
|
|
b->ehour = settings1["ehour"];
|
|
b->emin = settings1["emin"];
|
|
}
|
|
if (b->id == 3)
|
|
{
|
|
b->shour = settings2["shour"];
|
|
unsigned long fP = settings2["fadePeriod"];
|
|
b->fadePeriod = fP * 60000;
|
|
b->smin = settings2["smin"];
|
|
b->ehour = settings2["ehour"];
|
|
b->emin = settings2["emin"];
|
|
}
|
|
}
|
|
int getStage(ballast *b)
|
|
{
|
|
DateTime now = rtc.now();
|
|
int hr = now.hour();
|
|
int mn = now.minute();
|
|
Serial.print(F("Current hour is: "));
|
|
Serial.println(hr);
|
|
Serial.print(F("Current minute is: "));
|
|
Serial.println(mn);
|
|
|
|
if (hr < b->shour)
|
|
return 0;
|
|
if ((float)hr >= (float)b->shour && hr < (b->shour + (float)(b->fadePeriod) / 3600000 + (float)(b->smin) / 60))
|
|
{
|
|
if (hr == b->shour)
|
|
{
|
|
if (mn < b->smin)
|
|
return 0;
|
|
else
|
|
return 1;
|
|
}
|
|
return 1;
|
|
}
|
|
if ((float)hr >= (b->shour + (float)(b->fadePeriod) / 3600000 + (float)(b->smin) / 60) && hr < b->ehour)
|
|
{
|
|
return 2;
|
|
}
|
|
if ((float)hr >= (b->ehour + (float)(b->fadePeriod) / 3600000))
|
|
{
|
|
if (hr == (b->ehour + (float)(b->fadePeriod) / 3600000))
|
|
{
|
|
if (mn < b->emin)
|
|
return 3;
|
|
else
|
|
return 4;
|
|
}
|
|
else
|
|
{
|
|
// Serial.println((b->ehour + (float)(b->fadePeriod)/3600000));
|
|
return 4;
|
|
}
|
|
}
|
|
if ((float)hr >= (float)b->ehour && hr < (b->ehour + (float)(b->fadePeriod) / 3600000 + (float)(b->emin) / 60))
|
|
{
|
|
if (hr == b->ehour)
|
|
{
|
|
if (mn < b->emin)
|
|
return 2;
|
|
else
|
|
return 3;
|
|
}
|
|
else
|
|
return 3;
|
|
}
|
|
return 1;
|
|
}
|
|
void doBallast(ballast *b)
|
|
{
|
|
if (b->id == 1)
|
|
{
|
|
Serial.println(F("-------------------Ballast1-------------------"));
|
|
}
|
|
if (b->id == 2)
|
|
{
|
|
Serial.println(F("-------------------Ballast2-------------------"));
|
|
}
|
|
if (b->id == 3)
|
|
{
|
|
Serial.println(F("-------------------Ballast3-------------------"));
|
|
}
|
|
// DateTime now = rtc.now();
|
|
// int hr = now.hour();
|
|
Serial.print(F("Start hour is: "));
|
|
Serial.println(b->shour);
|
|
Serial.print(F("Start min is: "));
|
|
Serial.println(b->smin);
|
|
Serial.print(F("Fade Period is: "));
|
|
Serial.print((b->fadePeriod) / 60000);
|
|
Serial.println(F(" minutes"));
|
|
Serial.print(F("End hour is: "));
|
|
Serial.println(b->ehour);
|
|
Serial.print(F("End min is: "));
|
|
Serial.println(b->emin);
|
|
Serial.print(F("Brightness: "));
|
|
Serial.println(b->brightness);
|
|
int stage = getStage(b);
|
|
Serial.print(F("Stage: "));
|
|
Serial.println(stage);
|
|
if (stage == 0)
|
|
{
|
|
b->stage = 0;
|
|
b->brightness = 0;
|
|
analogWrite(b->pin, b->brightness);
|
|
Serial.print(F("Stage = "));
|
|
Serial.println(stage);
|
|
Serial.print(F("brightness: "));
|
|
Serial.println(b->brightness);
|
|
analogWrite(b->relayPin, RELAY_OFF);
|
|
}
|
|
else if (stage == 1)
|
|
{
|
|
if (currentMillis - b->fadeStartMillis >= (b->fadePeriod / 255))
|
|
{
|
|
//Serial.println(b->fadePeriod/255);
|
|
Serial.print(F("Stage = "));
|
|
Serial.println(stage);
|
|
digitalWrite(b->relayPin, RELAY_ON);
|
|
if (b->brightness <= 254)
|
|
{
|
|
analogWrite(b->pin, b->brightness++);
|
|
}
|
|
//d = b->fadePeriod/255;
|
|
Serial.print(F("Delay is: "));
|
|
//t = d / 1000;
|
|
Serial.print(b->fadePeriod / 255 / 1000);
|
|
Serial.println(F(" seconds"));
|
|
Serial.print(F("Brightness: "));
|
|
Serial.println(b->brightness);
|
|
//if(b->brightness == 255)
|
|
//b->brightness = 0;
|
|
//delay(d);
|
|
b->fadeStartMillis = currentMillis;
|
|
}
|
|
}
|
|
else if (stage == 2)
|
|
{
|
|
Serial.print(F("Stage = "));
|
|
Serial.println(stage);
|
|
b->brightness = 255;
|
|
analogWrite(b->pin, b->brightness);
|
|
}
|
|
else if (stage == 3)
|
|
{
|
|
if (currentMillis - b->fadeStartMillis >= (b->fadePeriod / 255))
|
|
{
|
|
//Serial.println(b->fadePeriod/255);
|
|
Serial.print(F("Stage = "));
|
|
Serial.println(stage);
|
|
//if(b->brightness == 0 && (float)hr < (b->ehour + (float)(b->fadePeriod)/3600000))
|
|
//b->brightness = 255;
|
|
if (b->brightness > 0)
|
|
{
|
|
|
|
analogWrite(b->pin, --b->brightness);
|
|
}
|
|
//d = b->fadePeriod/255;
|
|
Serial.print(F("Delay is: "));
|
|
//t = d / 1000;
|
|
Serial.print(b->fadePeriod / 255 / 1000);
|
|
Serial.println(F(" seconds"));
|
|
Serial.print(F("Brightness: "));
|
|
Serial.println(b->brightness);
|
|
//if(b->brightness == 255)
|
|
//b->brightness = 0;
|
|
//delay(d);
|
|
b->fadeStartMillis = currentMillis;
|
|
}
|
|
}
|
|
else if (stage == 4)
|
|
{
|
|
Serial.print(F("Stage = "));
|
|
Serial.println(stage);
|
|
analogWrite(b->pin, 0);
|
|
analogWrite(b->relayPin, RELAY_OFF);
|
|
}
|
|
Serial.println(F("----------------------------------------------"));
|
|
}
|
|
|
|
void manualMode(ballast *b)
|
|
{
|
|
/*DateTime now = rtc.now();
|
|
byte hr = now.hour();
|
|
byte mn = now.minute();
|
|
|
|
if(hr <= b-> shour)
|
|
{
|
|
analogWrite("
|
|
}*/
|
|
analogWrite(b->pin, 255);
|
|
analogWrite(b->relayPin, RELAY_ON);
|
|
}
|
|
|
|
int getFreeRam()
|
|
{
|
|
extern int __heap_start, *__brkval;
|
|
int v;
|
|
|
|
v = (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
|
|
|
|
Serial.print("Free RAM = ");
|
|
Serial.println(v, DEC);
|
|
|
|
return v;
|
|
}
|