3 Part Dosing issues

Do you have a question on how to do something.
Ask in here.
Post Reply
aranax
Posts: 120
Joined: Thu Jun 02, 2011 11:54 pm

3 Part Dosing issues

Post by aranax »

Hey guys,
Can you please help with my 3 part dosing? I want to be able to adjust 3 part dose timing via the Portal but it doesn't seem to be working. I've read a few topics and re-wrote my code accordingly but it still doesn't seem to work. I've commented out some of the failsafes to check the base code but it still doesn't consistently turn on.

Basically I'd like:
- to have all 3 pump timing editable via Portal.
- have Calc and Alk/Mag run on alternating time cycles
- make sure all pumps are off (overridden) if PH goes above 8.55

Dosing Portion:

Code: Select all

      //Dosing
/*      if ((hour() >= 8) && (hour() < 20)) { // Between 8am and 8pm we will disable Port 2
      ReefAngel.Relay.Off((Alk_pump));
    } else { // At night we'll disable Port1
      ReefAngel.Relay.Off((Calc_pump));
      ReefAngel.Relay.Off((Mag_pump));
    }
*/
      ReefAngel.DosingPumpRepeat( Box1_Port1,0,InternalMemory.read(843),InternalMemory.read(812) );
      ReefAngel.DosingPumpRepeat( Box1_Port3,5,InternalMemory.read(845),InternalMemory.read(813) );
      ReefAngel.DosingPumpRepeat( Box1_Port5,10,InternalMemory.read(934),InternalMemory.read(933) );
