You asked me to post what I had so far so here it is. Since we will be moving the lighting code to the pwm module I would like to be able to still access the following info - sunrise/set time for standard non offset time(there are 3 sets of times), cloud & lightning times for main screen, the ability to send lightning times to controller to change RF module to storm mode(where is rf documentation for programming?).
Code: Select all
#include <ReefAngel_Features.h>
#include <ReefAngel_Globals.h>
#include <ReefAngel_Wifi.h>
#include <Wire.h>
#include <OneWire.h>
#include <Time.h>
#include <DS1307RTC.h>
#include <ReefAngel_EEPROM.h>
#include <ReefAngel_NokiaLCD.h>
#include <ReefAngel_ATO.h>
#include <ReefAngel_Joystick.h>
#include <ReefAngel_LED.h>
#include <ReefAngel_TempSensor.h>
#include <ReefAngel_Relay.h>
#include <ReefAngel_PWM.h>
#include <ReefAngel_Timer.h>
#include <ReefAngel_Memory.h>
#include <ReefAngel.h>
#include <avr/pgmspace.h>
#include <ReefAngel_Colors.h>
#include <ReefAngel_CustomColors.h>
#include <ReefAngel_Salinity.h>
#include <ReefAngel.h>
#include <ReefAngel_RF.h>
#include <ReefAngel.h>
//*********************************************************************************************************************************
//Start of PWM Expansion Code Header
// This is just how we are going to reference the PWM expansion ports within the code.
// You can change the labels if you would like, just as long as they are changed all throughout the code too.
#define LEDPWM0 0
#define LEDPWM1 1
#define LEDPWM2 2
#define LEDPWM3 3
#define LEDPWM4 4
#define LEDPWM5 5
// Initial values to all 6 channels at startup. They will always be 0.
byte PWMChannel[]={
0,0,0,0,0,0};
byte cloudchance=0;
byte cloudduration=0;
int cloudstart=0;
//End of PWM Expansion Code Header
//*********************************************************************************************************************************
//*********************************************************************************************************************************
//Define Relay Ports
#define PowerCenter 1
#define LEDPSU 2
#define Refugium 3
#define Reactors 4
#define Vortechs 5
#define Return 6
#define Heater 7
#define Skimmer 8
//*********************************************************************************************************************************
//*********************************************************************************************************************************
//Seasons Seconds Calculator integers
int calcSec(int,int);
int calcTime(int,int);
//*********************************************************************************************************************************
//*********************************************************************************************************************************
//Custom Main, Graph & Menu
void ConvertNumToString(char* string, int num, byte decimal)
{
char temptxt[3];
int Temp = num;
if (Temp==0xFFFF) Temp=0;
itoa(Temp/decimal,string,10);
if (decimal>1)
{
itoa(Temp%decimal,temptxt,10);
strcat(string, ".");
if (Temp%decimal<10 && decimal==100) strcat(string, "0");
strcat(string, temptxt);
}
}
void DrawCustomMain()
{
byte x = 6;
byte y = 2;
byte t;
ReefAngel.LCD.DrawDate(6, 2);
ReefAngel.LCD.Clear(COLOR_BLACK, 1, 11, 132, 11);
pingSerial();
x = 12;
y += MENU_START_ROW+1;
ReefAngel.LCD.DrawText(COLOR_BLUE, COLOR_WHITE, x, y+6, "Display pH");
char text[7];
ConvertNumToString(text, ReefAngel.Params.PH, 100);
ReefAngel.LCD.Clear(DefaultBGColor, x+16, y+65, x+65, y+16);
ReefAngel.LCD.DrawLargeText(PHColor, DefaultBGColor, x+75, y+18, text,
Font8x16);
pingSerial();
ConvertNumToString(text, ReefAngel.Params.Temp1, 10);
y += MENU_START_ROW*2;
x = 10;
ReefAngel.LCD.Clear(DefaultBGColor,x,y,x+(16*4),y+16);
pingSerial();
ReefAngel.LCD.DrawHugeNumbers(T1TempColor, DefaultBGColor, x, y, text);
pingSerial();
x += (16*4) + 8;
ReefAngel.LCD.DrawText(T2TempColor,DefaultBGColor,8,y+25,"Sump:");
ReefAngel.LCD.DrawSingleMonitor(ReefAngel.Params.Temp2, T2TempColor,
24, y+35, 10);
ReefAngel.LCD.DrawText(T3TempColor,DefaultBGColor,x+8,y+25,"Room:");
ReefAngel.LCD.DrawSingleMonitor(ReefAngel.Params.Temp3, T3TempColor,
x+24, y+35, 10);
ConvertNumToString(SALtxt, ReefAngel.Params.Salinity, 10);
ReefAngel.LCD.DrawHugeNumbers(COLOR_LIMEGREEN, DefaultBGColor, 5, 55, SALtxt);
//y += 39*2;
// x = 13;
byte TempRelay = ReefAngel.Relay.RelayData;
TempRelay &= ReefAngel.Relay.RelayMaskOff;
TempRelay |= ReefAngel.Relay.RelayMaskOn;
ReefAngel.LCD.DrawOutletBox(12, 92, TempRelay);
// #ifdef RelayExp
// draw 1st expansion relay
// TempRelay = ReefAngel.Relay.RelayDataE[0];
// TempRelay &= ReefAngel.Relay.RelayMaskOffE[0];
// TempRelay |= ReefAngel.Relay.RelayMaskOnE[0];
// ReefAngel.LCD.DrawOutletBox(12, 105, TempRelay);
//#endif RelayExp
}
void DrawCustomGraph()
{
}
//End Custom
//*********************************************************************************************************************************
void setup()
{
ReefAngel.Init(); //Initialize controller
//WifiAuthentication("Brad:");
ReefAngel.FeedingModePorts = B10100000;
ReefAngel.WaterChangePorts = B10101000;
ReefAngel.OverheatShutoffPorts = B01000000;
ReefAngel.LightsOnPorts = B00000010;
// Ports that are always on
ReefAngel.Relay.On(PowerCenter);
ReefAngel.Relay.On(Return);
ReefAngel.Relay.On(Reactors);
ReefAngel.Relay.On(Vortechs);
ReefAngel.Relay.On(Refugium);
}
void loop()
{
//Heater on&off
ReefAngel.StandardHeater(Heater,780,792);
//Delay Skimmer
ReefAngel.Relay.DelayedOn(Skimmer, 5);
//call moonphase
if ( hour() <= 6 || hour () >= 19 ) // Moonlights on from 7PM to 7AM
{
ReefAngel.PWM.SetActinic(MoonPhase());
}
else
{
ReefAngel.PWM.SetActinic(0);
}
//Seasons
Seasons();
//Call Cloud Check
CheckCloud();
//Draw PWM value
//ReefAngel.LCD.DrawText(0,255,5,120,PWMChannel[LEDPWM0]);
//ReefAngel.LCD.DrawText(0,255,35,120,PWMChannel[LEDPWM1]);
//ReefAngel.LCD.DrawText(0,255,65,120,PWMChannel[LEDPWM2]);
//ReefAngel.LCD.DrawText(0,255,95,120,PWMChannel[LEDPWM3]);
ReefAngel.ShowInterface();
}
//*********************************************************************************************************************************
//Start of PWM slope function code designed for the PWM Expansion module
void PWMExpansion(byte cmd, byte data)
{
Wire.beginTransmission(8); // transmit to device #2
Wire.send('$'); // sends $
Wire.send('$'); // sends $
Wire.send('$'); // sends $
Wire.send(cmd); // sends a value
Wire.send(data); // sends 255
Wire.endTransmission(); // stop transmitting
}
//End of PWM slope function code designed for the PWM Expansion module
//*********************************************************************************************************************************
//*********************************************************************************************************************************
// Random Cloud/Thunderstorm effects function
void CheckCloud()
{
// ------------------------------------------------------------
// Change the values below to customize your cloud/storm effect
// Frequency in days based on the day of the month - number 2 means every 2 days, for example (day 2,4,6 etc)
// For testing purposes, you can use 1 and cause the cloud to occur everyday
#define Clouds_Every_X_Days 3
// Percentage chance of a cloud happening today
// For testing purposes, you can use 100 and cause the cloud to have 100% chance of happening
#define Cloud_Chance_per_Day 30
// Minimum number of minutes for cloud duration. Don't use max duration of less than 6
#define Min_Cloud_Duration 6
// Maximum number of minutes for the cloud duration. Don't use max duration of more than 255
#define Max_Cloud_Duration 20
// Minimum number of clouds that can happen per day
#define Min_Clouds_per_Day 2
// Maximum number of clouds that can happen per day
#define Max_Clouds_per_Day 5
// Only start the cloud effect after this setting
// In this example, start could after 11:30am
#define Start_Cloud_After NumMins(11,00)
// Always end the cloud effect before this setting
// In this example, end could before 8:00pm
#define End_Cloud_Before NumMins(17,00)
// Percentage chance of a lightning happen for every cloud
// For testing purposes, you can use 100 and cause the lightning to have 100% chance of happening
#define Lightning_Change_per_Cloud 65
// Channels used by the actinic LEDs on the PWM Expansion module
// These channels will not be dimmed when the cloud effect is triggered
// Number is a binary form. B001100 means channel 2 and 3 are used for actinics
#define Actinic_Channels B001110
// Channels used by the daylight LEDs on the PWM Expansion module
// These channels will be used for the spike when lightning effect is triggered
// Number is a binary form. B000011 means channel 0 and 1 are used for daylights
#define Daylight_Channels B000001
// Note: Make sure to choose correct values that will work within your PWMSLope settings.
// For example, in our case, we could have a max of 5 clouds per day and they could last for 50 minutes.
// Which could mean 250 minutes of clouds. We need to make sure the PWMSlope can accomodate 250 minutes of effects or unforseen resul could happen.
// Also, make sure that you can fit double those minutes between Start_Cloud_After and End_Cloud_Before.
// In our example, we have 510 minutes between Start_Cloud_After and End_Cloud_Before, so double the 250 minutes (or 500 minutes) can fit in that 510 minutes window.
// It's a tight fit, but it did.
//#define printdebug // Uncomment this for debug print on Serial Monitor window
#define forcecloudcalculation // Uncomment this to force the cloud calculation to happen in the boot process.
// Change the values above to customize your cloud/storm effect
// ------------------------------------------------------------
// Do not change anything below here
static byte cloudchance=255;
static byte cloudduration=0;
static int cloudstart=0;
static byte numclouds=0;
static byte lightningchance=0;
static byte cloudindex=0;
static byte lightningstatus=0;
static int LastNumMins=0;
// Every day at midnight, we check for chance of cloud happening today
if (hour()==0 && minute()==0 && second()==0) cloudchance=255;
#ifdef forcecloudcalculation
if (cloudchance==255)
#else
if (hour()==0 && minute()==0 && second()==1 && cloudchance==255)
#endif
{
//Pick a random number between 0 and 99
cloudchance=random(100);
// if picked number is greater than Cloud_Chance_per_Day, we will not have clouds today
if (cloudchance>Cloud_Chance_per_Day) cloudchance=0;
// Check if today is day for clouds.
if ((day()%Clouds_Every_X_Days)!=0) cloudchance=0;
// If we have cloud today
if (cloudchance)
{
// pick a random number for number of clouds between Min_Clouds_per_Day and Max_Clouds_per_Day
numclouds=random(Min_Clouds_per_Day,Max_Clouds_per_Day);
// pick the time that the first cloud will start
// the range is calculated between Start_Cloud_After and the even distribuition of clouds on this day.
cloudstart=random(Start_Cloud_After,Start_Cloud_After+((End_Cloud_Before-Start_Cloud_After)/(numclouds*2)));
// pick a random number for the cloud duration of first cloud.
cloudduration=random(Min_Cloud_Duration,Max_Cloud_Duration);
//Pick a random number between 0 and 99
lightningchance=random(100);
// if picked number is greater than Lightning_Change_per_Cloud, we will not have lightning today
if (lightningchance>Lightning_Change_per_Cloud) lightningchance=0;
}
}
// Now that we have all the parameters for the cloud, let's create the effect
if (cloudchance)
{
//is it time for cloud yet?
if (NumMins(hour(),minute())>=cloudstart && NumMins(hour(),minute())<(cloudstart+cloudduration))
{
// let's go through all channels to pick which ones will be dimmed
for (int a=0;a<6;a++)
{
if (bitRead(Actinic_Channels,a)==0)
{
// this will slope down the channel from the current PWM to 0 within 3minutes.
// then it will stay at 0 for the duration of the cycle
// and finally slope up from 0 to PWM value within 3 minutes
// it is basically an inversed slope
PWMChannel[a]=ReversePWMSlope(cloudstart,cloudstart+cloudduration,PWMChannel[a],0,180);
}
}
if (lightningchance && (NumMins(hour(),minute())==(cloudstart+(cloudduration/2))) && second()<5)
{
for (int b=0;b<6;b++)
{
if (bitRead(Daylight_Channels,b)==1)
{
if (random(100)<20) lightningstatus=1;
else lightningstatus=0;
if (lightningstatus) PWMChannel[b]=100;
else PWMChannel[b]=0;
//delay(10);
}
else
{
PWMChannel[b]=20;
}
}
}
}
if (NumMins(hour(),minute())>(cloudstart+cloudduration))
{
cloudindex++;
if (cloudindex < numclouds)
{
cloudstart=random(Start_Cloud_After+(((End_Cloud_Before-Start_Cloud_After)/(numclouds*2))*cloudindex*2),(Start_Cloud_After+(((End_Cloud_Before-Start_Cloud_After)/(numclouds*2))*cloudindex*2))+((End_Cloud_Before-Start_Cloud_After)/(numclouds*2)));
// pick a random number for the cloud duration of first cloud.
cloudduration=random(Min_Cloud_Duration,Max_Cloud_Duration);
//Pick a random number between 0 and 99
lightningchance=random(100);
// if picked number is greater than Lightning_Change_per_Cloud, we will not have lightning today
if (lightningchance>Lightning_Change_per_Cloud) lightningchance=0;
}
}
}
if (LastNumMins!=NumMins(hour(),minute()))
{
LastNumMins=NumMins(hour(),minute());
ReefAngel.LCD.Clear(255,0,120,132,132);
ReefAngel.LCD.DrawText(0,255,5,120,"C");
ReefAngel.LCD.DrawText(0,255,11,120,"00:00");
ReefAngel.LCD.DrawText(0,255,45,120,"L");
ReefAngel.LCD.DrawText(0,255,51,120,"00:00");
if (cloudchance && (NumMins(hour(),minute())<cloudstart))
{
int x=0;
if ((cloudstart/60)>=10) x=11; else x=17;
ReefAngel.LCD.DrawText(0,255,x,120,(cloudstart/60));
if ((cloudstart%60)>=10) x=29; else x=35;
ReefAngel.LCD.DrawText(0,255,x,120,(cloudstart%60));
}
ReefAngel.LCD.DrawText(0,255,90,120,cloudduration);
if (lightningchance)
{
int x=0;
if (((cloudstart+(cloudduration/2))/60)>=10) x=51; else x=57;
ReefAngel.LCD.DrawText(0,255,x,120,((cloudstart+(cloudduration/2))/60));
if (((cloudstart+(cloudduration/2))%60)>=10) x=69; else x=75;
ReefAngel.LCD.DrawText(0,255,x,120,((cloudstart+(cloudduration/2))%60));
}
}
}
//End Cloud Function
//*********************************************************************************************************************************
//*********************************************************************************************************************************
//Reverse PWM slope from cloud function
byte ReversePWMSlope(long cstart,long cend,byte PWMStart,byte PWMEnd, byte clength)
{
long n=elapsedSecsToday(now());
cstart*=60;
cend*=60;
if (n<cstart) return PWMStart;
if (n>=cstart && n<=(cstart+clength)) return map(n,cstart,cstart+clength,PWMStart,PWMEnd);
if (n>(cstart+clength) && n<(cend-clength)) return PWMEnd;
if (n>=(cend-clength) && n<=cend) return map(n,cend-clength,cend,PWMEnd,PWMStart);
if (n>cend) return PWMStart;
}
//End Reverse PWM function
//*********************************************************************************************************************************
//*********************************************************************************************************************************
//Calculate Sunrise/set by date & predefined season & rise/set times
void Seasons()
{
#define forceseasoncalculation
short ndays = 0;
static byte ssn = 0, ssnp = 0, ssnpt = 0;
int wrtime = 0;
int wstime = 0;
int rtime = 0;
int stime = 0;
int vrtime = 0;
int vstime = 0;
int wrhour = 0, wrmin = 0, wrsec = 0,wshour = 0,wsmin = 0, wssec = 0, rhour = 0, rmin = 0, rsec = 0, shour = 0, smin = 0, ssec = 0, vrhour = 0, vrmin = 0, vrsec = 0, vshour = 0, vsmin = 0, vssec = 0;
static byte iDiffrise = 0;
static byte iDiffset = 0;
short risediffperday = 0;
short setdiffperday = 0;
int totalrise = 0;
int totalset = 0;
byte i = 0, tyd=0, s=0;
int DaysPerMonth[12];
byte DaysPerYear = 0;
//rise and set times set by hour and minute. there are 4 seasons however there are 8 highs & lows in rise and set throughout the year first spot is second half of winter starting jan 1st
int risehour[8]= {07,07,07,06,06,05,06,06};
int riseminute[8]={00,30,00,30,00,30,00,30};
int sethour[8] = {17,18,18,19,19,19,19,18};
int setminute[8] = {30,00,30,00,00,30,00,00};
//
if (hour()==0 && minute()==0 && second()==0) ssnp=0;
#ifdef forceseasoncalculation
if (ssnp==0)
#else
if (hour()==0 && minute()==0 && second()==1 && ssnp==0)
#endif
{
//leapyear or not?
if (year()%4 == 0 && !(year()%100 == 0 && year()%400 != 0)) int DaysPerMonth[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
//every other year
else int DaysPerMonth[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
//adding up past months days
for (i=0; i<month() - 1; i++) ndays += DaysPerMonth[i];
//adding current months days, julian day number is output ex: nday = 192
ndays += day();
//output total days in year for final season day count later in code
for(tyd=0;tyd<11;tyd++)DaysPerYear += DaysPerMonth[tyd];
//define days between begin and middle season
int seasons[9] ={0,45,96,135,187,238,283,328,DaysPerYear};
//define season and array pulling variable
for (s=0; seasons[s] < ndays; s++) ssn = s, ssnpt = s, ssnp = s-1;
//set loop on array time pulling variable to go back to beginning instead of increasing array size
if (ssn > 7) ssn = 0;
//differece in seconds between season array times
int rise1 = calcSec(risehour[ssnp],riseminute[ssnp]);
int rise2 = calcSec(risehour[ssn],riseminute[ssn]);
iDiffrise = calcTime(rise1, rise2);
int set1 = calcSec(sethour[ssnp],setminute[ssnp]);
int set2 = calcSec(sethour[ssn],setminute[ssn]);
iDiffset = calcTime(set1,set2);
//calculate new sunrise/set difference from array value
//here we take the difference in day and get a difference in seconds per day. So if the time difference is 30 minutes from the last equation we divide that by the start day of season subtracted by the end day of season to get the number of days in the season
//example: 30 minutes/(day 45 – day 0) = 30/45 = 0.66666
//0.66666 is the difference of minutes each day throughout the season for sunrise
risediffperday = iDiffrise/(seasons[ssnpt]-seasons[ssnp]);
totalrise = risediffperday*(ndays - seasons[ssnp]);
setdiffperday = iDiffset/(seasons[ssnpt]-seasons[ssnp]);
totalset = setdiffperday*(ndays - seasons[ssnp]);
//creating time in seconds
rtime=(risehour[ssnp]*3600)+(riseminute[ssnp]*60);
if (ssnp == 0 || ssnp == 2 || ssnp == 4 || ssnp == 6) rtime =+ totalrise;
else rtime =- totalrise;
stime=(sethour[ssnp]*3600)+(setminute[ssnp]*60);
if (ssnp == 1 || ssnp == 3 || ssnp == 5 || ssnp == 7) stime += totalset;
else stime -= totalset;
//turning seconds back to h m s
//here are three different times offset by half hour to have different colors rise and set at different times
//standard times
rhour=rtime/3600;
rtime=rtime%3600;
rmin=rtime/60;
rtime=rtime%60;
rsec=rtime;
if(rsec > 30) rmin++;
shour=stime/3600;
stime=stime%3600;
smin=stime/60;
stime=stime%60;
ssec=stime;
if(ssec > 30) smin++;
//to change the offset change the number 1200 in seconds added or subtracted to rtime
//half hour shorter
wrtime = rtime + 1200;
wrhour = wrtime/3600;
wrtime=wrtime%3600;
wrmin=wrtime/60;
wrtime=wrtime%60;
wrsec=wrtime;
if(wrsec>30) wrmin++;
wstime = stime - 1200;
wshour = wstime/3600;
wstime=wstime%3600;
wsmin=wstime/60;
wstime=wstime%60;
wssec=wstime;
if(wssec>30) wsmin++;
//half hour longer
vrtime = rtime - 1200;
vrhour = vrtime/3600;
vrtime=vrtime%3600;
vrmin=vrtime/60;
vrtime=vrtime%60;
vrsec=vrtime;
if(vrsec>30) vrmin++;
vstime = stime + 1200;
vshour = vstime/3600;
vstime=vstime%3600;
vsmin=vstime/60;
vstime=vstime%60;
vssec=vstime;
if(vssec>30) vsmin++;
//time for each active led channel to pull for sunrise
int Sunrise[2]={rhour,rmin};
int Sunset[2]={shour,smin};
int whSunrise[2]={wrhour,wrmin};
int whSunset [2]={wshour,wsmin};
int vSunrise[2]={vrhour,vrmin};
int vSunset [2]={vshour,vsmin};
PWMChannel[LEDPWM0]=PWMSlope(whSunrise[1],whSunrise[2],whSunset[1],whSunset[2],0,100,180,PWMChannel[LEDPWM0]);
PWMChannel[LEDPWM1]=PWMSlope(vSunrise[1],vSunrise[2],vSunset[1],vSunset[2],0,100,180,PWMChannel[LEDPWM1]);
PWMChannel[LEDPWM2]=PWMSlope(Sunrise[1],Sunrise[2],Sunset[1],Sunset[2],0,100,180,PWMChannel[LEDPWM2]);
PWMChannel[LEDPWM3]=PWMSlope(Sunrise[1],Sunrise[2],whSunset[1],whSunset[2],0,100,180,PWMChannel[LEDPWM3]);
//return Sunrise, Sunset, whSunrise,whSunset,vSunrise,vSunset;
}}
//End Seasons Calculation
//*********************************************************************************************************************************
//*********************************************************************************************************************************
//Seconds Calculator for Seasons function
int calcSec(int hr, int minu)
{
int hour = hr * 3600;
int min = minu * 60;
int totalseconds=hour+min;
return totalseconds;
}
int calcTime(int seconds1, int seconds2)
{
int timediff=seconds1-seconds2;
return timediff;
}
//End Seconds calculator
//*********************************************************************************************************************************
