406 lines
12 KiB
C++
406 lines
12 KiB
C++
//Includes
|
|
#include <SPI.h>
|
|
#include <Time.h>
|
|
#include <Ethernet.h>
|
|
#include <EthernetUdp.h>
|
|
#include <LiquidCrystal.h>
|
|
|
|
//Constants
|
|
const unsigned int timeZone = 10;
|
|
const unsigned int NTPTimeout = 5000;
|
|
const unsigned int earthtoolsTimeout = 5000;
|
|
unsigned int lcdPin = 3;
|
|
unsigned int ledPin = 5;
|
|
const unsigned int lcdNightBrightness = 10;
|
|
const unsigned int lcdDayBrightness = 255;
|
|
const unsigned int ledNightBrightness = 0;
|
|
const unsigned int ledDayBrightness = 255;
|
|
const String latitude = "-33.909508";
|
|
const String longitude = "151.22162";
|
|
const int NTP_PACKET_SIZE = 48; // NTP time is in the first 48 bytes of message
|
|
byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0xE4, 0x0B };
|
|
unsigned int localPort = 8888;
|
|
IPAddress timeServer(203, 0, 178, 191);
|
|
byte packetBuffer[NTP_PACKET_SIZE]; //buffer to hold incoming & outgoing packets
|
|
IPAddress myIP(10, 0, 36, 200); // fallback local IP (no DHCP)
|
|
const char serverName[] = "www.earthtools.org";
|
|
const int timeOffset = 0; //minutes
|
|
const int sunriseDelay = 2; //hours
|
|
const int sunsetDelay = 5; //hours
|
|
|
|
//Variables
|
|
int sunDate = 0;
|
|
int syncDate = 0;
|
|
int ledBrightness = ledNightBrightness;
|
|
int lcdBrightness = lcdNightBrightness;
|
|
time_t dawn;
|
|
time_t sunrise;
|
|
time_t sunset;
|
|
time_t twilight;
|
|
String dawnText;
|
|
String sunriseText;
|
|
String sunsetText;
|
|
String twilightText;
|
|
unsigned int lastAttemptTime = 0;
|
|
int sunStatus = 0; // 1: down. 2: rising. 3: up. 4: setting.
|
|
int prevSunStatus = 0;
|
|
int prevLcdBrightness = -1;
|
|
int prevLedBrightness = -1;
|
|
long timeNowOffset = 0;
|
|
int secondsDisplayed = 0;
|
|
|
|
//Characters
|
|
byte lamp[8] = {
|
|
B01110,
|
|
B10001,
|
|
B10001,
|
|
B10001,
|
|
B01110,
|
|
B01110,
|
|
B00100,
|
|
};
|
|
|
|
byte up[8] = {
|
|
B00100,
|
|
B10101,
|
|
B01110,
|
|
B11111,
|
|
B01110,
|
|
B10101,
|
|
B00100,
|
|
};
|
|
|
|
byte down[8] = {
|
|
B01100,
|
|
B00110,
|
|
B00011,
|
|
B00011,
|
|
B00011,
|
|
B00110,
|
|
B01100,
|
|
};
|
|
|
|
byte rising[8] = {
|
|
B00000,
|
|
B00111,
|
|
B00011,
|
|
B00101,
|
|
B01000,
|
|
B10000,
|
|
B00000,
|
|
};
|
|
|
|
byte setting[8] = {
|
|
B00000,
|
|
B10000,
|
|
B01000,
|
|
B00101,
|
|
B00011,
|
|
B00111,
|
|
B00000,
|
|
};
|
|
|
|
byte logo[8] = {
|
|
B00000,
|
|
B00000,
|
|
B01000,
|
|
B11010,
|
|
B11010,
|
|
B00010,
|
|
B00000,
|
|
};
|
|
|
|
//Initialisation
|
|
LiquidCrystal lcd(8, 9, 4, 2, 6, 7);
|
|
EthernetClient earthtools;
|
|
EthernetUDP Udp;
|
|
|
|
void setup(){
|
|
//Initialise Hardware
|
|
Serial.begin(9600);
|
|
Serial.println("_______________________________");
|
|
Serial.println("Start serial (setup())");
|
|
|
|
lcd.begin(16, 2);
|
|
pinMode (ledPin, OUTPUT);
|
|
pinMode (lcdPin, OUTPUT);
|
|
analogWrite(ledPin, ledNightBrightness);
|
|
analogWrite(lcdPin, lcdNightBrightness);
|
|
lcd.createChar(0, lamp);
|
|
lcd.createChar(1, down);
|
|
lcd.createChar(2, rising);
|
|
lcd.createChar(3, up);
|
|
lcd.createChar(4, setting);
|
|
lcd.createChar(5, logo);
|
|
lcd.setCursor(8,0);
|
|
lcd.write(byte(5));
|
|
lcd.setCursor(0,1);
|
|
lcd.print("DHCP... ");
|
|
Serial.println("Attempting to get an IP address using DHCP:");
|
|
if (!Ethernet.begin(mac)) {
|
|
Serial.println("failed to get an IP address using DHCP, trying manually");
|
|
lcd.print("Manual");
|
|
Ethernet.begin(mac, myIP);
|
|
} else {
|
|
Serial.println("DHCP Success");
|
|
lcd.print("ok");
|
|
delay(1000);
|
|
}
|
|
Serial.print("IP Address: ");
|
|
lcd.setCursor(0,1);
|
|
lcd.print("IP: ");
|
|
Serial.println(Ethernet.localIP());
|
|
lcd.print(Ethernet.localIP());
|
|
delay(1000);
|
|
Udp.begin(localPort);
|
|
Serial.print("Starting NTP sync... ");
|
|
setSyncProvider(getNtpTime);
|
|
setSyncInterval(43200);
|
|
Serial.println("End setup()");
|
|
lcd.clear();
|
|
}
|
|
|
|
void loop(){
|
|
if(timeStatus() != timeNotSet ){ //wait until you know what time it is.
|
|
timeNowOffset = now() + (timeOffset * 60);
|
|
if(sunDate == day()) {
|
|
calculateBrightness();
|
|
updateLED();
|
|
updateLCD();
|
|
} else {
|
|
getSuntimes();
|
|
}
|
|
} else {
|
|
lcd.clear();
|
|
lcd.print("no clock sync...");
|
|
getNtpTime(); //get the time if you don't know what time it is.
|
|
delay(500);
|
|
}
|
|
}
|
|
|
|
void getSuntimes() {
|
|
connectToEarthtools();
|
|
while (!earthtools.available()) {
|
|
Serial.println("Waiting for Earthtools...");
|
|
delay(500);
|
|
}
|
|
Serial.println("Looking for Sun Times...");
|
|
if(earthtools.find("<sunrise>")) {
|
|
sunriseText = "";
|
|
while (!sunriseText.endsWith("<")) {
|
|
char inChar = earthtools.read();
|
|
sunriseText += inChar;
|
|
}
|
|
sunriseText.replace("<", "");
|
|
sunrise = formatTime(sunriseText, sunriseDelay);
|
|
Serial.println("Sunrise: " + sunriseText);
|
|
}
|
|
|
|
if(earthtools.find("<astronomical>")) {
|
|
dawnText = "";
|
|
while (!dawnText.endsWith("<")) {
|
|
char inChar = earthtools.read();
|
|
dawnText += inChar;
|
|
}
|
|
dawnText.replace("<", "");
|
|
dawn = formatTime(dawnText, sunriseDelay);
|
|
Serial.println("Dawn: " + dawnText);
|
|
}
|
|
|
|
if(earthtools.find("<sunset>")) {
|
|
sunsetText = "";
|
|
while (!sunsetText.endsWith("<")) {
|
|
char inChar = earthtools.read();
|
|
sunsetText += inChar;
|
|
}
|
|
sunsetText.replace("<", "");
|
|
sunset = formatTime(sunsetText, sunsetDelay);
|
|
Serial.println("Sunset: " + sunsetText);
|
|
}
|
|
|
|
if(earthtools.find("<astronomical>")) {
|
|
twilightText = "";
|
|
while (!twilightText.endsWith("<")) {
|
|
char inChar = earthtools.read();
|
|
twilightText += inChar;
|
|
}
|
|
twilightText.replace("<", "");
|
|
twilight = formatTime(twilightText, sunsetDelay);
|
|
Serial.println("Twilight: " + twilightText);
|
|
}
|
|
|
|
Serial.println("Sun times OK at " + String(hour()) + ":" + String(minute()) + ":" + String(second()));
|
|
earthtools.flush();
|
|
earthtools.stop();
|
|
sunDate = day();
|
|
}
|
|
|
|
time_t formatTime(String timeIn, int offset){
|
|
time_t timeout;
|
|
TimeElements tempTime;
|
|
String event_hour = timeIn.substring( 0 , timeIn.indexOf( ":" ) );
|
|
String event_minute = timeIn.substring( timeIn.indexOf(":")+1, timeIn.indexOf( ":", timeIn.indexOf(":")+1 ) );
|
|
String event_second = timeIn.substring( timeIn.indexOf(":", timeIn.indexOf(":")+1)+1);
|
|
tempTime.Second = event_second.toInt();
|
|
tempTime.Minute = event_minute.toInt();
|
|
tempTime.Hour = event_hour.toInt() + offset;
|
|
tempTime.Day = day();
|
|
tempTime.Month = month();
|
|
tempTime.Year = year();
|
|
tempTime.Year = tempTime.Year - 1970;
|
|
timeout = makeTime(tempTime);
|
|
return(timeout);
|
|
}
|
|
|
|
void connectToEarthtools() {
|
|
Serial.print("Connecting to Earthtools... ");
|
|
if (earthtools.connect(serverName, 80)) {
|
|
earthtools.println("GET /sun-1.0/" + latitude + "/" + longitude + "/" + String(day()) + "/" + String(month()) + "/" + timeZone + "/0 HTTP/1.1");
|
|
earthtools.println("HOST: " + String(serverName));
|
|
earthtools.println("Connection: close");
|
|
earthtools.println();
|
|
Serial.println("Connected to Earthtools");
|
|
}
|
|
}
|
|
|
|
void calculateBrightness() {
|
|
if (timeNowOffset >= dawn && timeNowOffset < sunrise) { // Sun is Rising
|
|
ledBrightness = map(timeNowOffset, dawn, sunrise, ledNightBrightness, ledDayBrightness);
|
|
lcdBrightness = map(timeNowOffset, dawn, sunrise, lcdNightBrightness, lcdDayBrightness);
|
|
sunStatus = 2;
|
|
}
|
|
|
|
else if (timeNowOffset >= sunrise && timeNowOffset < sunset) { // Sun is Up
|
|
ledBrightness = ledDayBrightness;
|
|
lcdBrightness = lcdDayBrightness;
|
|
sunStatus = 3;
|
|
}
|
|
|
|
else if (timeNowOffset >= sunset && timeNowOffset < twilight) { // Sun is Setting
|
|
ledBrightness = map(timeNowOffset, sunset, twilight, ledDayBrightness, ledNightBrightness);
|
|
lcdBrightness = map(timeNowOffset, sunset, twilight, lcdDayBrightness, lcdNightBrightness);
|
|
sunStatus = 4;
|
|
}
|
|
|
|
else { // Sun is Down
|
|
ledBrightness = ledNightBrightness;
|
|
lcdBrightness = lcdNightBrightness;
|
|
sunStatus = 1;
|
|
}
|
|
}
|
|
|
|
void updateLED(){
|
|
analogWrite(ledPin, ledBrightness);
|
|
}
|
|
|
|
void updateLCD(){
|
|
analogWrite(lcdPin, lcdBrightness);
|
|
if (prevSunStatus != sunStatus) {
|
|
Serial.println("Sun is " + String(sunStatus) + " (1: down. 2: rising. 3: up. 4: setting)");
|
|
lcd.setCursor(12,0);
|
|
lcd.write(byte(0)); //lamp icon
|
|
lcd.setCursor(10,0);
|
|
lcd.write(byte(sunStatus)); //Sun state icon
|
|
prevSunStatus = sunStatus;
|
|
}
|
|
if (prevLedBrightness != ledBrightness) {
|
|
lcd.setCursor(13,0);
|
|
if (ledBrightness < 10) { lcd.print("0"); }
|
|
if (ledBrightness < 100) { lcd.print("0"); }
|
|
lcd.print(ledBrightness);
|
|
prevLedBrightness = ledBrightness;
|
|
}
|
|
if (secondsDisplayed != second()) {
|
|
lcd.setCursor(0, 0);
|
|
lcd.print(hour());
|
|
printDigits(minute());
|
|
printDigits(second());
|
|
if(hour()<10) { lcd.print(" "); }
|
|
secondsDisplayed = second();
|
|
switch (sunStatus) { //1: down. 2: rising. 3: up. 4: setting.
|
|
case 1: //down
|
|
lcd.setCursor(0,1); lcd.write(byte(4)); //setting icon
|
|
lcd.setCursor(2,1); lcd.print(String(hour(twilight)) + ":" + String(minute(twilight)) + " ");
|
|
lcd.setCursor(9,1); lcd.write(byte(2)); //rising icon
|
|
lcd.setCursor(11,1); lcd.print(String(hour(dawn)) + ":" + String(minute(dawn)) + " ");
|
|
break;
|
|
|
|
case 2: //rising
|
|
lcd.setCursor(0,1); lcd.write(byte(1)); //down icon
|
|
lcd.setCursor(2,1); lcd.print(String(hour(dawn)) + ":" + String(minute(dawn)) + " ");
|
|
lcd.setCursor(9,1); lcd.write(byte(3)); //up icon
|
|
lcd.setCursor(11,1); lcd.print(String(hour(sunrise)) + ":" + String(minute(sunrise)) + " ");
|
|
break;
|
|
|
|
case 3: //up
|
|
lcd.setCursor(0,1); lcd.write(byte(2)); //rising icon
|
|
lcd.setCursor(2,1); lcd.print(String(hour(sunrise)) + ":" + String(minute(sunrise)) + " ");
|
|
lcd.setCursor(9,1); lcd.write(byte(4)); //setting icon
|
|
lcd.setCursor(11,1); lcd.print(String(hour(sunset)) + ":" + String(minute(sunset)) + " ");
|
|
break;
|
|
|
|
case 4: //setting
|
|
lcd.setCursor(0,1); lcd.write(byte(3)); //day icon
|
|
lcd.setCursor(2,1); lcd.print(String(hour(sunset)) + ":" + String(minute(sunset)) + " ");
|
|
lcd.setCursor(9,1); lcd.write(byte(1)); //night icon
|
|
lcd.setCursor(11,1); lcd.print(String(hour(twilight)) + ":" + String(minute(twilight)) + " ");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void printDigits(int digits){
|
|
lcd.print(":");
|
|
if(digits < 10)
|
|
lcd.print('0');
|
|
lcd.print(digits);
|
|
}
|
|
|
|
|
|
time_t getNtpTime()
|
|
{
|
|
while (Udp.parsePacket() > 0) ; // discard any previously received packets
|
|
Serial.print("Transmitting NTP Request... ");
|
|
sendNTPpacket(timeServer);
|
|
uint32_t beginWait = millis();
|
|
while (millis() - beginWait < 1500) {
|
|
int size = Udp.parsePacket();
|
|
if (size >= NTP_PACKET_SIZE) {
|
|
Serial.println("NTP synced");
|
|
Udp.read(packetBuffer, NTP_PACKET_SIZE); // read packet into the buffer
|
|
unsigned long secsSince1900;
|
|
// convert four bytes starting at location 40 to a long integer
|
|
secsSince1900 = (unsigned long)packetBuffer[40] << 24;
|
|
secsSince1900 |= (unsigned long)packetBuffer[41] << 16;
|
|
secsSince1900 |= (unsigned long)packetBuffer[42] << 8;
|
|
secsSince1900 |= (unsigned long)packetBuffer[43];
|
|
return secsSince1900 - 2208988800UL + timeZone * SECS_PER_HOUR;
|
|
}
|
|
}
|
|
Serial.println("NTP sync failed.");
|
|
return 0; // return 0 if unable to get the time
|
|
}
|
|
|
|
// send an NTP request to the time server at the given address
|
|
void sendNTPpacket(IPAddress &address)
|
|
{
|
|
// set all bytes in the buffer to 0
|
|
memset(packetBuffer, 0, NTP_PACKET_SIZE);
|
|
// Initialize values needed to form NTP request
|
|
// (see URL above for details on the packets)
|
|
packetBuffer[0] = 0b11100011; // LI, Version, Mode
|
|
packetBuffer[1] = 0; // Stratum, or type of clock
|
|
packetBuffer[2] = 6; // Polling Interval
|
|
packetBuffer[3] = 0xEC; // Peer Clock Precision
|
|
// 8 bytes of zero for Root Delay & Root Dispersion
|
|
packetBuffer[12] = 49;
|
|
packetBuffer[13] = 0x4E;
|
|
packetBuffer[14] = 49;
|
|
packetBuffer[15] = 52;
|
|
// all NTP fields have been given values, now
|
|
// you can send a packet requesting a timestamp:
|
|
Udp.beginPacket(address, 123); //NTP requests are to port 123
|
|
Udp.write(packetBuffer, NTP_PACKET_SIZE);
|
|
Udp.endPacket();
|
|
}
|