/*      
    if (ReefAngel.Params.PH>855)
    {
      ReefAngel.Relay.Off( (Calc_pump) );
      ReefAngel.Relay.Off( (Alk_pump) );
      ReefAngel.Relay.Off( (Mag_pump) );
    }
*/
Full Code:

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 <RF.h>
    #include <ReefAngel.h>
    #include <SunLocation.h>
    #include <WaterLevel.h>
    #include <Tide.h>
    #include <Moon.h>
    #include <WiFiAlert.h>
    #include <InternalEEPROM.h>
    #include <avr/wdt.h>

    // Custom menus
    #include <avr/pgmspace.h>
    prog_char menu1_label[] PROGMEM = "Refugium Light";
    prog_char menu2_label[] PROGMEM = "Feeding Mode";
    prog_char menu3_label[] PROGMEM = "Water Change";
    prog_char menu4_label[] PROGMEM = "Vortech Mode";
    prog_char menu5_label[] PROGMEM = "ATO Clear";
    prog_char menu6_label[] PROGMEM = "Overheat Clear";
    prog_char menu7_label[] PROGMEM = "PH Calibration";
    prog_char menu8_label[] PROGMEM = "WLS Calibration";
    prog_char menu9_label[] PROGMEM = "Date / Time";

    // 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, menu9_label
    };

    // Define Custom Memory Locations
    #define Mem_B_MoonSlope       100
    #define Mem_I_WCFillTime      106
    #define Mem_I_Latitude        108
    #define Mem_I_Longitude       110
    #define Mem_B_TideMin         117
    #define Mem_B_TideMax         118
    #define Mem_B_PumpOffset      119
    #define Mem_B_FeedingRF       120
    #define Mem_B_NightRF         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_I_CalDP1Vol       128
    #define Mem_I_CalDP1Time      130
    #define Mem_I_DP1Volume       132
    #define Mem_I_CalDP2Vol       134
    #define Mem_I_CalDP2Time      136
    #define Mem_I_DP2Volume       138
    #define Mem_B_TideMode        143
    #define Mem_I_CalDP3Vol       154
    #define Mem_I_CalDP3Time      156
    #define Mem_I_DP3Volume       158

    #define Mem_B_PrintDebug      198
    #define Mem_B_ResetMemory     199

    void init_memory() {
      InternalMemory.write(Mem_B_MoonSlope,60);
      InternalMemory.write_int(Mem_I_WCFillTime,240);
      InternalMemory.write_int(Mem_I_Latitude,31);
      InternalMemory.write_int(Mem_I_Longitude,-118);
      InternalMemory.write(Mem_B_TideMin,10);
      InternalMemory.write(Mem_B_TideMax,30);
      InternalMemory.write(Mem_B_FeedingRF,true);
      InternalMemory.write(Mem_B_NightRF,false);
      InternalMemory.write(Mem_B_NightSpeed,30);
      InternalMemory.write(Mem_B_NightDuration,10);
      InternalMemory.write(Mem_B_NTMSpeed,65);
      InternalMemory.write(Mem_B_NTMDuration,5);
      InternalMemory.write(Mem_B_NTMDelay,15);
      InternalMemory.write(Mem_B_NTMTime,150);
      InternalMemory.write_int(Mem_I_CalDP1Vol,11); 
      InternalMemory.write_int(Mem_I_CalDP1Time,600); 
      InternalMemory.write_int(Mem_I_DP1Volume,30); 
      InternalMemory.write_int(Mem_I_CalDP2Vol,11); 
      InternalMemory.write_int(Mem_I_CalDP2Time,600);   
      InternalMemory.write_int(Mem_I_DP2Volume,30);   
      InternalMemory.write_int(Mem_I_CalDP3Vol,3); 
      InternalMemory.write_int(Mem_I_CalDP3Time,270);   
      InternalMemory.write_int(Mem_I_DP3Volume,0);     
      InternalMemory.write(Mem_B_TideMode,0);

      InternalMemory.write(Mem_B_ResetMemory,false);
    }

    #define NUMBERS_8x16

    // Define Portal Variables
    #define Var_Feedings     0
    #define Var_DPump1       1
    #define Var_DPump2       2
    #define Var_AcclDay      3
    #define Var_Tide         4
    #define Var_TideMode     5
    #define Var_LogATO       6
    #define Var_WCVol        7

    // Define Relay Ports by Name
    #define UV_Filter          1   
    #define ATOSump            2
    #define Chiller            3
    #define Heater             4   
    #define Skimmer            5
    #define SumpCirc           6
    #define ReturnPump         7
    #define WaveRight          8

    #define Calc_pump          Box1_Port1
    #define Vortech1           Box1_Port2
    #define Alk_pump           Box1_Port3
    #define Dosing_pump        Box1_Port4
    #define Mag_pump           Box1_Port5
    #define WaveLeft           Box1_Port6
    #define Feeder             Box1_Port7
    #define ATOres             Box1_Port8

    #define VO_Cleaning        Box2_Port1
    #define VO_EnableATO       Box2_Port2
    #define VO_StartFill       Box2_Port3
    #define VO_Vacation        Box2_Port4
    #define VO_AutoFeed        Box2_Port5
    #define VO_Unused          Box2_Port6
    #define VO_Calibrate       Box2_Port7
    #define VO_LockPorts       Box2_Port8

    ////// Place global variable code below here

    //boolean dosing=true;
    byte vtechmode;
    //boolean bFeeding=false;

    // Custom classes
    SunLocation sun;
    Tide tide;

    // Vortech Variables
    byte vtMode, vtSpeed, vtDuration;

    // 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
      wdt_enable(WDTO_2S);
      //ReefAngel.Timer[1].SetInterval(45);
      //ReefAngel.Timer[2].SetInterval(2880);
      ReefAngel.InitMenu(pgm_read_word(&(menu_items[0])),SIZE(menu_items)); // Initialize Menu
      ReefAngel.AddWaterLevelExpansion();  // Water Level Expansion Module       
      // Ports toggled in Feeding Mode
      ReefAngel.FeedingModePorts = Port7Bit | Port5Bit ;
      ReefAngel.FeedingModePortsE[0] = 0;
      // Ports toggled in Water Change Mode
      ReefAngel.WaterChangePorts = Port4Bit | Port5Bit | Port6Bit | Port7Bit | Port8Bit;
      ReefAngel.WaterChangePortsE[0] = Port2Bit;
      // Ports turned off when Overheat temperature exceeded
      ReefAngel.OverheatShutoffPorts = Port4Bit ;
      ReefAngel.OverheatShutoffPortsE[0] = 0;
      // Use T1 probe as temperature and overheat functions
      //ReefAngel.TempProbe = T1_PROBE;
      //ReefAngel.OverheatProbe = T1_PROBE;
       
      // Ports that default on
      ReefAngel.Relay.On(ReturnPump);
      ReefAngel.Relay.On(ATOSump);
      ReefAngel.Relay.On(Vortech1);
      ReefAngel.Relay.On(SumpCirc);
      ReefAngel.Relay.On(SumpCirc);
      ReefAngel.Relay.On(Chiller);
      ////// Place additional initialization code below here
        randomSeed(now()/SECS_PER_DAY);
       
      if (InternalMemory.read(Mem_B_ResetMemory))
        init_memory();
      ////// Place additional initialization code above here
    }

    void loop()
    {
      ReefAngel.StandardLights( (WaveRight),6,0,11,30 );
      ReefAngel.Relay.DelayedOn( (Skimmer),10 );
      ReefAngel.StandardLights( (Skimmer),1,00,22,30 );
      ReefAngel.StandardLights( (WaveLeft),11,30,17,30 );
      ReefAngel.RF.UseMemory=false;
      
      //Dosing
/*      if ((hour() >= 8) && (hour() < 20)) { // Between 8am and 8pm we will disable Port 2
      ReefAngel.Relay.Off((Alk_pump));
    } else { // At night we'll disable Port1
      ReefAngel.Relay.Off((Calc_pump));
      ReefAngel.Relay.Off((Mag_pump));
    }
*/
      ReefAngel.DosingPumpRepeat( Box1_Port1,0,InternalMemory.read(843),InternalMemory.read(812) );
      ReefAngel.DosingPumpRepeat( Box1_Port3,5,InternalMemory.read(845),InternalMemory.read(813) );
      ReefAngel.DosingPumpRepeat( Box1_Port5,10,InternalMemory.read(934),InternalMemory.read(933) );
/*      
    if (ReefAngel.Params.PH>855)
    {
      ReefAngel.Relay.Off( (Calc_pump) );
      ReefAngel.Relay.Off( (Alk_pump) );
      ReefAngel.Relay.Off( (Mag_pump) );
    }
*/
      ////// Place your custom code below here
      SetMoon();              // Setup Moon rise/set lighting
      SetTide();              // Set High/Low tide properties
      SetRF();                // Set Vortech modes
     

    //Temp Heater Overheat
    if (ReefAngel.Params.Temp[T1_PROBE]>780) ReefAngel.Relay.Off(Heater);
    if (ReefAngel.Params.Temp[T1_PROBE]<760) ReefAngel.Relay.On(Heater);
      
    //Temp2 Heater Overheat
    //if (ReefAngel.Params.Temp[T2_PROBE]>780) ReefAngel.Relay.Off(QTH);
    //if (ReefAngel.Params.Temp[T2_PROBE]<760) ReefAngel.Relay.On(QTH);
    
      //ATO Res    
      ReefAngel.WaterLevelATO( Box1_Port8,1800,10,80 );
      
      //Skimmer failsafe
    if (ReefAngel.Relay.Status((ReturnPump)) != 1)
    {
    ReefAngel.Relay.Off((Skimmer));
    }
      
       // Manual Cleaning mode     
     if (ReefAngel.Relay.Status((VO_Cleaning)) == 1)
      {
        ReefAngel.Relay.On(Port8);
        ReefAngel.Relay.On(Box1_Port6);
        vtMode = 4; //LongPulse ShortPulse=3
      } 

      ////// Place your custom code above here


      // This should always be the last line
      ReefAngel.Portal( "" , "");
      ReefAngel.ShowInterface();
    }
 
  


    void SetMoon() {
    // rfi
      byte offset=InternalMemory.read(Mem_B_MoonSlope);
     
      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);

      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));
     
      ReefAngel.PWM.SetDaylight(PWMSlope(Moon.riseH,Moon.riseM,Moon.setH,Moon.setM, startD,endD,timeD,0));
      ReefAngel.PWM.SetActinic(PWMSlope(Moon.riseH,Moon.riseM,Moon.setH,Moon.setM, startA,endA,timeA,0));
    }

    void SetTide() {
    // rfi
      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,vtSpeed,120,nightSpeed+tideMin));

      // Show tide info on portal
      ReefAngel.CustomVar[Var_Tide]=tide.CalcTide();
    }

    void SetRF() {
      int ntmDelay=InternalMemory.read(Mem_B_NTMDelay)*60;
      int ntmTime=InternalMemory.read(Mem_B_NTMTime)*60;
      boolean nightRF=InternalMemory.read(Mem_B_NightRF);
      boolean feedingRF=InternalMemory.read(Mem_B_FeedingRF);
      static time_t t;

      vtMode=InternalMemory.RFMode_read();
      vtSpeed=InternalMemory.RFSpeed_read();
      vtDuration=InternalMemory.RFDuration_read();

      if ((now()-t > ntmDelay && now()-t < ntmTime+ntmDelay) && feedingRF) {
        // Post feeding mode
        vtMode=Smart_NTM;
        vtSpeed=InternalMemory.read(Mem_B_NTMSpeed);
        vtDuration=InternalMemory.read(Mem_B_NTMDuration);
      } else if (!sun.IsDaytime() && nightRF) {
        vtMode=Night;
        vtSpeed=InternalMemory.read(Mem_B_NightSpeed);
        vtDuration=InternalMemory.read(Mem_B_NightDuration);
      } else {
        if (vtMode!=Night && ReefAngel.RF.Mode==Night)
          ReefAngel.RF.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) {
        ReefAngel.RF.SetMode(Constant,25,0);
      } else {
        if ((vtMode==Smart_NTM) || (vtMode==ShortPulse)) vtDuration=InternalMemory.read(Mem_B_NTMDuration);
        (vtMode==Custom) ? RFCustom() : ReefAngel.RF.SetMode(vtMode,vtSpeed,vtDuration);
      }
    }

    void RFCustom() {
      static boolean changeMode;
      byte rcSpeed, rcSpeedAS;

      // Define new modes
      const int BHazard=15;
      const int Else=16;
      const int Sine=17;
     
      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 };

      if (now()%SECS_PER_DAY!=0) changeMode=true;
      if ((now()%SECS_PER_DAY==0 && changeMode)) {
        tideMode=random(100)%sizeof(RandomModes);
        InternalMemory.write(Mem_B_TideMode,tideMode);
        changeMode=false;
      }
     
      ReefAngel.CustomVar[Var_TideMode]=tideMode+1;

      switch (RandomModes[tideMode]) {
        case ReefCrest: {
          rcSpeed=ReefCrestMode(tideSpeed,vtDuration*2,true);
          rcSpeedAS=ReefCrestMode(tideSpeed,vtDuration*2,false);
          break;
        }
        case Lagoon: {
          rcSpeed=ReefCrestMode(tideSpeed,vtDuration,true);
          rcSpeedAS=ReefCrestMode(tideSpeed,vtDuration,false);
          break;
        }
        case TidalSwell: {
          rcSpeed=TidalSwellMode(tideSpeed,true);
          rcSpeedAS=TidalSwellMode(tideSpeed,false);
          break;
        }
        case Smart_NTM: {
          rcSpeed=NutrientTransportMode(0,tideSpeed,vtDuration*50,true);
          rcSpeedAS=NutrientTransportMode(0,tideSpeed,vtDuration*50,false);
          break;
        }
        case ShortPulse: {
          rcSpeed=ShortPulseMode(0,tideSpeed,vtDuration*50,true);
          rcSpeedAS=ShortPulseMode(0,tideSpeed,vtDuration*50,false);
          break;
        }
        case LongPulse: {
          rcSpeed=LongPulseMode(0,tideSpeed,vtDuration,true);
          rcSpeedAS=LongPulseMode(0,tideSpeed,vtDuration,false);
          break;
        }
        case BHazard: {
          rcSpeed=millis()%1200>800?tideSpeed:0;
          rcSpeedAS=millis()%1200<400?0:tideSpeed;
          break;
        }   
        case Else: {
          rcSpeed=ElseMode(tideSpeed,vtDuration*2,true);
          rcSpeedAS=ElseMode(tideSpeed,vtDuration*2,false);
          break;
        }   
        case Sine: {
          rcSpeed=SineMode(tideSpeed-tideMin,tideSpeed+tideMin,vtDuration*100,true);
          rcSpeedAS=SineMode(tideSpeed-tideMin,tideSpeed+tideMin,vtDuration*100,false);
          break;
        }
        default: {
          rcSpeed=tideSpeed;
          rcSpeedAS=tideSpeed; 
        }
      }

      ReefAngel.RF.SetMode(Custom,rcSpeedAS*pumpOffset,tide.isOutgoing());
      ReefAngel.RF.SetMode(Custom,rcSpeed,tide.isIncoming());
    }

    void NextRFMode() {
      vtMode++;
     
      if (vtMode > 12) {
        vtMode=0;
        vtSpeed=50; // Constant
      } else if (vtMode == 1) {
        vtSpeed=40; // Lagoon
      } else if (vtMode == 2) {
        vtSpeed=45; // Reef Crest
      } else if (vtMode == 3) { 
        vtSpeed=55; vtDuration=10; // Short Pulse
      } else if (vtMode == 4) {
        vtSpeed=55; vtDuration=20; // Long Pulse
      } else if (vtMode == 5) {
        vtSpeed=InternalMemory.read(Mem_B_NTMSpeed);
        vtDuration=InternalMemory.read(Mem_B_NTMDuration); // Smart_NTM
      } else if (vtMode == 6) {
        vtSpeed=50; vtDuration=10; // Smart_TSM
      } else if (vtMode == 7) {
        vtSpeed=InternalMemory.read(Mem_B_NightSpeed);
        vtDuration=InternalMemory.read(Mem_B_NightDuration);
        vtMode=9; // Night
      } else if (vtMode == 10) {
        vtSpeed=65; vtDuration=5; // Storm
      } else if (vtMode == 11) {
        vtSpeed=45; vtDuration=10; // Custom
      } 

      if (vtMode!=InternalMemory.RFMode_read())
        InternalMemory.RFMode_write(vtMode);
      if (vtSpeed!=InternalMemory.RFSpeed_read())
        InternalMemory.RFSpeed_write(vtSpeed);
      if (vtDuration!=InternalMemory.RFDuration_read())
        InternalMemory.RFDuration_write(vtDuration);
    }

    // Menu Code
    void MenuEntry1() {
      // Toggle refugium light between on/auto.
      ReefAngel.DisplayedMenu = RETURN_MAIN_MODE;
    }
    void MenuEntry2() {
      ReefAngel.FeedingModeStart();
    }
    void MenuEntry3() {
      ReefAngel.WaterChangeModeStart();
    }
    void MenuEntry4() {
      NextRFMode(); 
      ReefAngel.DisplayedMenu = RETURN_MAIN_MODE;
    }
    void MenuEntry5() {
      ReefAngel.ATOClear();
      ReefAngel.DisplayMenuEntry("Clear ATO Timeout");
    }
    void MenuEntry6() {
      ReefAngel.OverheatClear();
      ReefAngel.DisplayMenuEntry("Clear Overheat");
    }
    void MenuEntry7() {
      ReefAngel.SetupCalibratePH();
      ReefAngel.DisplayedMenu = ALT_SCREEN_MODE;
    }
    void MenuEntry8() {
      ReefAngel.SetupCalibrateWaterLevel();
      ReefAngel.DisplayedMenu = ALT_SCREEN_MODE;
    }
    void MenuEntry9() {
      ReefAngel.SetupDateTime();
      ReefAngel.DisplayedMenu = ALT_SCREEN_MODE;
    }

    // Custom Main Screen
    void DrawCustomMain() {
      const int NumScreens=3;
      static boolean drawGraph=true;
     
      // Main Header
      // ReefAngel.LCD.DrawText(DefaultFGColor, DefaultBGColor, 35, 2,"Lee'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; }
      }
     
      // 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); //Big Number
      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;
     
      // Display Water level
      ReefAngel.LCD.DrawText(DefaultFGColor,DefaultBGColor,x,y,"AT0 Level:"); x+=65;
      ReefAngel.LCD.DrawSingleMonitor(ReefAngel.WaterLevel.GetLevel(),DPColor,x,y,1);
      x+=5*(intlength(ReefAngel.WaterLevel.GetLevel())+1);
      ReefAngel.LCD.DrawText(DPColor, DefaultBGColor, x, y, "%");
      y+=12; x=t;
     
      // Vortech Mode
      ReefAngel.LCD.DrawText(0,255,x,y,"RF:"); x+=20;
      ReefAngel.LCD.Clear(DefaultBGColor,x,y,t+(128-t),y+8);
      if (vtMode == 0) ReefAngel.LCD.DrawLargeText(COLOR_GREEN,255,x,y,"Constant");
      else if (vtMode == 1) ReefAngel.LCD.DrawLargeText(COLOR_GOLD,255,x,y,"Lagoon");
      else if (vtMode == 2) ReefAngel.LCD.DrawLargeText(COLOR_GOLD,255,x,y,"Reef Crest");
      else if (vtMode == 3) ReefAngel.LCD.DrawLargeText(COLOR_RED,255,x,y,"Short Pulse");
      else if (vtMode == 4) ReefAngel.LCD.DrawLargeText(COLOR_RED,255,x,y,"Long Pulse");
      else if (vtMode == 5) ReefAngel.LCD.DrawLargeText(COLOR_MAGENTA,255,x,y,"Smart NTM");
      else if (vtMode == 6) ReefAngel.LCD.DrawLargeText(COLOR_MAGENTA,255,x,y,"Tidal Swell");
      else if (vtMode == 9) ReefAngel.LCD.DrawLargeText(COLOR_WHITE,0,x,y,"Night");
      else if (vtMode == 10) ReefAngel.LCD.DrawLargeText(COLOR_BLUE,0,x,y,"Storm");
      else if (vtMode == 11) ReefAngel.LCD.DrawLargeText(COLOR_BLUE,255,x,y,"Custom");
      y+=10; x=t;
     
      ReefAngel.LCD.DrawText(0,255,x,y,"RF Speed:"); x+=60;
      ReefAngel.LCD.Clear(DefaultBGColor,x,y,128,y+8);
      ReefAngel.LCD.DrawText(COLOR_BLUE, DefaultBGColor,x,y,vtSpeed); x+=15;
      ReefAngel.LCD.DrawText(COLOR_BLUE, DefaultBGColor,x,y,"/"); x+=10;
      ReefAngel.LCD.DrawText(COLOR_BLUE, DefaultBGColor,x,y,vtDuration);
      y+=10; x=t;
     
      // Display Acclimation timer
      if (ReefAngel.CustomVar[Var_AcclDay] > 0) {
        ReefAngel.LCD.DrawText(DefaultFGColor,DefaultBGColor,x,y,"Acclimation Day:"); x+=100;
        ReefAngel.LCD.DrawSingleMonitor(ReefAngel.CustomVar[Var_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); 
    }

    byte ElseMode( byte MidPoint, byte Offset, boolean WaveSync )
    {
      // Static's only initialize the first time they are called
      static unsigned long LastChange=millis();        // Set the inital time that the last change occurred
      static int Delay = random( 500, 3000);           // Set the initial delay
      static int NewSpeed = MidPoint;                  // Set the initial speed
      static int AntiSpeed = MidPoint;                 // Set the initial anti sync speed
      if ((millis()-LastChange) > Delay)               // Check if the delay has elapsed
      {
        Delay=random(500,5000);                        // If so, come up with a new delay
        int ChangeUp = random(Offset);                 // Amount to go up or down
        if (random(100)<50)                            // 50/50 chance of speed going up or going down
        {
          NewSpeed = MidPoint - ChangeUp;
          AntiSpeed = MidPoint + ChangeUp;
        }
        else
        {
          NewSpeed = MidPoint + ChangeUp;
          AntiSpeed = MidPoint - ChangeUp;
        }
        LastChange=millis();                           // Reset the time of the last change
      }
      if (WaveSync)
      {
        return NewSpeed;
      }
      else
      {
        return AntiSpeed;
      }
    }

/*    void DelayedOnModes(byte relay) {
      static unsigned long startTime=now();

      if (startTime==LastStart && ReefAngel.HighATO.IsActive()) {
        ReefAngel.Relay.On(relay);
      } else {
        ReefAngel.Relay.DelayedOn(relay);
      }
    }
*/
Thanks.

-J
Image
aranax
Posts: 120
Joined: Thu Jun 02, 2011 11:54 pm

Re: 3 Part Dosing issues

Post by aranax »

The Android app (that I'm using) may be displaying the old memory locations for dosing (800-ish) when i view them through the memory read/write feature. I read another post regarding mem location mapping and it seemed to indicate old locations were in the 800s and new ones are in the 200s. I'm going to check my globals.h file when I get home unless someone can look at their globals.h file to let me know what locations I should be using for dosing (DPtime, DPinterval) :)

-J
Image
binder
Posts: 2871
Joined: Fri Mar 18, 2011 6:20 pm
Location: Illinois
Contact:

Re: 3 Part Dosing issues

Post by binder »

you can select what memory locations you want to use in the Android App. there is a setting (checkbox) that lets you choose what memory locations you want to use.
Post Reply