ok been a while since i was able to try to work on my ra. i turned off av on install i think its working now but my old code i changed the menu stuff over and i try to verify the code and i get error
Code: Select all
#include <ReefAngel_Features.h>
#include <Globals.h>
#include <RA_Wifi.h>
#include <Wire.h>
#include <OneWire.h>
#include <Time.h>
#include <DS1307RTC.h>
#include <InternalEEPROM.h>
#include <RA_NokiaLCD.h>
#include <RA_ATO.h>
#include <RA_Joystick.h>
#include <LED.h>
#include <RA_TempSensor.h>
#include <Relay.h>
#include <RA_PWM.h>
#include <Timer.h>
#include <Memory.h>
#include <RA_Colors.h>
#include <RA_CustomColors.h>
#include <ReefAngel.h>
#include <SunLocation.h>
#include <Tide.h>
#include <Moon.h>
#include <WiFiAlert.h>
#include <DCPump.h>
// Won't compile without this...
// ReefAngel.DCPump.UseMemory=true;
// Custom menus
#include <avr/pgmspace.h>
const char menu1_label[] PROGMEM = "Feeding Mode";
const char menu2_label[] PROGMEM = "Water Change";
const char menu3_label[] PROGMEM = "ATO Clear";
const char menu4_label[] PROGMEM = "DC Pump Mode";
const char menu5_label[] PROGMEM = "Overheat Clear";
const char menu6_label[] PROGMEM = "PH Calibration";
const char menu7_label[] PROGMEM = "Date / Time";
const char menu8_label[] PROGMEM = "Refugium Light";
// Group the menu entries together
PROGMEM const char *menu_items[] = {
menu1_label, menu2_label, menu3_label,
menu4_label, menu5_label, menu6_label, menu7_label, menu8_label
};
// Define Custom Memory Locations
#define Mem_B_MoonOffset 100
#define Mem_B_AtoHourInterval 101
#define Mem_I_Latitude 108
#define Mem_I_Longitude 110
#define Mem_B_AcclRiseOffset 112
#define Mem_B_AcclSetOffset 113
#define Mem_B_AcclDay 114
#define Mem_B_TideMin 117
#define Mem_B_TideMax 118
#define Mem_B_PumpOffset 119
#define Mem_B_FeedingDCPump 120
#define Mem_B_NightDCPump 121
#define Mem_B_NightSpeed 122
#define Mem_B_NightDuration 123
#define Mem_B_NTMSpeed 124
#define Mem_B_NTMDuration 125
#define Mem_B_NTMDelay 126
#define Mem_B_NTMTime 127
#define Mem_B_TideMode 143
#define Mem_B_CloudsEveryXDays 149
#define Mem_B_CloudChancePerDay 150
#define Mem_B_MinCloudDuration 151
#define Mem_B_MaxCloudDuration 152
#define Mem_B_MinCloudsPerDay 153
#define Mem_B_MaxCloudsPerDay 154
#define Mem_B_StartCloudAfterHour 155
#define Mem_B_StartCloudAfterMin 156
#define Mem_B_EndCloudBeforeHour 157
#define Mem_B_EndCloudBeforeMin 158
#define Mem_B_LightningChance 159
#define Mem_B_LightMode 160
#define Mem_B_LightOffset 161
#define Mem_I_RiseOffset 162
#define Mem_I_SetOffset 164
#define Mem_B_AcclActinicOffset 166
#define Mem_B_AcclDaylightOffset 167
#define Mem_B_RandomMode 168
#define Mem_B_GyreOffset 169
#define Mem_B_MoonMode 170
#define Mem_B_LightsOffPerc 171
#define Mem_B_FeedingSpeed 172
#define Mem_B_WCSpeed 173
#define Mem_B_EnableStorm 178
#define Mem_B_ForceRandomTide 179
#define Mem_B_ResetMemory 199
void init_memory() {
// Initialize Custom Memory Locations
InternalMemory.write(Mem_B_MoonOffset,15); //mb100
InternalMemory.write(Mem_B_AtoHourInterval,1); //mb101
InternalMemory.write_int(Mem_I_Latitude,-21); //mi108
InternalMemory.write_int(Mem_I_Longitude,-147); //mi110
InternalMemory.write(Mem_B_AcclRiseOffset,12); //mb112
InternalMemory.write(Mem_B_AcclSetOffset,13); //mb113
InternalMemory.write(Mem_B_AcclDay,0); //mb114
InternalMemory.write(Mem_B_TideMin,10); //mb117
InternalMemory.write(Mem_B_TideMax,20); //mb118
InternalMemory.write(Mem_B_PumpOffset,80); //mb119
InternalMemory.write(Mem_B_FeedingDCPump,true); //mb120
InternalMemory.write(Mem_B_NightDCPump,false); //mb121
InternalMemory.write(Mem_B_NightSpeed,35); //mb122
InternalMemory.write(Mem_B_NightDuration,16); //mb123
InternalMemory.write(Mem_B_NTMSpeed,100); //mb124
InternalMemory.write(Mem_B_NTMDuration,50); //mb125
InternalMemory.write(Mem_B_NTMDelay,5); //mb126
InternalMemory.write(Mem_B_NTMTime,5); //mb127
InternalMemory.write(Mem_B_TideMode,0); //mb143
InternalMemory.write(Mem_B_CloudsEveryXDays,1); //mb149
InternalMemory.write(Mem_B_CloudChancePerDay,50); //mb150
InternalMemory.write(Mem_B_MinCloudDuration,6); //mb151
InternalMemory.write(Mem_B_MaxCloudDuration,10); //mb152
InternalMemory.write(Mem_B_MinCloudsPerDay,2); //mb153
InternalMemory.write(Mem_B_MaxCloudsPerDay,8); //mb154
InternalMemory.write(Mem_B_StartCloudAfterHour,10); //mb155
InternalMemory.write(Mem_B_StartCloudAfterMin,00); //mb156
InternalMemory.write(Mem_B_EndCloudBeforeHour,22); //mb157
InternalMemory.write(Mem_B_EndCloudBeforeMin,00); //mb158
InternalMemory.write(Mem_B_LightningChance,50); //mb159
InternalMemory.write(Mem_B_LightMode,1); //mb160
InternalMemory.write(Mem_B_LightOffset,30); //mb161
InternalMemory.write_int(Mem_I_RiseOffset,20); //mi162
InternalMemory.write_int(Mem_I_SetOffset,16); //mi164
InternalMemory.write(Mem_B_AcclActinicOffset,250); //mb166
InternalMemory.write(Mem_B_AcclDaylightOffset,125); //mb167
InternalMemory.write(Mem_B_RandomMode,false); //mb168
InternalMemory.write(Mem_B_GyreOffset,10); //mb169
InternalMemory.write(Mem_B_MoonMode,1); //mb170
InternalMemory.write(Mem_B_LightsOffPerc,1); //mb171
InternalMemory.write(Mem_B_FeedingSpeed,0); //mb172
InternalMemory.write(Mem_B_WCSpeed,0); //mb173
InternalMemory.write(Mem_B_ResetMemory,false); //mb199
}
#define NUMBERS_8x16
#define Var_Tide 4
#define Var_TideMode 5
// Define Relay Ports by Name
#define Return 1
#define Heater 2
#define Refugium 3
#define MediaPump 4
#define WhiteLeft 5
#define BlueLeft 6
#define Autotopoff 7
#define Skimmer 8
////// Place global variable code below here
// Custom classes
SunLocation sun;
Tide tide;
// Jebao Variables
byte DCPumpMode, DCPumpSpeed, DCPumpDuration;
// For Cloud and preset code
int DaylightPWMValue=0;
int ActinicPWMValue=0;
int DaylightPWMValue0=0; // For cloud code, channel 0
int DaylightPWMValue2=0; // For cloud code, chennel 2
int ActinicPWMValue1=0; // For cloud code, channel 0
int ActinicPWMValue3=0; // For cloud code, chennel 2
// Needs to be global for DrawCustomGraph()
int ScreenID=1;
////// Place global variable code above here
// Setup on controller startup/reset
void setup()
{
// This must be the first line
ReefAngel.Init(); //Initialize controller
for (int a=0;a<SIZE(menu_items);a++)
ReefAngel.InitMenu(pgm_read_word(&(menu_items[a])),a); // Initialize Menu
// Ports toggled in Feeding Mode
ReefAngel.FeedingModePorts = Port1Bit | Port2Bit ;
// Ports toggled in Water Change Mode
ReefAngel.WaterChangePorts = Port1Bit | Port2Bit | Port4Bit | Port7Bit | Port8Bit;
// Ports toggled when Lights On / Off menu entry selected
ReefAngel.LightsOnPorts = Port3Bit | Port5Bit | Port6Bit;
// Ports turned off when Overheat temperature exceeded
ReefAngel.OverheatShutoffPorts = Port2Bit | Port4Bit;
// Use T1 probe as temperature and overheat functions
ReefAngel.TempProbe = T1_PROBE;
ReefAngel.OverheatProbe = T1_PROBE;
// Feeeding and Water Change mode speed
// Ports that are always on
ReefAngel.Relay.On( Return ); // Return Pump
////// Place additional initialization code below here
ReefAngel.DCPump.UseMemory=false;
randomSeed(now()/SECS_PER_DAY);
if (InternalMemory.read(Mem_B_ResetMemory))
init_memory();
////// Place additional initialization code above here
}
void loop()
{
DelayedOnFeedMode(Return); // DelayedOn after feed mode change only
ReefAngel.Relay.Set(Refugium,!ReefAngel.Relay.Status(WhiteLeft));
ReefAngel.SingleATO(true,Autotopoff, InternalMemory.ATOExtendedTimeout_read(), InternalMemory.read(Mem_B_AtoHourInterval));
ReefAngel.Relay.Set(Skimmer, ReefAngel.HighATO.IsActive());
ReefAngel.DCPump.ExpansionChannel[4] = AntiSync; // Left Jebao RW4
ReefAngel.DCPump.ExpansionChannel[5] = Sync; // Right jebao rw4
ReefAngel.StandardHeater(Heater);
////// Place your custom code below here
// Lighting and Flow
SetSun(); // Setup Sun rise/set lighting
AcclimateLED(); // Apply acclimation dimming
SetMoon(); // Setup Moon rise/set lighting
FillInMoon(); // Fill in 5% to 0% gap in main LEDs
LEDPresets();
CheckCloud(); // Check for cloud and lightning.
UpdateLED();
SetTide(); // Set High/Low tide properties
SetDCPump(); // Set Vortech modes
////// Place your custom code above here
// This should always be the last line
ReefAngel.Portal( "troylong45" );
ReefAngel.DDNS( "1" ); // Your DDNS is troylong45-1.myreefangel.com
ReefAngel.ShowInterface();
}
void SetSun() {
// Start acclimation routine
int acclRiseOffset=InternalMemory.read(Mem_B_AcclRiseOffset)*60;
int acclSetOffset=InternalMemory.read(Mem_B_AcclSetOffset)*60;
byte acclDay=InternalMemory.read(Mem_B_AcclDay);
// See if we are acclimating corals and decrease the countdown each day
static boolean acclCounterReady=false;
if (now()%SECS_PER_DAY!=0) acclCounterReady=true;
if (now()%SECS_PER_DAY==0 && acclCounterReady && acclDay>0) {
acclDay--;
acclCounterReady=false;
InternalMemory.write(Mem_B_AcclDay,acclDay);
}
// End acclimation
// Add some customizable offsets
sun.Init(InternalMemory.read_int(Mem_I_Latitude), InternalMemory.read_int(Mem_I_Longitude));
int riseOffset=InternalMemory.read_int(Mem_I_RiseOffset);
int setOffset=InternalMemory.read_int(Mem_I_SetOffset);
sun.SetOffset(riseOffset,(acclDay*acclRiseOffset),setOffset,(-acclDay*acclSetOffset)); // Bahamas
sun.CheckAndUpdate(); // Calculate today's Sunrise / Sunset
byte lightOffset=InternalMemory.read(Mem_B_LightOffset); // left right separation
byte actinicOffset=InternalMemory.ActinicOffset_read();
// Make sure light resets to zero at night.
for(int i=0;i<4;i++) { ReefAngel.PWM.SetChannel(i,0); }
switch(InternalMemory.read(Mem_B_LightMode)) {
case 0: {
// Daylights
ReefAngel.PWM.Channel0PWMSlope(lightOffset,0);
ReefAngel.PWM.Channel2PWMSlope(0,lightOffset);
// Actinics
ReefAngel.PWM.Channel1PWMSlope(actinicOffset+lightOffset,actinicOffset);
ReefAngel.PWM.Channel3PWMSlope(actinicOffset,actinicOffset+lightOffset);
break;
}
case 1: {
// Daylights
ReefAngel.PWM.Channel0PWMParabola(lightOffset,0);
ReefAngel.PWM.Channel2PWMParabola(0,lightOffset);
// Actinics
ReefAngel.PWM.Channel1PWMParabola(actinicOffset+lightOffset,actinicOffset);
ReefAngel.PWM.Channel3PWMParabola(actinicOffset,actinicOffset+lightOffset);
break;
}
case 2: {
// Daylights
ReefAngel.PWM.Channel0PWMSmoothRamp(lightOffset,0);
ReefAngel.PWM.Channel2PWMSmoothRamp(0,lightOffset);
// Actinics
ReefAngel.PWM.Channel1PWMSmoothRamp(actinicOffset+lightOffset,actinicOffset);
ReefAngel.PWM.Channel3PWMSmoothRamp(actinicOffset,actinicOffset+lightOffset);
break;
}
case 3: {
// Daylights
ReefAngel.PWM.Channel0PWMSigmoid(lightOffset,0);
ReefAngel.PWM.Channel2PWMSigmoid(0,lightOffset);
// Actinics
ReefAngel.PWM.Channel1PWMSigmoid(actinicOffset+lightOffset,actinicOffset);
ReefAngel.PWM.Channel3PWMSigmoid(actinicOffset,actinicOffset+lightOffset);
break;
}
case 4: { // Reverse the actinics in the morning
// Daylights
ReefAngel.PWM.Channel0PWMParabola(lightOffset+actinicOffset,0);
ReefAngel.PWM.Channel2PWMParabola(actinicOffset,lightOffset);
// Actinics
ReefAngel.PWM.Channel1PWMParabola(lightOffset,actinicOffset);
ReefAngel.PWM.Channel3PWMParabola(0,actinicOffset+lightOffset);
break;
}
}
}
void SetMoon() {
byte offset=InternalMemory.read(Mem_B_MoonOffset);
byte startD=InternalMemory.read(Mem_B_PWMSlopeStartD);
byte endD=InternalMemory.read(Mem_B_PWMSlopeEndD);
byte timeD=InternalMemory.read(Mem_B_PWMSlopeDurationD);
byte startA=InternalMemory.read(Mem_B_PWMSlopeStartA);
byte endA=InternalMemory.read(Mem_B_PWMSlopeEndA);
byte timeA=InternalMemory.read(Mem_B_PWMSlopeDurationA);
time_t onTime=ScheduleTime(Moon.riseH, Moon.riseM,0);
time_t offTime=ScheduleTime(Moon.setH, Moon.setM,0);
time_t offsetOnTime=ScheduleTime(Moon.riseH, Moon.riseM,0)-(offset*60);
time_t offsetOffTime=ScheduleTime(Moon.setH, Moon.setM,0)-(offset*60);
byte actRiseH=(offsetOnTime%SECS_PER_DAY)/SECS_PER_HOUR;
byte actRiseM=((offsetOnTime%SECS_PER_DAY)%SECS_PER_HOUR)/60;
byte actSetH=(offsetOffTime%SECS_PER_DAY)/SECS_PER_HOUR;
byte actSetM=((offsetOffTime%SECS_PER_DAY)%SECS_PER_HOUR)/60;
static byte mp=MoonPhase();
if (mp!=MoonPhase()) {
InternalMemory.write(Mem_B_PWMSlopeEndD,mp);
InternalMemory.write(Mem_B_PWMSlopeEndA,mp);
mp=MoonPhase();
}
moon_init(InternalMemory.read_int(Mem_I_Latitude), InternalMemory.read_int(Mem_I_Longitude));
// Make sure light resets to zero at night.
ReefAngel.PWM.SetDaylight(0);
ReefAngel.PWM.SetActinic(0);
switch(InternalMemory.read(Mem_B_MoonMode)) {
case 0: {
// Daylights
ReefAngel.PWM.SetDaylightRaw(PWMSlopeHighRes(Moon.riseH,Moon.riseM,Moon.setH,Moon.setM,startA,endA,timeA,0));
ReefAngel.PWM.SetActinicRaw(PWMSlopeHighRes(actRiseH,actRiseM,actSetH,actSetM,startD,endD,timeD,0));
break;
}
case 1: {
ReefAngel.PWM.SetDaylightRaw(PWMParabolaHighRes(Moon.riseH,Moon.riseM,Moon.setH,Moon.setM, startA,endA,0));
ReefAngel.PWM.SetActinicRaw(PWMParabolaHighRes(actRiseH,actRiseM,actSetH,actSetM, startD,endD,0));
break;
}
case 2: {
ReefAngel.PWM.SetDaylightRaw(PWMSmoothRampHighRes(Moon.riseH,Moon.riseM,Moon.setH,Moon.setM,startA,endA,timeA,0));
ReefAngel.PWM.SetActinicRaw(PWMSmoothRampHighRes(actRiseH,actRiseM,actSetH,actSetM,startD,endD,timeD,0));
break;
}
case 3: {
ReefAngel.PWM.SetDaylightRaw(PWMSigmoidHighRes(Moon.riseH,Moon.riseM,Moon.setH,Moon.setM,startA,endA,0));
ReefAngel.PWM.SetActinicRaw(PWMSigmoidHighRes(actRiseH,actRiseM,actSetH,actSetM,startD,endD,0));
break;
}
}
}
void FillInMoon() {
// Extend the sunrise/sunset to fill in gaps when fixtures shut off.
byte actinicOffset=InternalMemory.ActinicOffset_read();
byte lightOffset=InternalMemory.read(Mem_B_LightOffset); // left right separation
int LightsOffPerc=40.95*InternalMemory.read(Mem_B_LightsOffPerc);
int onTime=NumMins(InternalMemory.StdLightsOnHour_read(),InternalMemory.StdLightsOnMinute_read())-(actinicOffset+(2*lightOffset));
int offTime=NumMins(InternalMemory.StdLightsOffHour_read(),InternalMemory.StdLightsOffMinute_read())+(actinicOffset+(2*lightOffset));
int moonVal=ReefAngel.PWM.GetDaylightValueRaw();
int channelVal=PWMSlopeHighRes(onTime/60,onTime%60,offTime/60,offTime%60,0,100,lightOffset,0);
if (ReefAngel.PWM.GetChannelValueRaw(1)<=LightsOffPerc && channelVal>ReefAngel.PWM.GetDaylightValueRaw())
ReefAngel.PWM.SetDaylightRaw(channelVal);
if (ReefAngel.PWM.GetChannelValueRaw(3)<=LightsOffPerc && channelVal>ReefAngel.PWM.GetActinicValueRaw())
ReefAngel.PWM.SetActinicRaw(channelVal);
DaylightPWMValue=ReefAngel.PWM.GetDaylightValueRaw();
ActinicPWMValue=ReefAngel.PWM.GetActinicValueRaw();
}
void AcclimateLED() {
byte acclDay=InternalMemory.read(Mem_B_AcclDay);
if (acclDay > 0) {
float acclActinicOffset=acclDay*(40.95*(((float)InternalMemory.read(Mem_B_AcclActinicOffset)/100)));
float acclDaylightOffset=acclDay*(40.95*((float)InternalMemory.read(Mem_B_AcclDaylightOffset)/100));
float endPerc;
endPerc=40.95*InternalMemory.PWMSlopeEnd1_read();
ReefAngel.PWM.SetChannelRaw(1,map(ReefAngel.PWM.GetChannelValueRaw(1),0,endPerc,0,endPerc-acclActinicOffset));
endPerc=40.95*InternalMemory.PWMSlopeEnd3_read();
ReefAngel.PWM.SetChannelRaw(3,map(ReefAngel.PWM.GetChannelValueRaw(3),0,endPerc,0,endPerc-acclActinicOffset));
endPerc=40.95*InternalMemory.PWMSlopeEnd0_read();
ReefAngel.PWM.SetChannelRaw(0,map(ReefAngel.PWM.GetChannelValueRaw(0),0,endPerc,0,endPerc-acclDaylightOffset));
endPerc=40.95*InternalMemory.PWMSlopeEnd2_read();
ReefAngel.PWM.SetChannelRaw(2,map(ReefAngel.PWM.GetChannelValueRaw(2),0,endPerc,0,endPerc-acclDaylightOffset));
}
}
#define LED_1to1 Box2_Port1
#define LED_2to1 Box2_Port2
#define LED_3to1 Box2_Port3
#define LED_BLUE Box2_Port4
#define LED_WHITE Box2_Port5
#define LED_MOON Box2_Port6
#define LED_STORM Box2_Port7
#define TRIGGER_STORM Box2_Port8
void resetRelayBox(byte ID) {
// toggle all relays except for the one selected
for (int i=Box2_Port1;i<=Box2_Port4;i++) {
if (i!=ID) ReefAngel.Relay.Auto(i);
}
}
void LEDPresets() {
static byte lastPreset=0;
DaylightPWMValue0=ReefAngel.PWM.GetChannelValueRaw(0);
ActinicPWMValue1=ReefAngel.PWM.GetChannelValueRaw(1);
DaylightPWMValue2=ReefAngel.PWM.GetChannelValueRaw(2);
ActinicPWMValue3=ReefAngel.PWM.GetChannelValueRaw(3);
DaylightPWMValue=ReefAngel.PWM.GetDaylightValueRaw();
ActinicPWMValue=ReefAngel.PWM.GetActinicValueRaw();
if (ReefAngel.Relay.isMaskOn(LED_1to1)) {
if (lastPreset!=1) resetRelayBox(LED_1to1);
DaylightPWMValue0=90*40.95;
ActinicPWMValue1=10*40.95;
DaylightPWMValue2=90*40.95;
ActinicPWMValue3=10*40.95;
lastPreset=1;
}
if (ReefAngel.Relay.isMaskOff(LED_1to1)) {
if (lastPreset!=2) resetRelayBox(LED_1to1);
DaylightPWMValue0=10*40.95;
ActinicPWMValue1=90*40.95;
DaylightPWMValue2=10*40.95;
ActinicPWMValue3=90*40.95;
lastPreset=2;
}
if (ReefAngel.Relay.isMaskOn(LED_2to1)) {
if (lastPreset!=3) resetRelayBox(LED_2to1);
DaylightPWMValue0=60*40.95;
ActinicPWMValue1=40*40.95;
DaylightPWMValue2=60*40.95;
ActinicPWMValue3=40*40.95;
lastPreset=3;
}
if (ReefAngel.Relay.isMaskOff(LED_2to1)) {
if (lastPreset!=4) resetRelayBox(LED_2to1);
DaylightPWMValue0=40*40.95;
ActinicPWMValue1=60*40.95;
DaylightPWMValue2=40*40.95;
ActinicPWMValue3=60*40.95;
lastPreset=4;
}
if (ReefAngel.Relay.isMaskOn(LED_3to1)) {
if (lastPreset!=5) resetRelayBox(LED_3to1);
DaylightPWMValue0=75*40.95;
ActinicPWMValue1=25*40.95;
DaylightPWMValue2=75*40.95;
ActinicPWMValue3=25*40.95;
lastPreset=5;
}
if (ReefAngel.Relay.isMaskOff(LED_3to1)) {
if (lastPreset!=6) resetRelayBox(LED_3to1);
DaylightPWMValue0=25*40.95;
ActinicPWMValue1=75*40.95;
DaylightPWMValue2=25*40.95;
ActinicPWMValue3=75*40.95;
lastPreset=6;
}
if (ReefAngel.Relay.isMaskOn(LED_BLUE)) {
if (lastPreset!=9) resetRelayBox(LED_BLUE);
DaylightPWMValue0=0;
ActinicPWMValue1=80*40.95;
DaylightPWMValue2=0;
ActinicPWMValue3=80*40.95;
lastPreset=9;
}
if (ReefAngel.Relay.isMaskOff(LED_BLUE)) {
if (lastPreset!=10) resetRelayBox(LED_BLUE);
ActinicPWMValue1=0;
ActinicPWMValue3=0;
lastPreset=10;
}
if (ReefAngel.Relay.isMaskOn(LED_WHITE)) {
if (lastPreset!=11) resetRelayBox(LED_WHITE);
DaylightPWMValue0=80*40.95;
ActinicPWMValue1=0;
DaylightPWMValue2=80*40.95;
ActinicPWMValue3=0;
lastPreset=11;
}
if (ReefAngel.Relay.isMaskOff(LED_WHITE)) {
if (lastPreset!=12) resetRelayBox(LED_WHITE);
DaylightPWMValue0=0;
DaylightPWMValue2=0;
lastPreset=12;
}
if (ReefAngel.Relay.isMaskOn(LED_MOON)) {
if (lastPreset!=13) resetRelayBox(LED_MOON);
DaylightPWMValue=4095;
ActinicPWMValue=4095;
lastPreset=13;
}
if (ReefAngel.Relay.isMaskOff(LED_MOON)) {
if (lastPreset!=14) resetRelayBox(LED_MOON);
DaylightPWMValue=0;
ActinicPWMValue=0;
lastPreset=14;
}
}
// Write updated values to the channels
void UpdateLED() {
ReefAngel.PWM.SetChannelRaw(0,DaylightPWMValue0);
ReefAngel.PWM.SetChannelRaw(1,ActinicPWMValue1);
ReefAngel.PWM.SetChannelRaw(2,DaylightPWMValue2);
ReefAngel.PWM.SetChannelRaw(3,ActinicPWMValue3);
ReefAngel.PWM.SetDaylightRaw(DaylightPWMValue);
ReefAngel.PWM.SetActinicRaw(ActinicPWMValue);
byte LightsOffPerc=40.95*InternalMemory.read(Mem_B_LightsOffPerc);
if (ReefAngel.PWM.GetChannelValueRaw(0)>=LightsOffPerc) ReefAngel.Relay.On(WhiteLeft); else ReefAngel.Relay.Off(WhiteLeft);
if (ReefAngel.PWM.GetChannelValueRaw(1)>=LightsOffPerc) ReefAngel.Relay.On(BlueLeft); else ReefAngel.Relay.Off(BlueLeft);
}
void SetTide() {
byte nightSpeed=InternalMemory.read(Mem_B_NightSpeed);
byte tideMin=InternalMemory.read(Mem_B_TideMin);
byte tideMax=InternalMemory.read(Mem_B_TideMax);
// Set tide offsets
tide.SetOffset(tideMin, tideMax);
// Set tide speed. Slope in/out of Night Mode
tide.SetSpeed(PWMSlope(sun.GetRiseHour()-1,sun.GetRiseMinute(),
sun.GetSetHour(),sun.GetSetMinute(),nightSpeed+tideMin,DCPumpSpeed,120,nightSpeed+tideMin));
// Show tide info on portal
ReefAngel.CustomVar[Var_Tide]=tide.CalcTide();
}
void SetDCPump() {
int ntmDelay=InternalMemory.read(Mem_B_NTMDelay)*60;
int ntmTime=InternalMemory.read(Mem_B_NTMTime)*60;
boolean nightDCPump=InternalMemory.read(Mem_B_NightDCPump);
boolean feedingDCPump=InternalMemory.read(Mem_B_FeedingDCPump);
static time_t t;
ReefAngel.DCPump.FeedingSpeed=InternalMemory.read(Mem_B_FeedingSpeed);
ReefAngel.DCPump.WaterChangeSpeed=InternalMemory.read(Mem_B_WCSpeed);
DCPumpMode=InternalMemory.DCPumpMode_read();
DCPumpSpeed=InternalMemory.DCPumpSpeed_read();
DCPumpDuration=InternalMemory.DCPumpDuration_read();
if ((now()-t > ntmDelay && now()-t < ntmTime+ntmDelay) && feedingDCPump) {
// Post feeding mode
DCPumpMode=Smart_NTM;
DCPumpSpeed=InternalMemory.read(Mem_B_NTMSpeed);
DCPumpDuration=InternalMemory.read(Mem_B_NTMDuration);
} else if (!sun.IsDaytime() && nightDCPump) {
DCPumpMode=Night;
DCPumpSpeed=InternalMemory.read(Mem_B_NightSpeed);
DCPumpDuration=InternalMemory.read(Mem_B_NightDuration);
} else {
if (DCPumpMode!=Night && ReefAngel.DCPump.Mode==Night)
ReefAngel.DCPump.SetMode(Night_Stop,0,0);
}
if (ReefAngel.DisplayedMenu==FEEDING_MODE) {
t=now(); // Run post feeding mode when this counter stops
} else if (ReefAngel.DisplayedMenu==WATERCHANGE_MODE) {
// Not needed anymore.
// ReefAngel.DCPump.SetMode(Constant,25,0);
} else {
if ((DCPumpMode==Smart_NTM) || (DCPumpMode==ShortPulse)) DCPumpDuration=InternalMemory.read(Mem_B_NTMDuration);
(DCPumpMode==Custom) ? DCPumpCustom() : ReefAngel.DCPump.SetMode(DCPumpMode,DCPumpSpeed,DCPumpDuration);
}
}
void RefugiumLight() {if (ReefAngel.DisplayedMenu==WATERCHANGE_MODE) {
ReefAngel.Relay.On(Refugium);} }
void DCPumpCustom() {
static boolean changeMode;
byte rcSpeed, rcSpeedAS;
// Define new modes
const int BHazard=15;
const int RA_ReefCrest=16;
const int RA_Lagoon=17;
const int RA_TidalSwell=18;
const int RA_Smart_NTM=19;
const int RA_ShortPulse=20;
const int RA_LongPulse=21;
byte tideSpeed=tide.CalcTide();
byte tideMin=InternalMemory.read(Mem_B_TideMin);
byte tideMax=InternalMemory.read(Mem_B_TideMax);
byte tideMode=InternalMemory.read(Mem_B_TideMode);
float pumpOffset=(float) InternalMemory.read(Mem_B_PumpOffset)/100;
byte RandomModes[]={ ReefCrest, TidalSwell, Smart_NTM, Lagoon, ShortPulse, LongPulse, BHazard, Else, Sine, Constant };
// if (now()%SECS_PER_DAY!=0 && InternalMemory.read(Mem_B_RandomMode)) changeMode=true;
// if (now()%SECS_PER_DAY==0 && changeMode) {
if (now()%(6*SECS_PER_HOUR)!=10 && InternalMemory.read(Mem_B_RandomMode)) changeMode=true;
if (now()%(6*SECS_PER_HOUR)==10 && changeMode) {
tideMode=random(100)%sizeof(RandomModes);
InternalMemory.write(Mem_B_TideMode,tideMode);
changeMode=false;
}
// Choose another random mode if triggered
if (InternalMemory.read(Mem_B_ForceRandomTide)) {
tideMode=random(100)%sizeof(RandomModes);
InternalMemory.write(Mem_B_TideMode,tideMode);
InternalMemory.write(Mem_B_ForceRandomTide,false);
}
ReefAngel.CustomVar[Var_TideMode]=tideMode+1;
switch (RandomModes[tideMode]) {
case ReefCrest: {
ReefAngel.DCPump.SetMode(ReefCrest,tideSpeed,DCPumpDuration);
return;
break;
}
case Lagoon: {
ReefAngel.DCPump.SetMode(Lagoon,tideSpeed,DCPumpDuration);
return;
break;
}
case TidalSwell: {
ReefAngel.DCPump.SetMode(TidalSwell,tideSpeed,DCPumpDuration);
return;
break;
}
case Smart_NTM: {
ReefAngel.DCPump.SetMode(Smart_NTM,tideSpeed,DCPumpDuration);
return;
break;
}
case ShortPulse: {
ReefAngel.DCPump.SetMode(ShortPulse,tideSpeed,DCPumpDuration);
return;
break;
}
case LongPulse: {
ReefAngel.DCPump.SetMode(LongPulse,tideSpeed,DCPumpDuration);
return;
break;
}
case RA_ReefCrest: {
rcSpeed=ReefCrestMode(tideSpeed,DCPumpDuration*2,true);
rcSpeedAS=ReefCrestMode(tideSpeed,DCPumpDuration*2,false);
break;
}
case RA_Lagoon: {
rcSpeed=ReefCrestMode(tideSpeed,DCPumpDuration,true);
rcSpeedAS=ReefCrestMode(tideSpeed,DCPumpDuration,false);
break;
}
case RA_TidalSwell: {
rcSpeed=TidalSwellMode(tideSpeed,true);
rcSpeedAS=TidalSwellMode(tideSpeed,false);
break;
}
case RA_Smart_NTM: {
rcSpeed=NutrientTransportMode(0,tideSpeed,DCPumpDuration*50,true);
rcSpeedAS=NutrientTransportMode(0,tideSpeed,DCPumpDuration*50,false);
break;
}
case RA_ShortPulse: {
rcSpeed=ShortPulseMode(0,tideSpeed,DCPumpDuration*50,true);
rcSpeedAS=ShortPulseMode(0,tideSpeed,DCPumpDuration*50,false);
break;
}
case RA_LongPulse: {
rcSpeed=LongPulseMode(0,tideSpeed,DCPumpDuration,true);
rcSpeedAS=LongPulseMode(0,tideSpeed,DCPumpDuration,false);
break;
}
case Else: {
rcSpeed=ElseMode(tideSpeed,DCPumpDuration*2,true);
rcSpeedAS=ElseMode(tideSpeed,DCPumpDuration*2,false);
break;
}
case BHazard: {
rcSpeed=millis()%1200>800?tideSpeed:0;
rcSpeedAS=millis()%1200<400?0:tideSpeed;
break;
}
case Sine: {
rcSpeed=SineMode(tideSpeed-tideMin,tideSpeed+tideMin,DCPumpDuration*100,true);
rcSpeedAS=SineMode(tideSpeed-tideMin,tideSpeed+tideMin,DCPumpDuration*100,false);
break;
}
default: {
rcSpeed=tideSpeed;
rcSpeedAS=tideSpeed;
pumpOffset=(float) InternalMemory.read(Mem_B_GyreOffset)/100;
}
}
ReefAngel.DCPump.SetMode(Custom,rcSpeedAS*pumpOffset,tide.isOutgoing());
ReefAngel.DCPump.SetMode(Custom,rcSpeed,tide.isIncoming());
}
void NextDCPumpMode() {
DCPumpMode++;
if (DCPumpMode > 12) {
DCPumpMode=0;
DCPumpSpeed=50; // Constant
} else if (DCPumpMode == 1) {
DCPumpSpeed=40; // Lagoon
} else if (DCPumpMode == 2) {
DCPumpSpeed=45; // Reef Crest
} else if (DCPumpMode == 3) {
DCPumpSpeed=55; DCPumpDuration=10; // Short Pulse
} else if (DCPumpMode == 4) {
DCPumpSpeed=55; DCPumpDuration=20; // Long Pulse
} else if (DCPumpMode == 5) {
DCPumpSpeed=InternalMemory.read(Mem_B_NTMSpeed);
DCPumpDuration=InternalMemory.read(Mem_B_NTMDuration); // Smart_NTM
} else if (DCPumpMode == 6) {
DCPumpSpeed=50; DCPumpDuration=10; // Smart_TSM
} else if (DCPumpMode == 7) {
DCPumpSpeed=InternalMemory.read(Mem_B_NightSpeed);
DCPumpDuration=InternalMemory.read(Mem_B_NightDuration);
DCPumpMode=9; // Night
} else if (DCPumpMode == 10) {
DCPumpSpeed=65; DCPumpDuration=5; // Storm
} else if (DCPumpMode == 11) {
DCPumpSpeed=45; DCPumpDuration=10; // Custom
}
if (DCPumpMode!=InternalMemory.DCPumpMode_read())
InternalMemory.DCPumpMode_write(DCPumpMode);
if (DCPumpSpeed!=InternalMemory.DCPumpSpeed_read())
InternalMemory.DCPumpSpeed_write(DCPumpSpeed);
if (DCPumpDuration!=InternalMemory.DCPumpDuration_read())
InternalMemory.DCPumpDuration_write(DCPumpDuration);
}
// Menu Code
void MenuEntry1() {
ReefAngel.FeedingModeStart();
}
void MenuEntry2() {
ReefAngel.WaterChangeModeStart();
}
void MenuEntry3() {
ReefAngel.ATOClear();
ReefAngel.DisplayMenuEntry("Clear ATO Timeout");
}
void MenuEntry4() {
NextDCPumpMode();
ReefAngel.DisplayedMenu = RETURN_MAIN_MODE;
}
void MenuEntry5() {
ReefAngel.SetupCalibratePH();
}
void MenuEntry6() {
ReefAngel.OverheatClear();
ReefAngel.DisplayMenuEntry("Clear Overheat");
}
void MenuEntry7() {
ReefAngel.SetupDateTime();
}
void MenuEntry8() {
// Toggle refugium light between on/auto.
ReefAngel.Relay.Override(Refugium, ReefAngel.Relay.Status(Refugium)+1);
ReefAngel.DisplayedMenu = RETURN_MAIN_MODE;
}
// Custom Main Screen
void DrawCustomMain() {
const int NumScreens=4;
static boolean drawGraph=true;
// Main Header
// ReefAngel.LCD.DrawText(DefaultFGColor, DefaultBGColor, 35, 2,"Troy's Reef");
ReefAngel.LCD.DrawDate(5,2);
ReefAngel.LCD.Clear(COLOR_BLACK, 1, 11, 128, 11);
// Param Header
DrawParams(5,14);
switch (ScreenID) {
case 0:
{
if (drawGraph) { ReefAngel.LCD.DrawGraph(5,40); drawGraph=false; }
break;
}
case 1: { DrawStatus(5,40); break; }
case 2: { DrawSunMoon(5,40); break; }
case 3: { DrawClouds(5,50); break; }
}
// Draw Relays
DrawRelays(12,94);
// Date+Time
// ReefAngel.LCD.DrawDate(5,122);
if (ReefAngel.Joystick.IsLeft()) {
ReefAngel.ClearScreen(DefaultBGColor);
ScreenID--; drawGraph=true;
}
if (ReefAngel.Joystick.IsRight()) {
ReefAngel.ClearScreen(DefaultBGColor);
ScreenID++; drawGraph=true;
}
if (ScreenID<0) ScreenID=NumScreens-1;
if (ScreenID>=NumScreens) ScreenID=0;
}
void DrawCustomGraph() {
if (ScreenID==0)
ReefAngel.LCD.DrawGraph(5, 40);
}
void DrawParams(int x, int y) {
char buf[16];
ReefAngel.LCD.DrawText(COLOR_BLACK,DefaultBGColor,x+5,y,"Temp:");
ReefAngel.LCD.DrawText(COLOR_BLACK,DefaultBGColor,x+80, y, "PH:");
// Temp and PH
y+=2;
ConvertNumToString(buf, ReefAngel.Params.Temp[T2_PROBE], 10);
ReefAngel.LCD.DrawText(T2TempColor, DefaultBGColor, x+45, y, buf);
y+=6;
ConvertNumToString(buf, ReefAngel.Params.Temp[T1_PROBE], 10);
ReefAngel.LCD.DrawLargeText(T1TempColor, DefaultBGColor, x+5, y, buf, Num8x16);
ConvertNumToString(buf, ReefAngel.Params.PH, 100);
ReefAngel.LCD.DrawLargeText(PHColor, DefaultBGColor, x+80, y, buf, Num8x16);
y+=5;
ConvertNumToString(buf, ReefAngel.Params.Temp[T3_PROBE], 10);
ReefAngel.LCD.DrawText(T3TempColor, DefaultBGColor, x+45, y, buf);
}
void DrawStatus(int x, int y) {
int t=x;
ReefAngel.LCD.DrawLargeText(COLOR_INDIGO,DefaultBGColor,15,y,"High",Font8x16);
ReefAngel.LCD.DrawLargeText(COLOR_INDIGO,DefaultBGColor,85,y,"Low",Font8x16);
if (ReefAngel.HighATO.IsActive()) {
ReefAngel.LCD.FillCircle(55,y+3,5,COLOR_GREEN);
} else {
ReefAngel.LCD.FillCircle(55,y+3,5,COLOR_RED);
}
if (ReefAngel.LowATO.IsActive()) {
ReefAngel.LCD.FillCircle(70,y+3,5,COLOR_GREEN);
} else {
ReefAngel.LCD.FillCircle(70,y+3,5,COLOR_RED);
}
y+=12;
// DC Pump Mode
ReefAngel.LCD.DrawText(0,255,x,y,"DC:"); x+=20;
ReefAngel.LCD.Clear(DefaultBGColor,x,y,t+(128-t),y+8);
if (DCPumpMode == 0) ReefAngel.LCD.DrawLargeText(COLOR_GREEN,255,x,y,"Constant");
else if (DCPumpMode == 1) ReefAngel.LCD.DrawLargeText(COLOR_GOLD,255,x,y,"Lagoon");
else if (DCPumpMode == 2) ReefAngel.LCD.DrawLargeText(COLOR_GOLD,255,x,y,"Reef Crest");
else if (DCPumpMode == 3) ReefAngel.LCD.DrawLargeText(COLOR_RED,255,x,y,"Short Pulse");
else if (DCPumpMode == 4) ReefAngel.LCD.DrawLargeText(COLOR_RED,255,x,y,"Long Pulse");
else if (DCPumpMode == 5) ReefAngel.LCD.DrawLargeText(COLOR_MAGENTA,255,x,y,"Smart NTM");
else if (DCPumpMode == 6) ReefAngel.LCD.DrawLargeText(COLOR_MAGENTA,255,x,y,"Tidal Swell");
else if (DCPumpMode == 9) ReefAngel.LCD.DrawLargeText(COLOR_WHITE,0,x,y,"Night");
else if (DCPumpMode == 10) ReefAngel.LCD.DrawLargeText(COLOR_BLUE,0,x,y,"Storm");
else if (DCPumpMode == 11) ReefAngel.LCD.DrawLargeText(COLOR_BLUE,255,x,y,"Custom");
y+=10; x=t;
ReefAngel.LCD.DrawText(0,255,x,y,"DC Speed:"); x+=60;
ReefAngel.LCD.Clear(DefaultBGColor,x,y,128,y+8);
ReefAngel.LCD.DrawText(COLOR_BLUE, DefaultBGColor,x,y,DCPumpSpeed); x+=15;
ReefAngel.LCD.DrawText(COLOR_BLUE, DefaultBGColor,x,y,"/"); x+=10;
ReefAngel.LCD.DrawText(COLOR_BLUE, DefaultBGColor,x,y,DCPumpDuration);
y+=10; x=t;
// Display Acclimation timer
byte acclDay=InternalMemory.read(Mem_B_AcclDay);
if (acclDay > 0) {
ReefAngel.LCD.DrawText(DefaultFGColor,DefaultBGColor,x,y,"Acclimation Day:"); x+=100;
ReefAngel.LCD.DrawSingleMonitor(acclDay,DefaultFGColor,x,y,1);
} else {
ReefAngel.LCD.Clear(DefaultBGColor,x,y,128,y+8);
}
}
void DrawSunMoon(int x, int y) {
char buf[16];
int t=x;
y+=2;
/// Display Sunrise / Sunset
sprintf(buf, "%02d:%02d", sun.GetRiseHour(), sun.GetRiseMinute());
ReefAngel.LCD.DrawText(COLOR_BLACK,DefaultBGColor,x,y,"Rise:"); x+=31;
ReefAngel.LCD.DrawText(COLOR_RED,DefaultBGColor,x,y,buf);
sprintf(buf, "%02d:%02d", sun.GetSetHour(), sun.GetSetMinute()); x+=36;
ReefAngel.LCD.DrawText(COLOR_BLACK,DefaultBGColor,x,y,"Set:"); x+=25;
ReefAngel.LCD.DrawText(COLOR_RED,DefaultBGColor,x,y,buf);
y+=15; x=t;
/// Display Moonrise / Moonset
sprintf(buf, "%02d:%02d", Moon.riseH, Moon.riseM);
ReefAngel.LCD.DrawText(COLOR_BLACK,DefaultBGColor,x,y,"MR:"); x+=21;
ReefAngel.LCD.DrawText(COLOR_RED,DefaultBGColor,x,y,buf);
sprintf(buf, "%02d:%02d", Moon.setH, Moon.setM); x+=36;
ReefAngel.LCD.DrawText(COLOR_BLACK,DefaultBGColor,x,y,"MS:"); x+=21;
ReefAngel.LCD.DrawText(COLOR_RED,DefaultBGColor,x,y,buf); x+=36;
if (Moon.isUp) ReefAngel.LCD.DrawText(COLOR_RED,DefaultBGColor,x,y,"@");
else ReefAngel.LCD.DrawText(COLOR_RED,DefaultBGColor,x,y,"_");
y+=10; x=t;
// MoonPhase
ReefAngel.LCD.DrawText(0,255,x,y,"Moon:");
ReefAngel.LCD.Clear(DefaultBGColor,x+32,y,128,y+8);
ReefAngel.LCD.DrawText(COLOR_MAGENTA,255,x+32,y,MoonPhaseLabel());
y+=10; x=t;
// MoonLight %
ReefAngel.LCD.DrawText(COLOR_BLACK,DefaultBGColor,x,y,"MoonLights:"); x+=68;
ReefAngel.LCD.DrawSingleMonitor(ReefAngel.PWM.GetDaylightValue(),DPColor,x,y,1);
x+=5*(intlength(ReefAngel.PWM.GetDaylightValue())+1);
ReefAngel.LCD.DrawText(DPColor, DefaultBGColor, x, y, "%");
}
void DrawRelays(int x, int y) {
// Draw Relays
byte TempRelay = ReefAngel.Relay.RelayData;
TempRelay &= ReefAngel.Relay.RelayMaskOff;
TempRelay |= ReefAngel.Relay.RelayMaskOn;
ReefAngel.LCD.DrawOutletBox(x, y, TempRelay);
y+=12;
TempRelay = ReefAngel.Relay.RelayDataE[0];
TempRelay &= ReefAngel.Relay.RelayMaskOffE[0];
TempRelay |= ReefAngel.Relay.RelayMaskOnE[0];
ReefAngel.LCD.DrawOutletBox(x, y, TempRelay);
y+=12;
TempRelay = ReefAngel.Relay.RelayDataE[1];
TempRelay &= ReefAngel.Relay.RelayMaskOffE[1];
TempRelay |= ReefAngel.Relay.RelayMaskOnE[1];
ReefAngel.LCD.DrawOutletBox(x, y, TempRelay);
}
void DelayedOnFeedMode(byte relay) {
static unsigned long startTime=now();
if ( (startTime==LastStart || ReefAngel.DisplayedMenu==WATERCHANGE_MODE) && ReefAngel.HighATO.IsActive()) {
ReefAngel.Relay.On(relay);
} else {
ReefAngel.Relay.DelayedOn(relay);
}
}
// ------------------------------------------------------------
// 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 InternalMemory.read(Mem_B_CloudsEveryXDays)
// 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 InternalMemory.read(Mem_B_CloudChancePerDay)
// Minimum number of minutes for cloud duration. Don't use min duration of less than 6
#define Min_Cloud_Duration InternalMemory.read(Mem_B_MinCloudDuration)
// Maximum number of minutes for the cloud duration. Don't use max duration of more than 255
#define Max_Cloud_Duration InternalMemory.read(Mem_B_MaxCloudDuration)
// Minimum number of clouds that can happen per day
#define Min_Clouds_per_Day InternalMemory.read(Mem_B_MinCloudsPerDay)
// Maximum number of clouds that can happen per day
#define Max_Clouds_per_Day InternalMemory.read(Mem_B_MaxCloudsPerDay)
// Only start the cloud effect after this setting
// In this example, start cloud after noon
#define Start_Cloud_After NumMins(InternalMemory.read(Mem_B_StartCloudAfterHour),InternalMemory.read(Mem_B_StartCloudAfterMin))
// Always end the cloud effect before this setting
// In this example, end cloud before 9:00pm
#define End_Cloud_Before NumMins(InternalMemory.read(Mem_B_EndCloudBeforeHour),InternalMemory.read(Mem_B_EndCloudBeforeMin))
// 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_Chance_per_Cloud InternalMemory.read(Mem_B_LightningChance)
// 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 result 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.
// Add Random Lightning modes
#define Calm 0 // No lightning
#define Slow 1 // 5 seconds of slow lightning in the middle of a cloud for ELN style (slow response) drivers
#define Fast 2 // 5 seconds of fast lightning in the middle of a cloud for LDD style (fast response) drivers
#define Mega 3 // Lightning throughout the cloud, higher chance as it gets darker
#define Mega2 4 // Like Mega, but with more lightning
// ------------------------------------------------------------
// 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 byte lightningMode=0;
static boolean chooseLightning=true;
void CheckCloud()
{
// Set which modes you want to use
// Example: { Calm, Fast, Mega, Mega2 } to randomize all four modes.
// { Mega2 } for just Mega2. { Mega, Mega, Fast} for Mega and Fast, with twice the chance of Mega.
byte LightningModes[] = {Slow};
// Change the values above to customize your cloud/storm effect
static time_t DelayCounter=millis(); // Variable for lightning timing.
static int DelayTime=random(1000); // Variable for lightning timimg.
// 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
{
// Commenting out to see if it's interfering with our other seed.
// randomSeed(millis()); // Seed the random number generator
//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_Chance_per_Cloud, we will not have lightning today
if (lightningchance>Lightning_Chance_per_Cloud) lightningchance=0;
}
}
// Now that we have all the parameters for the cloud, let's create the effect
if (ReefAngel.Relay.isMaskOn(LED_STORM)) {
InternalMemory.write(Mem_B_EnableStorm,false);
}
if (ReefAngel.Relay.isMaskOff(LED_STORM)) {
InternalMemory.write(Mem_B_EnableStorm,true);
}
if (InternalMemory.read(Mem_B_EnableStorm)) return;
if (cloudchance)
{
if (ReefAngel.Relay.isMaskOff(TRIGGER_STORM)) // Change this to whatever port you want to use as a trigger.
{
cloudstart = NumMins(hour(), minute());
ReefAngel.Relay.Auto(TRIGGER_STORM); // Here, too.
}
//is it time for cloud yet?
if (NumMins(hour(),minute())>=cloudstart && NumMins(hour(),minute())<(cloudstart+cloudduration))
{
// Increase Blue channel first for better effect and to compensate for drop in Whites
ActinicPWMValue1=ReversePWMSlopeHighRes(cloudstart,cloudstart+cloudduration,ActinicPWMValue1,ActinicPWMValue1+DaylightPWMValue0,180);
ActinicPWMValue3=ReversePWMSlopeHighRes(cloudstart,cloudstart+cloudduration,ActinicPWMValue3,ActinicPWMValue3+DaylightPWMValue2,180);
DaylightPWMValue0=ReversePWMSlopeHighRes(cloudstart,cloudstart+cloudduration,DaylightPWMValue0,0,180);
DaylightPWMValue2=ReversePWMSlopeHighRes(cloudstart,cloudstart+cloudduration,DaylightPWMValue2,0,180);
if (chooseLightning)
{
lightningMode=LightningModes[random(100)%sizeof(LightningModes)];
chooseLightning=false;
}
switch (lightningMode)
{
case Calm:
break;
case Mega:
// Lightning chance from beginning of cloud through the end. Chance increases with darkness of cloud.
if (lightningchance && random(ReversePWMSlope(cloudstart,cloudstart+cloudduration,100,0,180))<1 && (millis()-DelayCounter)>DelayTime)
{
// Send the trigger
Strike();
DelayCounter=millis(); // If we just had a round of flashes, then lets put in a longer delay
DelayTime=random(1000); // of up to a second for dramatic effect before we do another round.
}
break;
case Mega2:
// Higher lightning chance from beginning of cloud through the end. Chance increases with darkness of cloud.
if (lightningchance && random(ReversePWMSlope(cloudstart,cloudstart+cloudduration,100,0,180))<2)
{
Strike();
}
break;
case Fast:
// 5 seconds of lightning in the middle of the cloud
if (lightningchance && (NumMins(hour(),minute())==(cloudstart+(cloudduration/2))) && second()<5 && (millis()-DelayCounter)>DelayTime)
{
Strike();
DelayCounter=millis(); // If we just had a round of flashes, then lets put in a longer delay
DelayTime=random(1000); // of up to a second for dramatic effect before we do another round.
}
break;
case Slow:
// Slow lightning for 5 seconds in the middle of the cloud. Suitable for slower ELN style drivers
if (lightningchance && second()%40<8)
{
SlowStrike();
}
break;
default:
break;
}
}
else
{
chooseLightning=true; // Reset the flag to choose a new lightning type
}
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_Chance_per_Cloud, we will not have lightning today
if (lightningchance>Lightning_Chance_per_Cloud) lightningchance=0;
}
}
}
// Cloud ON option - Clouds every minute
if (ReefAngel.Relay.isMaskOn(TRIGGER_STORM) && now()%60<10)
{
SlowStrike();
}
}
void SlowStrike()
{
int r = random(100);
if (r<20) lightningstatus=1;
else lightningstatus=0;
if (lightningstatus)
{
// Let's separate left and right both.
if (r<14) {
DaylightPWMValue0=4095;
DaylightPWMValue2=4095;
ActinicPWMValue1=4095;
ActinicPWMValue3=4095;
} else if (r<17) {
DaylightPWMValue0=100;
DaylightPWMValue2=4095;
ActinicPWMValue3=4095;
} else {
DaylightPWMValue0=4095;
ActinicPWMValue1=4095;
DaylightPWMValue2=100;
}
}
else
{
DaylightPWMValue0=100;
DaylightPWMValue2=100;
}
delay(1);
}
void DrawClouds(int x, int y)
{
// Write the times of the next cloud, next lightning, and cloud duration to the screen and into some customvars for the Portal.
ReefAngel.LCD.DrawText(0,255,x,y,"C"); x+=6;
ReefAngel.LCD.DrawText(0,255,x,y,"00:00"); x+=34;
ReefAngel.LCD.DrawText(0,255,x,y,"L"); x+=6;
ReefAngel.LCD.DrawText(0,255,x,y,"00:00"); x=5;
if (cloudchance && (NumMins(hour(),minute())<cloudstart))
{
int x=0;
if ((cloudstart/60)>=10) x=11;
else x=17;
ReefAngel.LCD.DrawText(0,255,x,y,(cloudstart/60));
ReefAngel.CustomVar[0]=cloudstart/60; // Write the hour of the next cloud to custom variable for Portal reporting
if ((cloudstart%60)>=10) x=29;
else x=35;
ReefAngel.LCD.DrawText(0,255,x,y,(cloudstart%60));
ReefAngel.CustomVar[1]=cloudstart%60; // Write the minute of the next cloud to custom variable for Portal reporting
}
ReefAngel.LCD.DrawText(0,255,x+85,y,cloudduration);
ReefAngel.CustomVar[2]=(cloudduration); // Put the duration of the next cloud in a custom var for the portal
if (lightningchance)
{
int x=0;
if (((cloudstart+(cloudduration/3))/60)>=10) x=51;
else x=57;
ReefAngel.LCD.DrawText(0,255,x,y,((cloudstart+(cloudduration/3))/60));
ReefAngel.CustomVar[6]=(cloudstart+(cloudduration/2))/60; // Write the hour of the next lightning to a custom variable for the Portal
if (((cloudstart+(cloudduration/3))%60)>=10) x=69;
else x=75;
ReefAngel.LCD.DrawText(0,255,x,y,((cloudstart+(cloudduration/3))%60)); // Write the minute of the next lightning to a custom variable for the Portal
ReefAngel.CustomVar[7]=(cloudstart+(cloudduration/2))%60;
}
}
void Strike()
{
int a=random(1,5); // Pick a number of consecutive flashes from 1 to 4.
for (int i=0; i<a; i++)
{
// Flash on
int newdata=4095;
Wire.beginTransmission(0x40); // Address of the dimming expansion module
Wire.write(0x8+(4*0)); // 0x8 is channel 0, 0x12 is channel 1, etc. This is channel 0.
Wire.write(newdata&0xff); // Send the data 8 bits at a time. This sends the LSB
Wire.write(newdata>>8); // This sends the MSB
Wire.endTransmission();
Wire.beginTransmission(0x40); // Address of the dimming expansion module
Wire.write(0x8+(4*2)); // 0x8 is channel 0, 0x12 is channel 1, etc. This is channel 2.
Wire.write(newdata&0xff); // Send the data 8 bits at a time. This sends the LSB
Wire.write(newdata>>8); // This sends the MSB
Wire.endTransmission();
int randy=random(20,80); // Random number for a delay
if (randy>71) randy=((randy-70)/2)*100; // Small chance of a longer delay
delay(randy); // Wait from 20 to 69 ms, or 100-400 ms
// Flash off. Return to baseline.
newdata=ReefAngel.PWM.GetChannelValueRaw(0); // Use the channel number you're flashing here
Wire.beginTransmission(0x40); // Same as above
Wire.write(0x8+(4*0));
Wire.write(newdata&0xff);
Wire.write(newdata>>8);
Wire.endTransmission();
newdata=ReefAngel.PWM.GetChannelValueRaw(2); // Use the channel number you're flashing here
Wire.beginTransmission(0x40); // Same as above
Wire.write(0x8+(4*2));
Wire.write(newdata&0xff);
Wire.write(newdata>>8);
Wire.endTransmission();
delay(random(30,50)); // Wait from 30 to 49 ms
wdt_reset(); // Reset watchdog timer to avoid re-boots
}
}
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 (int) PWMStart;
}
int ReversePWMSlopeHighRes(long cstart,long cend,int PWMStart,int 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 (int) PWMStart;
}
