API tools faq
paste
manhoosbilli1

Complete incubator code

manhoosbilli1
Sep 19th, 2018
94
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Arduino 57.77 KB | None | 0 0
raw download clone embed print report
  1. //remember to use factory reset first
  2. //this will clear the eeprom memory or
  3. //you may get all sorts of odd data being
  4. //displayed
  5.  
  6. //turning the light on and off by the switch will
  7. //always return you to home screen
  8.  
  9. //if you are in menu for more than 2 minutes it will
  10. //kick you out and not save settings
  11.  
  12. //heater is disabled while in menu
  13.  
  14.  
  15. //wiring lcd with ic2
  16. // + to bread board+
  17. // - to bread board -
  18. // sda to sda (pin 20 mega)
  19. // scl to scl (pin 21 mega)
  20. //or
  21. //A4 (SDA)(uno pins)
  22. //A5 (SCL)(uno pins)
  23.  
  24. //rtc
  25. //same as the lcd both use ic2
  26.  
  27. //dht22
  28. // + to bread board+
  29. // - to bread board -
  30. // data to pin 2
  31. //use a 10k ohm pull-up resistor (resistor between pin 2 and +)
  32.  
  33. //keypad
  34. //common to -
  35. // buttonEdit = 5;
  36. // buttonPlus = 4;
  37. // buttonMinus = 7;
  38. // buttonEnter = 6;//make into lights
  39.  
  40. //turner inputs
  41. //pin 9 estop (used on reverse tilt table)
  42. //pin 8 turner input (used on tilt table)
  43.  
  44. //lights relay
  45. //pin 12 (option to turn lights on using spare button)
  46.  
  47. //humidity relay
  48. //pin A4 (option if you have a auto humidity fan/pump)
  49.  
  50. //alarm relay
  51. //pin A3 (optional relay for alarms)
  52. //tone pin 11 (option tone speaker)
  53. //pin 11 is a tone pin for 8ohm speaker used as a alarm
  54. // pin11 to + other pin to -
  55.  
  56. //heater relay
  57. //pin A0
  58.  
  59. //turner relay pins(2 off when using reversing turner)
  60.  
  61. //turnerrelay1 pin A1 normal use
  62. //turnerrelay2 pin A2 only used on rev tilt table
  63.  
  64.  
  65. //pin 3 can not be used due to pin 11 set up
  66. //pin 1 and 2 are not used in case serial is required
  67.  
  68.  
  69. #include <EEPROM.h>
  70. #include "DHT.h"
  71. #include <DS1307.h>
  72. #include <Wire.h>
  73. #include <LiquidCrystal_I2C.h>
  74. LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);  //
  75. #define DHT1 2
  76. #define DHTTYPE DHT22   // DHT 22  (AM2302)
  77. #define humidityRelay A4 //relays
  78. #define alarmrelay A3 //relays
  79. #define turnerrelay1 A1 //relays
  80. #define turnerrelay2 A2 //relays
  81. #define overrun 9
  82. #define turnerinput 8 //relays
  83. #define heaterRelay A0 //heater relay
  84. #define lightrelay 12
  85.  
  86. DHT sensor1(DHT1, DHTTYPE);
  87. const byte buttonEdit = 5;
  88. const byte buttonPlus = 4;
  89. const byte buttonMinus = 7;
  90. const byte buttonEnter = 6;//make into lights
  91.  
  92.  
  93. char* menu1[8] = {"set temp/humidity", "set time/date", "set turner",
  94.                   "set hatch date", "alarm points", "hardware setup", "factory reset", "return"
  95.                  };
  96. char* menu10[9] = {"current set points", "current cal offset", "set point temp", "set point humidity", "calibrate temp",
  97.                    "calibrate hum", "set temp swing", "set humidity swing", "return"
  98.                   };
  99. char* menu20[6] = {"set minute", "set hour", "set day",
  100.                    "set month", "set year", "return"
  101.                   };
  102. char* menu30[3] = { "disable/enable", "return", " "
  103.                   };
  104.  
  105. char* menu40[4] = {"set days to hatch", "start countdown", "alarm on/off",
  106.                    "return"
  107.                   };
  108. char* menu50[5] = {"turner hardware", "temp in F or C",
  109.                    "audio alarm", "hot spot probe", "return"
  110.                   };
  111. char* menu60[3] = {"reset now ", "return", " "};
  112. char* menu80[8] = {"temp alarm", "humidity alarm", "display set points", "high temp sp",
  113.                    "low temp sp", "high hum sp", "low hum alarm", "return"
  114.                   };
  115.  
  116. char* menu100[5] = {"disable/enable", "time turner runs", "time between turns",
  117.                     "test turner", "return"
  118.                    };
  119. char* menu110[5] = {"disable/enable", "time between turns",
  120.                     "cam time", "test turner", "return"
  121.                    };
  122. char* menu120[6] = {"disable/enable", "time between turns", "turner manual",
  123.                     "tuner alarm", "test turner", "return"
  124.                    };
  125.  
  126. char* standardText[4] = {"use up and down", "press enter to apply", "set_point : ", "press enter to exit"};
  127. int subsublevel = 0;
  128. int menuNumber2 = 0;
  129. float temp;
  130. float humidity;
  131. float humidity_setpoint = 0;
  132. float temp_setpoint = 0;
  133. int alarm_active = 0;
  134. float tempC = 0;
  135. float tempF = 0;
  136. float highTempSetPoint = 0;
  137. float lowTempAlarmPoint = 0;
  138. float highHumidAlarmPoint = 0;
  139. float lowHumidAlarmPoint = 0;
  140. unsigned long secondTurnercounter = 0; // turner second timer rewite to 60 then reset
  141. unsigned long previousMillis5 = 0;
  142. unsigned long timeBetweenTurnsSeconds = 0;
  143. long previousMillis = 0;//one second counter
  144. long interval = 1000; //one second
  145. float tempSwing = 0;
  146. float humiditySwing = 0;
  147. float cal_temp = 0;
  148. float cal_humidity = 0;
  149. float adj_temp;
  150. float adj_humidity;
  151. long turn_timer; // used on display
  152. int display_stat_turn = 1;
  153. int t1_hatch_days = 15;
  154. int time_to_turn_mins;
  155. int time_to_turn_hr;
  156. int set_minute = 1; //used to set rtc
  157. int set_hour = 1; //used to set rtc
  158. int set_day = 1; //used to set rtc
  159. int set_month = 1; //used to set rtc
  160. long set_year = 2017; //used to set rtc
  161. int tunerDisable = 0;
  162. int clock_update = 0; //used to set rtc
  163. byte reboot = 1;
  164. int prev_clock_day = 0;
  165. int hour_counter = 0;
  166. int memory_update;
  167. unsigned int temp_timer = 0; // stop sensor for one second on boot and slow reads
  168. byte lightButton = 0;
  169. byte editButton = 0;
  170. byte plusButton = 0;
  171. byte noSave = 0;
  172. byte  minusButton = 0;
  173. int  menuNumberLv1 = 0;
  174. int menuNumber3 = 0;
  175. int editMode = 0;
  176. byte preveditButton = 0;
  177. int menuNumber = 1;
  178. int subMenu = 0;
  179. byte prevplusButton = 0;
  180. byte prevMinusButton = 0;
  181. unsigned long prevMillis = 0;
  182. byte prevlightButton = 0;
  183. int prevmn = 0;
  184. int screenmax = 7;
  185. int menuLevel = 0;
  186. int prevmn2 = 0;
  187. int escape = 0;
  188. int hatchDays = 0;
  189. int hatchCountUp = 0;
  190. int hatchAlarm = 0;
  191. int turnerType = 1;
  192. int TimeBetweenTurns = 1;
  193. int TimeTurnerTurns = 1;
  194. int turnerAlarm = 0;
  195. unsigned long  turnerRunCounter = 0;
  196. int testTurner = 0;
  197. int countdown = 0;
  198. byte tilt = 0;
  199. byte onetime = 0;
  200. byte turnerstop = 0;
  201. byte turnerEstop = 0;
  202. byte prevturnerstop = 0;
  203. byte audioalarm = 0;
  204. byte tempalarm = 1;
  205. byte humalarm = 1;
  206. byte facReset = 0;
  207. byte soundalarm = 0;
  208. byte badsensor = 1; //bad reading go safe
  209. byte setlightrelay = 1;
  210. byte heaterdisplay = 0;
  211. byte humidityfandisplay = 0;
  212. byte tempinF = 0;
  213. byte prevtempinF = 0;
  214. byte temp_char[8] = {B01110, B01010, B01010, B01110, B01110, B11111, B11111, B01110};
  215. byte hum_char[8] = {B00100, B01110, B11111, B00100, B10001, B00100, B10001, B00100};
  216. byte bell_Char[8] = {B00100, B01110, B01110, B01110, B11111, B11111, B00100, B00000};
  217. byte arrow_Char[8] = {B00000, B00000, B10000, B10000, B10111, B10011, B10101, B01000};
  218. byte pointer[8] = {B10000, B01000, B00100, B00010, B00010, B00100, B01000, B10000};
  219.  
  220. byte showC[8] = {B11000, B11000, B00000, B00111, B00100, B00100, B00100, B00111};
  221. byte showF[8] = {B11000, B11000, B00000, B00111, B00100, B00111, B00100, B00100};
  222.  
  223. DS1307 clock;
  224.  
  225.  
  226.  
  227. void setup() {
  228.   // put your setup code here, to run once:
  229.   // Serial.begin(9600);
  230.   lcd.begin(20, 4);
  231.   lcd.createChar(1, temp_char);
  232.   lcd.createChar(2, hum_char);
  233.   lcd.createChar(3, bell_Char);
  234.   lcd.createChar(4, arrow_Char);
  235.   lcd.createChar(5, pointer);
  236.   lcd.createChar(6, showF);
  237.   lcd.createChar(7, showC);
  238.  
  239.   pinMode (buttonEdit, INPUT_PULLUP);
  240.   pinMode (buttonPlus, INPUT_PULLUP);
  241.   pinMode (buttonMinus, INPUT_PULLUP);
  242.   pinMode (buttonEnter, INPUT_PULLUP);
  243.   pinMode (turnerinput, INPUT_PULLUP);
  244.   pinMode (overrun, INPUT_PULLUP);
  245.   pinMode (humidityRelay, OUTPUT), HIGH;
  246.   pinMode (alarmrelay, OUTPUT), HIGH;
  247.   pinMode (turnerrelay1, OUTPUT), HIGH;
  248.   pinMode (turnerrelay2, OUTPUT), HIGH;
  249.   pinMode (heaterRelay, OUTPUT), HIGH;
  250.   pinMode (lightrelay, OUTPUT), HIGH;
  251.   clock.begin();
  252.   sensor1.begin();
  253.   lcd.clear();
  254.  
  255.  
  256.   EEPROM.get (0, temp_setpoint); //float
  257.   turnerAlarm = EEPROM.read (4); //int
  258.   EEPROM.get (8,  highTempSetPoint ); //float
  259.   EEPROM.get (12,  lowTempAlarmPoint ); //float
  260.   EEPROM.get (16,  highHumidAlarmPoint ); //float
  261.   EEPROM.get (20,  lowHumidAlarmPoint ); //float
  262.   audioalarm = EEPROM.read (24); //int
  263.   tempalarm = EEPROM.read (28); //int
  264.   humalarm = EEPROM.read (32); //int
  265.   hatchAlarm = EEPROM.read (36); //int
  266.   tempinF = EEPROM.read (40); //int
  267.   EEPROM.get (48, cal_temp ); //float
  268.   EEPROM.get (52, cal_humidity); //float
  269.   EEPROM.get (56, tempSwing); //float
  270.   EEPROM.get (60, humiditySwing); //float
  271.   hatchDays = EEPROM.read (64); //int
  272.   hatchCountUp = EEPROM.read (68); //int
  273.   turnerType = EEPROM.read (72); //int
  274.   tunerDisable = EEPROM.read (76); //int
  275.   TimeBetweenTurns = EEPROM.read (80); //int
  276.   TimeTurnerTurns = EEPROM.read (84); //int
  277.   EEPROM.get (88, humidity_setpoint);//float
  278.  
  279. }
  280.  
  281.  
  282.  
  283. //...................................................................................loop
  284. void loop() {
  285.   clockset();
  286.   memoryUpdater();
  287.   getTemp();
  288.   humidityFan();
  289.   screenCall();
  290.   checkeditbutton();
  291.   turnerCountForDisplay();
  292.   alarmcheck();
  293.   turnercontrols();
  294.   //showprint();//used in testing
  295.   heatercontrols();
  296.   timers();
  297. }
  298. //......................................................................................loopend
  299.  
  300.  
  301. // testMenu(menuNumber, screenmax, menuLevel);
  302. void testMenu(int x, int y, int z ) {
  303.   int a;
  304.   lcd.setCursor(6, 0);
  305.   // lcd.print(x);//used for testing
  306.   //lcd.setCursor(4, 0);//used for testing
  307.   // lcd.print(y);//used for testing
  308.   // lcd.setCursor(8, 0);//used for testing
  309.   // lcd.print(z);//used for testing
  310.   lcd.print (F("menu"));
  311.   int b;
  312.   if (x == 1) {
  313.     lcd.setCursor(0, 1);
  314.     a = x - 1;
  315.   }
  316.   else if ((x == y) && (y != 2)) {
  317.     lcd.setCursor(0, 3);
  318.     a = x - 3;
  319.   }
  320.   else {
  321.     lcd.setCursor(0, 2);
  322.     a = x - 2;
  323.   }
  324.   lcd.write(5);
  325.   for (int i = 1; i <= 3; i++) {
  326.     lcd.setCursor(2, i);
  327.  
  328.     switch (z) {
  329.       case 1:
  330.         lcd.print( menu1[a]);
  331.         break;
  332.       case 10:
  333.         lcd.print( menu10[a]);
  334.         break;
  335.       case 20:
  336.         lcd.print( menu20[a]);
  337.         break;
  338.       case 30:
  339.         lcd.print( menu30[a]);
  340.         break;
  341.       case 40:
  342.         lcd.print( menu40[a]);
  343.         break;
  344.       case 50:
  345.         lcd.print( menu50[a]);
  346.         break;
  347.       case 60:
  348.         lcd.print( menu60[a]);
  349.         break;
  350.       case 80:
  351.         lcd.print( menu80[a]);
  352.         break;
  353.       case 100:
  354.         lcd.print( menu100[a]);
  355.         break;
  356.       case 110:
  357.         lcd.print( menu110[a]);
  358.         break;
  359.       case 120:
  360.         lcd.print( menu120[a]);
  361.         break;
  362.       default:
  363.         lcd.print("error ");
  364.         lcd.print(z);
  365.         break;
  366.     }
  367.     a = a + 1;
  368.     delay(10);
  369.   }
  370. }
  371. void screenCall() {
  372.   if (prevmn != menuNumber) {
  373.     lcd.clear();
  374.   }
  375.   prevmn = menuNumber;
  376.   if (prevmn2 != menuNumber2) {
  377.     lcd.clear();
  378.   }
  379.   prevmn2 = menuNumber2;
  380.   switch (editMode) {
  381.     case 0:
  382.       callHomeScreen();
  383.       break;
  384.     case 1:
  385.       buttons(1);
  386.       menuNumber = constrain(menuNumber, 1, 8);
  387.       screenmax = 8;
  388.       menuLevel = 1;
  389.       testMenu(menuNumber, screenmax, menuLevel);
  390.       subMenu = menuNumber;
  391.       menuNumber2 = 0;
  392.       break;
  393.     case 2:
  394.       buttons(2);
  395.       menuNumber = 1;
  396.       menuNumber2 = constrain(menuNumber2, 1, screenmax);
  397.       switch (subMenu) {
  398.         case 1:
  399.           screenmax = 9;
  400.           menuLevel = 10;
  401.           testMenu(menuNumber2, screenmax, menuLevel);
  402.           break;
  403.         case 2:
  404.           screenmax = 6;
  405.           menuLevel = 20;
  406.           testMenu(menuNumber2, screenmax, menuLevel);
  407.           break;
  408.         case 3:
  409.           switch (turnerType) {
  410.             case 1:
  411.               screenmax = 2;
  412.               menuLevel = 30;
  413.               testMenu(menuNumber2, screenmax, menuLevel);
  414.               break;
  415.             case 2:
  416.               screenmax = 5;
  417.               menuLevel = 100;
  418.               testMenu(menuNumber2, screenmax, menuLevel);
  419.               break;
  420.             case 3:
  421.               screenmax = 5;
  422.               menuLevel = 110;
  423.               testMenu(menuNumber2, screenmax, menuLevel);
  424.               break;
  425.             case 4:
  426.               screenmax = 6;
  427.               menuLevel = 120;
  428.               testMenu(menuNumber2, screenmax, menuLevel);
  429.               break;
  430.           }
  431.           break;
  432.         case 4:
  433.           screenmax = 4;
  434.           menuLevel = 40;
  435.           testMenu(menuNumber2, screenmax, menuLevel);
  436.           break;
  437.         case 5:
  438.           screenmax = 8;
  439.           menuLevel = 80;
  440.           testMenu(menuNumber2, screenmax, menuLevel);
  441.           break;
  442.         case 6:
  443.           screenmax = 5;
  444.           menuLevel = 50;
  445.           testMenu(menuNumber2, screenmax, menuLevel);
  446.           break;
  447.         case 7:
  448.           screenmax = 2;
  449.           menuLevel = 60;
  450.           testMenu(menuNumber2, screenmax, menuLevel);
  451.           break;
  452.         case 8:
  453.           editMode = editMode - 2;
  454.           break;
  455.       }
  456.       subsublevel = menuLevel + menuNumber2;
  457.       break;
  458.     case 3:
  459.       buttons(3);
  460.       menuNumber3 = constrain(menuNumber3, 1, screenmax);
  461.       delay(20);
  462.       escape = 0;
  463.       switch (subsublevel) {
  464.  
  465.         case 11:
  466.           //  display set points temp/humidity
  467.  
  468.           while (escape == 0) {
  469.             checkeditbutton();
  470.             lcd.setCursor(4, 0);
  471.             lcd.print(F("set points"));
  472.             lcd.setCursor(0, 1);
  473.             lcd.print(standardText[2]);
  474.             lcd.write(1);
  475.             addSpace(1);
  476.             lcd.print (temp_setpoint, 1);
  477.             addSign();
  478.             lcd.setCursor(0, 2);
  479.             lcd.print(standardText[2]);
  480.             lcd.write(2);
  481.             addSpace(1);
  482.             lcd.print (humidity_setpoint, 0);
  483.             lcd.setCursor(0, 3);
  484.             lcd.print(standardText[3]);
  485.           }
  486.           editMode = editMode - 1;
  487.           break;
  488.         case 12:
  489.           //display off sets
  490.           while (escape == 0) {
  491.             checkeditbutton();
  492.             lcd.setCursor(1, 0);
  493.             lcd.print(F("senor"));
  494.             lcd.setCursor(11, 0);
  495.             lcd.print(F("adjusted"));
  496.             lcd.setCursor(0, 1);
  497.             lcd.print("s");
  498.             addSpace(1);
  499.             lcd.write(1);
  500.             lcd.print (temp, 1);
  501.             addSign();
  502.             lcd.setCursor(10, 1);
  503.             lcd.print(F("="));
  504.             addSpace(1);
  505.             lcd.write(1);
  506.             lcd.print (adj_temp, 1);
  507.             addSign();
  508.             lcd.setCursor(0, 2);
  509.             lcd.print("s");
  510.             addSpace(1);
  511.             lcd.write(2);
  512.             lcd.print (humidity, 1);
  513.             lcd.setCursor(10, 2);
  514.             lcd.print(F("="));
  515.             addSpace(1);
  516.             lcd.write(2);
  517.             lcd.print (adj_humidity, 1);
  518.             lcd.setCursor(0, 3);
  519.             lcd.print(standardText[3]);
  520.           }
  521.           editMode = editMode - 1;
  522.           break;
  523.         case 13:
  524.           //set temp here
  525.           while (escape == 0) {
  526.             checkeditbutton();
  527.             buttons(10);
  528.             lcd.setCursor(4, 0);
  529.             lcd.print (F("change temp"));
  530.             lcd.setCursor(0, 1);
  531.             lcd.print(standardText[2]);
  532.             lcd.print (temp_setpoint, 1);
  533.             addSign();
  534.             lcd.setCursor(0, 3);
  535.             lcd.print(standardText[1]);
  536.             memory_update = 1;
  537.           }
  538.           editMode = editMode - 1;
  539.           break;
  540.         case 14:
  541.           //set humidity here
  542.  
  543.           while (escape == 0) {
  544.             checkeditbutton();
  545.             buttons(11);
  546.             lcd.setCursor(0, 0);
  547.             lcd.print (F("change humidity"));
  548.             lcd.setCursor(0, 1);
  549.             lcd.print(standardText[2]);
  550.             lcd.print (humidity_setpoint, 0);
  551.  
  552.             lcd.setCursor(0, 3);
  553.             lcd.print(standardText[1]);
  554.             memory_update = 1;
  555.           }
  556.           editMode = editMode - 1;
  557.           break;
  558.         case 15:
  559.           //cal temp here
  560.           while (escape == 0) {
  561.             checkeditbutton();
  562.             buttons(12);
  563.             getTemp();
  564.             lcd.setCursor(0, 0);
  565.             lcd.print (F("current temp"));
  566.             addSpace(1);
  567.             lcd.print (temp, 1);
  568.             addSign();
  569.             lcd.setCursor(0, 1);
  570.             lcd.print (F("cal offset:"));
  571.             addSpace(1);
  572.             lcd.print (cal_temp, 1);
  573.             addSign();
  574.             lcd.setCursor(0, 2);
  575.             lcd.print (F("adjust temp"));
  576.             addSpace(1);
  577.             adj_temp = temp - cal_temp;
  578.             lcd.print (adj_temp, 1);
  579.             addSign();
  580.             lcd.setCursor(0, 3);
  581.             lcd.print(standardText[1]);
  582.             memory_update = 1;
  583.           }
  584.           editMode = editMode - 1;
  585.           break;
  586.         case 16:
  587.           //cal humidity here
  588.           while (escape == 0) {
  589.             checkeditbutton();
  590.             buttons(13);
  591.             getTemp();
  592.             lcd.setCursor(0, 0);
  593.             lcd.print (F("current "));
  594.             lcd.write(2);
  595.             addSpace(1);
  596.             lcd.print (humidity, 1);
  597.             lcd.setCursor(0, 1);
  598.             lcd.print (F("cal offset:"));
  599.             addSpace(1);
  600.             lcd.print (cal_humidity, 1);
  601.             lcd.setCursor(0, 2);
  602.             lcd.print (F("adjust"));
  603.             addSpace(1);
  604.             lcd.write(2);
  605.             addSpace(1);
  606.             adj_humidity = humidity - cal_humidity;
  607.             lcd.print (adj_humidity, 1);
  608.             lcd.setCursor(0, 3);
  609.             lcd.print(standardText[1]);
  610.             memory_update = 1;
  611.           }
  612.           editMode = editMode - 1;
  613.           break;
  614.         case 17:
  615.           //set temp swing here
  616.           while (escape == 0) {
  617.             checkeditbutton();
  618.             buttons(14);
  619.             getTemp();
  620.             lcd.setCursor(0, 0);
  621.             lcd.print (F("temp drop before"));
  622.             lcd.setCursor(0, 1);
  623.             lcd.print (F("heater starts "));
  624.             lcd.setCursor(0, 2);
  625.             lcd.print (F("adjust"));
  626.             addSpace(1);
  627.             lcd.write(1);
  628.             addSpace(1);
  629.             lcd.print (tempSwing);
  630.             addSign();
  631.             lcd.setCursor(0, 3);
  632.             lcd.print(standardText[1]);
  633.             memory_update = 1;
  634.           }
  635.           editMode = editMode - 1;
  636.           break;
  637.         case 18:
  638.           //set cal swing here
  639.           while (escape == 0) {
  640.             checkeditbutton();
  641.             buttons(15);
  642.             getTemp();
  643.             lcd.setCursor(0, 0);
  644.             lcd.print (F("hum drop before"));
  645.             lcd.setCursor(0, 1);
  646.             lcd.print (F("relay starts"));
  647.             addSpace(1);
  648.             lcd.setCursor(0, 2);
  649.             lcd.print (F("adjust"));
  650.             addSpace(1);
  651.             lcd.write(2);
  652.             addSpace(1);
  653.             lcd.print (humiditySwing);
  654.             lcd.setCursor(0, 3);
  655.             lcd.print(standardText[1]);
  656.             memory_update = 1;
  657.           }
  658.           editMode = editMode - 1;
  659.           break;
  660.         case 19:
  661.           editMode = editMode - 2;
  662.           break;
  663.         case 21:
  664.  
  665.           while (escape == 0) {
  666.             checkeditbutton();
  667.             buttons(5);
  668.             set_minute = constrain(set_minute, 1, 59);
  669.             lcd.setCursor(0, 0);
  670.             showclock();
  671.             lcd.setCursor(0, 1);
  672.             lcd.print(standardText[0]);
  673.             lcd.setCursor(0, 2);
  674.             lcd.print (F("enter minute:"));
  675.             addSpace(1);
  676.             if (set_minute < 10) {
  677.               addSpace(1);
  678.             }
  679.             lcd.print(set_minute);
  680.             lcd.setCursor(0, 3);
  681.             lcd.print(standardText[1]);
  682.           }
  683.           editMode = 0;
  684.           clock_update = 1;
  685.           break;
  686.         case 22:
  687.           //set hour here
  688.  
  689.           while (escape == 0) {
  690.             checkeditbutton();
  691.             buttons(6);
  692.             set_hour = constrain(set_hour, 1, 24);
  693.             lcd.setCursor(0, 0);
  694.             lcd.print (F("set hour"));
  695.             lcd.setCursor(0, 1);
  696.             lcd.print(standardText[0]);
  697.             lcd.setCursor(0, 2);
  698.             lcd.print (F("enter hour:"));
  699.             addSpace(1);
  700.             if (set_hour < 10) {
  701.               addSpace(1);
  702.             }
  703.             lcd.print(set_hour);
  704.             lcd.setCursor(0, 3);
  705.             lcd.print(standardText[1]);
  706.           }
  707.           editMode = 0;
  708.           clock_update = 1;
  709.           break;
  710.         case 23:
  711.  
  712.           while (escape == 0) {
  713.             checkeditbutton();
  714.             buttons(7);
  715.             set_day = constrain(set_day, 1, 31);
  716.             lcd.setCursor(0, 0);
  717.             lcd.print (F("set day"));
  718.             lcd.setCursor(0, 1);
  719.             lcd.print(standardText[0]);
  720.             lcd.setCursor(0, 2);
  721.             lcd.print (F("enter day"));
  722.             addSpace(1);
  723.             if (set_day < 10) {
  724.               addSpace(1);
  725.             }
  726.             lcd.print(set_day);
  727.             lcd.setCursor(0, 3);
  728.             lcd.print(standardText[1]);
  729.           }
  730.           editMode = 0;
  731.           clock_update = 1;
  732.           break;
  733.         case 24:
  734.  
  735.           while (escape == 0) {
  736.             checkeditbutton();
  737.             buttons(8);
  738.             set_month = constrain(set_day, 1, 12);
  739.             lcd.setCursor(0, 0);
  740.             lcd.print (F("set month"));
  741.             lcd.setCursor(0, 1);
  742.             lcd.print(standardText[0]);
  743.             lcd.setCursor(0, 2);
  744.             lcd.print (F("enter month"));
  745.             addSpace(1);
  746.             lcd.print (set_month);
  747.             lcd.setCursor(0, 3);
  748.             lcd.print(standardText[1]);
  749.           }
  750.           editMode = 0;
  751.           clock_update = 1;
  752.           break;
  753.         case 25:
  754.  
  755.           while (escape == 0) {
  756.             checkeditbutton();
  757.             buttons(9);
  758.             set_year = constrain(set_day, 2017, 2030);
  759.             //set year here
  760.             lcd.setCursor(0, 0);
  761.             lcd.print (F("set year"));
  762.             lcd.setCursor(0, 1);
  763.             lcd.print(standardText[0]);
  764.             lcd.setCursor(0, 2);
  765.             lcd.print (F("enter year"));
  766.             addSpace(1);
  767.             lcd.print(set_year);
  768.             lcd.setCursor(0, 3);
  769.             lcd.print(standardText[1]);
  770.           }
  771.           editMode = 0;
  772.           clock_update = 1;
  773.  
  774.           break;
  775.         case 26:
  776.           editMode = editMode - 2;
  777.           break;
  778.         case 31:
  779.           tunerDisableScreen();
  780.           break;
  781.         case 32:
  782.           editMode = editMode - 2;
  783.           break;
  784.         case 41:
  785.           //set how many days to turn alarm
  786.           while (escape == 0) {
  787.             checkeditbutton();
  788.             buttons(4);
  789.             hatchDays = constrain(hatchDays, 1, 40);
  790.             lcd.setCursor(3, 0);
  791.             lcd.print (F("days before"));
  792.             lcd.setCursor(2, 1);
  793.             lcd.print (F("lockdown"));
  794.             lcd.setCursor(0, 2);
  795.             lcd.print (F("adjust "));
  796.             addSpace(1);
  797.             lcd.print (hatchDays);
  798.             lcd.setCursor(0, 3);
  799.             lcd.print(standardText[1]);
  800.             memory_update = 1;
  801.           }
  802.           editMode = editMode - 1;
  803.           break;
  804.         case 42:
  805.           //add how many days to count and start
  806.           lcd.clear();
  807.           lcd.setCursor(1, 2);
  808.           lcd.print (F("countdown started"));
  809.           delay(1000);
  810.           hatchCountUp = 0;
  811.           memory_update = 1;
  812.           editMode = editMode - 1;
  813.           break;
  814.         case 43:
  815.           //disable count down alarm
  816.           // hatchAlarm==1 on
  817.           while (escape == 0) {
  818.             checkeditbutton();
  819.             buttons(16);
  820.  
  821.             lcd.setCursor(3, 0);
  822.             lcd.print (F("hatch alarm"));
  823.             lcd.setCursor(1, 1);
  824.             lcd.print (F("on/off"));
  825.  
  826.             lcd.setCursor(12, 1);
  827.             if (hatchAlarm == 0) {
  828.               lcd.print (F("off"));
  829.             }
  830.             else {
  831.               lcd.print (F("on"));
  832.               addSpace(1);
  833.             }
  834.             lcd.setCursor(0, 3);
  835.             lcd.print(standardText[1]);
  836.             memory_update = 1;
  837.           }
  838.           editMode = editMode - 1;
  839.  
  840.           break;
  841.         case 44:
  842.           editMode = editMode - 2;
  843.           break;
  844.         case 51:
  845.  
  846.           while (escape == 0) {
  847.             checkeditbutton();
  848.             buttons(17);
  849.             if (turnerType > 4) {
  850.               turnerType = 1;
  851.             }
  852.             if (turnerType < 1) {
  853.               turnerType = 4;
  854.             }
  855.             lcd.setCursor(3, 0);
  856.             lcd.print (F("turner design"));
  857.             lcd.setCursor(2, 1);
  858.             switch (turnerType) {
  859.               case 1:
  860.                 lcd.print (F("always running"));
  861.                 break;
  862.               case 2:
  863.                 lcd.print (F("timed on/delay"));
  864.                 break;
  865.               case 3:
  866.                 addSpace(3);
  867.                 lcd.print (F("cam tilt"));
  868.                 addSpace(3);
  869.                 break;
  870.               case 4:
  871.                 lcd.print (F("reversing tilt"));
  872.                 break;
  873.             }
  874.             lcd.setCursor(0, 3);
  875.             lcd.print(standardText[1]);
  876.             memory_update = 1;
  877.           }
  878.           editMode = editMode - 1;
  879.           break;
  880.  
  881.         case 52:
  882.           //select f or c
  883.           prevtempinF = tempinF;
  884.           while (escape == 0) {
  885.             checkeditbutton();
  886.             buttons(31);
  887.             lcd.setCursor(3, 0);
  888.             lcd.print (F("temp F or C"));
  889.             lcd.setCursor(8, 1);
  890.             lcd.print (F("select"));
  891.  
  892.             lcd.setCursor(4, 2);
  893.             if ( tempinF  == 0) {
  894.               lcd.print (F("temp in F"));
  895.             }
  896.             else {
  897.               lcd.print (F("temp in C"));
  898.               addSpace(1);
  899.             }
  900.             lcd.setCursor(0, 3);
  901.             lcd.print(standardText[1]);
  902.           }
  903.  
  904.           if (tempinF != prevtempinF) {
  905.             if (tempinF == 0) {
  906.               temp_setpoint = 99.5;
  907.               highTempSetPoint = 102;
  908.               lowTempAlarmPoint = 95;
  909.               cal_temp = 0;
  910.               tempSwing = 0.5;
  911.             } else {
  912.               temp_setpoint = 37.5;
  913.               highTempSetPoint = 39;
  914.               lowTempAlarmPoint = 33;
  915.               cal_temp = 0;
  916.               tempSwing = 0.5;
  917.             }
  918.             EEPROM.put(0, temp_setpoint);//float
  919.             EEPROM.put(8, highTempSetPoint);//float
  920.             EEPROM.put(12, lowTempAlarmPoint);//float
  921.             EEPROM.write(40, tempinF);
  922.             EEPROM.put(48, cal_temp);
  923.             EEPROM.put(56, tempSwing);
  924.  
  925.             lcd.clear();
  926.             lcd.setCursor(1, 0);
  927.             lcd.print("change detected");
  928.             lcd.setCursor(1, 1);
  929.             lcd.print("check calibration");
  930.             lcd.setCursor(5, 3);
  931.             lcd.print("returning");
  932.             delay(3000);
  933.           }
  934.           editMode = editMode - 1;
  935.           break;
  936.  
  937.         case 53:
  938.           //to next edit mode disable or enable audio alarm
  939.           while (escape == 0) {
  940.             checkeditbutton();
  941.             buttons(23);
  942.             lcd.setCursor(3, 0);
  943.             lcd.print (F("audio alarm"));
  944.             lcd.setCursor(1, 1);
  945.             lcd.print (F("on/off"));
  946.  
  947.             lcd.setCursor(12, 1);
  948.             if (audioalarm  == 0) {
  949.               lcd.print (F("off"));
  950.             }
  951.             else {
  952.               lcd.print (F("on"));
  953.               addSpace(1);
  954.             }
  955.             lcd.setCursor(0, 3);
  956.             lcd.print(standardText[1]);
  957.             memory_update = 1;
  958.           }
  959.           editMode = editMode - 1;
  960.           break;
  961.         case 54:
  962.           //to next edit mode add hotspot to home display
  963.           lcd.clear();
  964.           lcd.setCursor(8, 0);
  965.           lcd.print (F("sry"));
  966.           lcd.setCursor(2, 1);
  967.           lcd.print (F("not available"));
  968.           lcd.setCursor(2, 2);
  969.           lcd.print (F("on this model"));
  970.           lcd.setCursor(4, 3);
  971.           lcd.print (F("returning"));
  972.           delay(3000);
  973.           editMode = editMode - 1;
  974.           break;
  975.  
  976.         case 55:
  977.           editMode = editMode - 2;
  978.           break;
  979.         case 61:
  980.           //write to memory setup numbers
  981.           while (escape == 0) {
  982.             checkeditbutton();
  983.             buttons(30);
  984.             lcd.setCursor(3, 0);
  985.             lcd.print (F("reset"));
  986.             lcd.setCursor(1, 1);
  987.             lcd.print (F("yes/no"));
  988.  
  989.             lcd.setCursor(12, 1);
  990.             if (facReset == 0) {
  991.               lcd.print (F("no"));
  992.               addSpace(1);
  993.             }
  994.             else {
  995.               lcd.print (F("yes"));
  996.             }
  997.             lcd.setCursor(0, 3);
  998.             lcd.print(standardText[1]);
  999.           }
  1000.           if (facReset == 0) {
  1001.             editMode = editMode - 1;
  1002.           } else {
  1003.             lcd.clear();
  1004.             lcd.setCursor(5, 1);
  1005.             lcd.print (F("saving"));
  1006.             facReset = 0;
  1007.             if (tempinF == 0) {// is F
  1008.               temp_setpoint = 99.5;
  1009.               highTempSetPoint = 102;
  1010.               lowTempAlarmPoint = 95;
  1011.             }
  1012.             else {//is C
  1013.               temp_setpoint = 37.5;
  1014.               highTempSetPoint = 39;
  1015.               lowTempAlarmPoint = 33;
  1016.             }
  1017.             humidity_setpoint = 35;
  1018.             turnerAlarm = 1;
  1019.             highHumidAlarmPoint = 85;
  1020.             lowHumidAlarmPoint = 25;
  1021.             cal_temp = 0;
  1022.             cal_humidity = 0;
  1023.             tempSwing = 0.5;
  1024.             humiditySwing = 1;
  1025.             hatchDays = 19;
  1026.             hatchCountUp = 0;
  1027.             turnerType = 2;
  1028.             tunerDisable = 0;
  1029.             TimeBetweenTurns = 2;
  1030.             TimeTurnerTurns = 15;
  1031.             memory_update = 1;
  1032.             noSave = 0;
  1033.             audioalarm = 1;
  1034.             tempalarm = 1;
  1035.             humalarm = 1;
  1036.             hatchAlarm = 1;
  1037.             memoryUpdater();
  1038.             delay(2000);
  1039.             editMode = 0;
  1040.           }
  1041.           break;
  1042.         case 62:
  1043.           editMode = editMode - 2;
  1044.           break;
  1045.         case 81:
  1046.           //temp alarm on/off  all linked back to alarmcheck()
  1047.  
  1048.           while (escape == 0) {
  1049.             checkeditbutton();
  1050.             buttons(24);
  1051.             lcd.setCursor(3, 0);
  1052.             lcd.print (F("temp alarm"));
  1053.             lcd.setCursor(1, 1);
  1054.             lcd.print (F("on/off"));
  1055.  
  1056.             lcd.setCursor(12, 1);
  1057.             if (tempalarm  == 0) {
  1058.               lcd.print (F("off"));
  1059.             }
  1060.             else {
  1061.               lcd.print (F("on"));
  1062.               addSpace(1);
  1063.             }
  1064.             lcd.setCursor(0, 3);
  1065.             lcd.print(standardText[1]);
  1066.             memory_update = 1;
  1067.           }
  1068.           editMode = editMode - 1;
  1069.  
  1070.  
  1071.           break;
  1072.         case 82:
  1073.           //humidity alarm on/off linked back to alarmcheck()
  1074.  
  1075.           while (escape == 0) {
  1076.             checkeditbutton();
  1077.             buttons(25);
  1078.             lcd.setCursor(2, 0);
  1079.             lcd.print (F("humidity alarm"));
  1080.             lcd.setCursor(1, 1);
  1081.             lcd.print (F("on/off"));
  1082.  
  1083.             lcd.setCursor(12, 1);
  1084.             if (humalarm   == 0) {
  1085.               lcd.print (F("off"));
  1086.             }
  1087.             else {
  1088.               lcd.print (F("on"));
  1089.               addSpace(1);
  1090.             }
  1091.             lcd.setCursor(0, 3);
  1092.             lcd.print(standardText[1]);
  1093.             memory_update = 1;
  1094.           }
  1095.           editMode = editMode - 1;
  1096.           break;
  1097.         case 83:
  1098.           //display set points
  1099.           while (escape == 0) {
  1100.             checkeditbutton();
  1101.             lcd.setCursor(0, 0);
  1102.             lcd.print(F("high low set points"));
  1103.             lcd.setCursor(0, 1);
  1104.             lcd.print(F("L"));
  1105.             lcd.write(1);
  1106.             addSpace(1);
  1107.             lcd.print (lowTempAlarmPoint, 1);
  1108.             addSign();
  1109.             lcd.setCursor(10, 1);
  1110.             lcd.print(F("H"));
  1111.             lcd.write(1);
  1112.             addSpace(1);
  1113.             lcd.print (highTempSetPoint, 1);
  1114.             addSign();
  1115.             lcd.setCursor(0, 2);
  1116.             lcd.print("L");
  1117.             lcd.write(2);
  1118.             addSpace(1);
  1119.             lcd.print (lowHumidAlarmPoint, 0);
  1120.             lcd.setCursor(10, 2);
  1121.             lcd.print(F("H"));
  1122.             lcd.write(2);
  1123.             addSpace(1);
  1124.             lcd.print (highHumidAlarmPoint, 0);
  1125.             lcd.setCursor(0, 3);
  1126.             lcd.print(standardText[3]);
  1127.           }
  1128.           editMode = editMode - 1;
  1129.           break;
  1130.         case 84:
  1131.           //over temp setpoint linked back to alarmcheck()
  1132.           while (escape == 0) {
  1133.             checkeditbutton();
  1134.             buttons(26);
  1135.             lcd.setCursor(2, 0);
  1136.             lcd.print (F("high temp alarm"));
  1137.             lcd.setCursor(0, 1);
  1138.             lcd.print(standardText[2]);
  1139.             lcd.print (highTempSetPoint, 1);
  1140.             addSign();
  1141.             lcd.setCursor(0, 3);
  1142.             lcd.print(standardText[1]);
  1143.             memory_update = 1;
  1144.           }
  1145.           editMode = editMode - 1;
  1146.  
  1147.           break;
  1148.         case 85:
  1149.           //under temp setpoint linked back to alarmcheck()
  1150.           while (escape == 0) {
  1151.             checkeditbutton();
  1152.             buttons(27);
  1153.             lcd.setCursor(2, 0);
  1154.             lcd.print (F("low temp alarm"));
  1155.             lcd.setCursor(0, 1);
  1156.             lcd.print(standardText[2]);
  1157.             lcd.print (lowTempAlarmPoint, 1);
  1158.             addSign();
  1159.             lcd.setCursor(0, 3);
  1160.             lcd.print(standardText[1]);
  1161.             memory_update = 1;
  1162.           }
  1163.           editMode = editMode - 1;
  1164.           break;
  1165.         case 86:
  1166.           //high hum setpoint linked back to alarmcheck()
  1167.           while (escape == 0) {
  1168.             checkeditbutton();
  1169.             buttons(28);
  1170.             lcd.setCursor(2, 0);
  1171.             lcd.print (F("high humid alarm"));
  1172.             lcd.setCursor(0, 1);
  1173.             lcd.print(standardText[2]);
  1174.             lcd.print (highHumidAlarmPoint, 0);
  1175.             lcd.setCursor(0, 3);
  1176.             lcd.print(standardText[1]);
  1177.             memory_update = 1;
  1178.           }
  1179.           editMode = editMode - 1;
  1180.           break;
  1181.         case 87://low hum setpoint
  1182.           while (escape == 0) {
  1183.             checkeditbutton();
  1184.             buttons(29);
  1185.             lcd.setCursor(2, 0);
  1186.             lcd.print (F("low humid alarm"));
  1187.             lcd.setCursor(0, 1);
  1188.             lcd.print(standardText[2]);
  1189.             lcd.print (lowHumidAlarmPoint, 0);
  1190.             lcd.setCursor(0, 3);
  1191.             lcd.print(standardText[1]);
  1192.             memory_update = 1;
  1193.           }
  1194.           editMode = editMode - 1;
  1195.           break;
  1196.         case 88://return
  1197.           editMode = editMode - 2;
  1198.           break;
  1199.         case 101:
  1200.           //disable
  1201.           tunerDisableScreen();
  1202.           break;
  1203.         case 102:
  1204.           // setTimeTurnerTurns
  1205.           while (escape == 0) {
  1206.             checkeditbutton();
  1207.             buttons(19);
  1208.             if (TimeTurnerTurns < 1) {
  1209.               TimeTurnerTurns = 1;
  1210.             }
  1211.             lcd.setCursor(3, 0);
  1212.             lcd.print (F("turner runs for"));
  1213.             lcd.setCursor(2, 1);
  1214.             lcd.print (TimeTurnerTurns);
  1215.             addSpace(1);
  1216.             lcd.print (F("seconds"));
  1217.             lcd.setCursor(0, 2);
  1218.             lcd.print(standardText[1]);
  1219.             memory_update = 1;
  1220.           }
  1221.           editMode = editMode - 1;
  1222.           break;
  1223.         case 103:
  1224.           //time between turns
  1225.           setTimeBetweenTurns();
  1226.           break;
  1227.         case 104:
  1228.           //test turner
  1229.           turntester();
  1230.           break;
  1231.         case 105:
  1232.           //return
  1233.           editMode = editMode - 2;
  1234.           break;
  1235.         case 111:
  1236.           //disable
  1237.           tunerDisableScreen();
  1238.           break;
  1239.         case 112:
  1240.           //time between turns
  1241.           setTimeBetweenTurns();
  1242.           break;
  1243.         case 113:
  1244.           //cam time
  1245.           while (escape == 0) {
  1246.             checkeditbutton();
  1247.             buttons(19);
  1248.             if (TimeTurnerTurns < 1) {
  1249.               TimeTurnerTurns = 1;
  1250.             }
  1251.             lcd.setCursor(3, 0);
  1252.             lcd.print (F("time to clear"));
  1253.             lcd.setCursor(5, 1);
  1254.             lcd.print (F("cam switch"));
  1255.             lcd.setCursor(2, 2);
  1256.             lcd.print (TimeTurnerTurns);
  1257.             addSpace(1);
  1258.             lcd.print (F("seconds"));
  1259.             lcd.setCursor(0, 3);
  1260.             lcd.print(standardText[1]);
  1261.             memory_update = 1;
  1262.           }
  1263.           editMode = editMode - 1;
  1264.           break;
  1265.         case 114:
  1266.           //turn test
  1267.           turntester();
  1268.           break;
  1269.         case 115:
  1270.           editMode = editMode - 2;
  1271.           break;
  1272.         case 121:
  1273.           //disable
  1274.           tunerDisableScreen();
  1275.           break;
  1276.         case 122:
  1277.           //time between turns
  1278.           setTimeBetweenTurns();
  1279.           break;
  1280.         case 123:
  1281.           //turner manual
  1282.           while (escape == 0) {
  1283.             checkeditbutton();
  1284.             buttons(22);
  1285.             if (minusButton == 0) {
  1286.               digitalWrite (turnerrelay1, LOW);
  1287.             } else {
  1288.               digitalWrite (turnerrelay1, HIGH);
  1289.             }
  1290.  
  1291.             if (plusButton == 0) {
  1292.               digitalWrite (turnerrelay2, LOW);
  1293.             } else {
  1294.               digitalWrite (turnerrelay2, HIGH);
  1295.             }
  1296.  
  1297.             lcd.setCursor(4, 0);
  1298.             lcd.print (F("tilt manual"));
  1299.             lcd.setCursor(2, 1);
  1300.             lcd.print (F("use up and down"));
  1301.             lcd.setCursor(2, 2);
  1302.             lcd.print (F("to move table"));
  1303.             lcd.setCursor(0, 3);
  1304.             lcd.print(standardText[3]);
  1305.             tunerDisable = 0;
  1306.           }
  1307.           lcd.clear();
  1308.           lcd.setCursor(4, 0);
  1309.           lcd.print (F("remember to"));
  1310.           lcd.setCursor(2, 1);
  1311.           lcd.print (F("enable tilt"));
  1312.           lcd.setCursor(2, 2);
  1313.           lcd.print (F("when finnished"));
  1314.           lcd.setCursor(4, 3);
  1315.           lcd.print (F("returning"));
  1316.           delay(3000);
  1317.           editMode = editMode - 1;
  1318.  
  1319.           break;
  1320.         case 124:
  1321.           //turner alarm
  1322.           setturnerAlarm();
  1323.           break;
  1324.         case 125:
  1325.           //test turner
  1326.           turntester();
  1327.           break;
  1328.         case 126:
  1329.           editMode = editMode - 2;
  1330.           break;
  1331.       }
  1332.       lcd.clear();
  1333.       break;
  1334.   }
  1335. }
  1336.  
  1337. void buttons(byte type) {
  1338.  
  1339.   plusButton = digitalRead(buttonPlus);
  1340.   minusButton = digitalRead(buttonMinus);
  1341.  
  1342.   if ((plusButton == 0) && (prevplusButton == 1)) {
  1343.     lcd.clear();
  1344.     switch (type) {
  1345.       case 1:
  1346.         menuNumber++;
  1347.         break;
  1348.       case 2:
  1349.         menuNumber2++;
  1350.         break;
  1351.       case 3:
  1352.         menuNumber3++;
  1353.         break;
  1354.       case 4:
  1355.         hatchDays++;
  1356.         break;
  1357.       case 5:
  1358.         set_minute++;
  1359.         break;
  1360.       case 6:
  1361.         set_hour++;
  1362.         break;
  1363.       case 7:
  1364.         set_day++;
  1365.         break;
  1366.       case 8:
  1367.         set_month++;
  1368.         break;
  1369.       case 9:
  1370.         set_year++;
  1371.         break;
  1372.       case 10:
  1373.         temp_setpoint = temp_setpoint + 0.1;
  1374.         break;
  1375.       case 11:
  1376.         humidity_setpoint++;
  1377.         break;
  1378.       case 12:
  1379.         cal_temp =  cal_temp + 0.1;
  1380.         break;
  1381.       case 13:
  1382.         cal_humidity = cal_humidity + 0.1;
  1383.         break;
  1384.       case 14:
  1385.         tempSwing = tempSwing + 0.1;
  1386.         break;
  1387.       case 15:
  1388.         humiditySwing = humiditySwing + 1;
  1389.         break;
  1390.       case 16:
  1391.         hatchAlarm = ! hatchAlarm;
  1392.         break;
  1393.       case 17:
  1394.         turnerType++;
  1395.         break;
  1396.       case 18:
  1397.         TimeBetweenTurns++;
  1398.         break;
  1399.       case 19:
  1400.         TimeTurnerTurns++;
  1401.         break;
  1402.       case 20:
  1403.         turnerAlarm = !turnerAlarm;
  1404.         break;
  1405.       case 21:
  1406.         tunerDisable = !tunerDisable;
  1407.         break;
  1408.       case 22:
  1409.         //  do not use this spot
  1410.         break;
  1411.       case 23:
  1412.         audioalarm = ! audioalarm;
  1413.         break;
  1414.       case 24:
  1415.         tempalarm = !tempalarm;
  1416.         break;
  1417.       case 25:
  1418.         humalarm = ! humalarm;
  1419.         break;
  1420.       case 26:
  1421.         highTempSetPoint = highTempSetPoint + 0.1;
  1422.         break;
  1423.       case 27:
  1424.         lowTempAlarmPoint = lowTempAlarmPoint + 0.1;
  1425.         break;
  1426.       case 28:
  1427.         highHumidAlarmPoint = highHumidAlarmPoint + 1;
  1428.         break;
  1429.       case 29:
  1430.         lowHumidAlarmPoint = lowHumidAlarmPoint + 1;
  1431.         break;
  1432.       case 30:
  1433.         facReset = !facReset;
  1434.         break;
  1435.       case 31:
  1436.         tempinF = !tempinF;
  1437.         break;
  1438.     }
  1439.     prevplusButton = 0;
  1440.   }
  1441.   if (plusButton == 1) {
  1442.     prevplusButton = 1; //debounce
  1443.   }
  1444.  
  1445.   if ((minusButton == 0) && (prevMinusButton == 1)) {
  1446.     lcd.clear();
  1447.     switch (type) {
  1448.       case 1:
  1449.         menuNumber--;
  1450.         break;
  1451.       case 2:
  1452.         menuNumber2--;
  1453.         break;
  1454.       case 3:
  1455.         menuNumber3--;
  1456.         break;
  1457.       case 4:
  1458.         hatchDays--;
  1459.         break;
  1460.       case 5:
  1461.         set_minute--;
  1462.         break;
  1463.       case 6:
  1464.         set_hour--;
  1465.         break;
  1466.       case 7:
  1467.         set_day--;
  1468.         break;
  1469.       case 8:
  1470.         set_month--;
  1471.         break;
  1472.       case 9:
  1473.         set_year--;
  1474.         break;
  1475.       case 10:
  1476.         temp_setpoint = temp_setpoint - 0.1;
  1477.         break;
  1478.       case 11:
  1479.         humidity_setpoint--;
  1480.         break;
  1481.       case 12:
  1482.         cal_temp =  cal_temp - 0.1;
  1483.         break;
  1484.       case 13:
  1485.         cal_humidity = cal_humidity - 0.1;
  1486.         break;
  1487.       case 14:
  1488.         tempSwing = tempSwing - 0.1;
  1489.         break;
  1490.       case 15:
  1491.         humiditySwing = humiditySwing - 1;
  1492.         break;
  1493.       case 16:
  1494.         hatchAlarm = !hatchAlarm;
  1495.         break;
  1496.       case 17:
  1497.         turnerType--;
  1498.         break;
  1499.       case 18:
  1500.         TimeBetweenTurns--;
  1501.         break;
  1502.       case 19:
  1503.         TimeTurnerTurns--;
  1504.         break;
  1505.       case 20:
  1506.         turnerAlarm = !turnerAlarm;
  1507.         break;
  1508.       case 21:
  1509.         tunerDisable = !tunerDisable;
  1510.         break;
  1511.       case 22:
  1512.         //do not use this spot
  1513.         break;
  1514.       case 23:
  1515.         audioalarm = ! audioalarm;
  1516.         break;
  1517.       case 24:
  1518.         tempalarm = !tempalarm;
  1519.         break;
  1520.       case 25:
  1521.         humalarm = ! humalarm;
  1522.         break;
  1523.       case 26:
  1524.         highTempSetPoint = highTempSetPoint - 0.1;
  1525.         break;
  1526.       case 27:
  1527.         lowTempAlarmPoint = lowTempAlarmPoint - 0.1;
  1528.         break;
  1529.       case 28:
  1530.         highHumidAlarmPoint = highHumidAlarmPoint - 1;
  1531.         break;
  1532.       case 29:
  1533.         lowHumidAlarmPoint = lowHumidAlarmPoint - 1;
  1534.         break;
  1535.       case 30:
  1536.         facReset = !facReset;
  1537.         break;
  1538.       case 31:
  1539.         tempinF = !tempinF;
  1540.         break;
  1541.  
  1542.     }
  1543.     prevMinusButton = 0;
  1544.   }
  1545.   if (minusButton == 1) {
  1546.     prevMinusButton = 1; //debounce
  1547.   }
  1548.  
  1549. }
  1550.  
  1551.  
  1552.  
  1553. void callHomeScreen() {
  1554.  
  1555.   lcd.setCursor(0, 0);
  1556.   showclock();
  1557.   lcd.setCursor(0, 1);
  1558.   lcd.write(1);
  1559.   lcd.print(F(":"));
  1560.   addSpace(1);
  1561.   if (adj_temp, 1 < 100) {
  1562.     addSpace(1); //stop screen moving due to extra digit
  1563.   }
  1564.   lcd.print (adj_temp, 1);
  1565.   addSign();
  1566.   addSpace(1);
  1567.   lcd.write(2);
  1568.   lcd.print(F(":"));
  1569.   addSpace(1);
  1570.   lcd.print (adj_humidity, 1);
  1571.  
  1572.   lcd.setCursor(0, 2);
  1573.   lcd.write (4);
  1574.   switch (display_stat_turn) {
  1575.     case 1:
  1576.       addSpace(6);
  1577.       lcd.print (F("off"));
  1578.       addSpace(8);
  1579.       break;
  1580.     case 2:
  1581.  
  1582.       time_to_turn_hr = (turn_timer / 60);
  1583.       time_to_turn_mins = turn_timer - (time_to_turn_hr * 60);
  1584.       if ((time_to_turn_hr == 0) && (time_to_turn_mins == 0)) {
  1585.         lcd.print (F(" turn pending "));
  1586.         lcd.print (countdown);
  1587.       }
  1588.       else {
  1589.         //add stop screen moving due to extra digit
  1590.         addSpace(1);
  1591.         lcd.print (time_to_turn_hr);
  1592.         addSpace(1);
  1593.         lcd.print (F("hrs"));
  1594.         addSpace(1);
  1595.  
  1596.         if (time_to_turn_mins < 10) {
  1597.           addSpace(1);
  1598.         }
  1599.         lcd.print (time_to_turn_mins);
  1600.         addSpace(1);
  1601.         lcd.print (F("mins"));
  1602.       }
  1603.  
  1604.       break;
  1605.     case 3:
  1606.       if ((turnerType == 1) || (turnerType == 4)) {
  1607.         addSpace(5);
  1608.         lcd.print (F("running"));
  1609.         addSpace(6);
  1610.       } else {
  1611.         addSpace(2);
  1612.         lcd.print (F("running"));
  1613.         addSpace(1);
  1614.         lcd.print (turnerRunCounter);
  1615.       }
  1616.       break;
  1617.   }
  1618.  
  1619.   lcd.setCursor(0, 3);
  1620.   if (alarm_active == 0) {
  1621.     if (hatchAlarm == 1) {
  1622.       lcd.print (F("hatch in"));
  1623.       addSpace(1);
  1624.       lcd.print (hatchDays);
  1625.       addSpace(1);
  1626.       lcd.print (F("days"));
  1627.       addSpace(2);
  1628.     } else {
  1629.       lcd.write (3);
  1630.       addSpace(5);
  1631.       lcd.print  (F("enabled"));
  1632.       addSpace(5);
  1633.     }
  1634.   }
  1635.  
  1636.  
  1637.   if (alarm_active != 0) {
  1638.     lcd.write (3);
  1639.     switch (alarm_active) {
  1640.       case 1:
  1641.         addSpace(4);
  1642.         lcd.print (F("high temp"));
  1643.         addSpace(4);
  1644.         break;
  1645.       case 2:
  1646.         addSpace(4);
  1647.         lcd.print (F("low temp"));
  1648.         addSpace(5);
  1649.         break;
  1650.       case 3:
  1651.         addSpace(4);
  1652.         lcd.print (F("hi humidity"));
  1653.         addSpace(2);
  1654.         break;
  1655.       case 4:
  1656.         addSpace(3);
  1657.         lcd.print (F("low humidity"));
  1658.         addSpace(2);
  1659.         break;
  1660.       case 7:
  1661.         addSpace(4);
  1662.         lcd.print (F("rtc fail"));
  1663.         addSpace(4);
  1664.         break;
  1665.       case 8:
  1666.         addSpace(2);
  1667.         lcd.print (F("turner overrun"));
  1668.         addSpace(1);
  1669.         break;
  1670.       case 9:
  1671.         addSpace(1);
  1672.         lcd.print (F("lockdown now"));
  1673.         addSpace(1);
  1674.         break;
  1675.  
  1676.     }
  1677.  
  1678.   }
  1679.  
  1680.   lcd.setCursor(18, 3);
  1681.   if (heaterdisplay == 1) {
  1682.     lcd.write (1);//temp replay indicator
  1683.   } else {
  1684.     addSpace(1);
  1685.   }
  1686.   lcd.setCursor(19, 3);
  1687.   if (humidityfandisplay == 1) {
  1688.     lcd.write (2);//humidity relay indicator
  1689.   } else {
  1690.     addSpace(1);
  1691.   }
  1692. }
  1693.  
  1694. void getTemp() {
  1695.   if (temp_timer >= 1) {
  1696.     humidity = sensor1.readHumidity();
  1697.     // Read temperature as Celsius
  1698.     tempC = sensor1.readTemperature();
  1699.     // Read temperature as Fahrenheit
  1700.     tempF = sensor1.readTemperature(true);
  1701.     temp_timer = 0;
  1702.   }
  1703.  
  1704.   if (tempinF == 0) {
  1705.     temp = tempF;
  1706.   }
  1707.   else {
  1708.     temp = tempC;
  1709.   }
  1710.   // failed to read sensor alarm
  1711.   if (isnan(humidity) || isnan(temp)) {
  1712.     alarm_active = 5;
  1713.     badsensor = 1; //bad reading go safe
  1714.   } else {
  1715.     badsensor = 0;
  1716.   }
  1717.  
  1718.  
  1719.  
  1720.   adj_humidity = humidity - cal_humidity;
  1721.   adj_temp = temp - cal_temp;
  1722.  
  1723.  
  1724.  
  1725. }
  1726. void humidityFan() {
  1727.   //humidity fan code
  1728.   if (badsensor == 0) { //good reading
  1729.     if (adj_humidity >= humidity_setpoint) {
  1730.       digitalWrite (humidityRelay, HIGH);//off
  1731.       humidityfandisplay = 0;
  1732.     }
  1733.     else if ( adj_humidity <= humidity_setpoint - humiditySwing ) {
  1734.       if (editMode != 0) {
  1735.         digitalWrite (humidityRelay, HIGH);//in while loop disable
  1736.       } else {
  1737.         digitalWrite (humidityRelay, LOW);//low is on
  1738.         humidityfandisplay = 1;
  1739.       }
  1740.     }
  1741.  
  1742.   } else { //bad reading go safe
  1743.     digitalWrite (humidityRelay, HIGH);//off
  1744.     humidityfandisplay = 0;
  1745.   }
  1746. }
  1747.  
  1748. void heatercontrols() {
  1749.   if (badsensor == 0) { //good reading
  1750.     if (adj_temp >= temp_setpoint) {
  1751.       digitalWrite (heaterRelay, HIGH);//off
  1752.       heaterdisplay = 0;
  1753.     }
  1754.     else if ( adj_temp <= temp_setpoint - tempSwing ) {
  1755.       if (editMode != 0) {
  1756.         digitalWrite (heaterRelay, HIGH);//in while loop disable
  1757.       } else {
  1758.         digitalWrite (heaterRelay, LOW);//low is on
  1759.         heaterdisplay = 1;
  1760.       }
  1761.     }
  1762.  
  1763.   } else { //bad reading go safe
  1764.     digitalWrite (heaterRelay, HIGH);//off
  1765.     heaterdisplay = 0;
  1766.   }
  1767. }
  1768.  
  1769. void  checkeditbutton() {
  1770.  
  1771.   lightButton = digitalRead(buttonEnter);
  1772.   editButton = digitalRead(buttonEdit);
  1773.  
  1774.   //after 2 mins kick out of menu and do not save changes
  1775.   unsigned long currentMillis5 = millis();
  1776.   if (currentMillis5 - previousMillis5 > 120000L) {
  1777.     escape = 1;
  1778.     noSave = 1;
  1779.     editMode = 0;
  1780.     previousMillis5 = currentMillis5;
  1781.   }
  1782.  
  1783.   if (editButton != preveditButton) {
  1784.     if (editButton == LOW) {
  1785.       editMode++;
  1786.       escape = 1;
  1787.       lcd.clear();
  1788.       previousMillis5 = currentMillis5;
  1789.     }
  1790.     preveditButton = editButton;
  1791.   }
  1792.   editMode = constrain(editMode, 0, 3);
  1793.  
  1794.   if (lightButton != prevlightButton) {
  1795.     if (lightButton == LOW ) {
  1796.       editMode = 0;
  1797.       lcd.clear();
  1798.       escape = 1;
  1799.       noSave = 1;
  1800.       menuNumber = 0;
  1801.       subMenu = 0;
  1802.       setlightrelay = !setlightrelay;
  1803.     }
  1804.     prevlightButton = lightButton;
  1805.   }
  1806.  
  1807.   if (setlightrelay == 0) {
  1808.     digitalWrite(lightrelay, HIGH);
  1809.   } else {
  1810.     digitalWrite(lightrelay, LOW);
  1811.   }
  1812. }
  1813.  
  1814.  
  1815. void showclock() {
  1816.   clock.getTime();
  1817.   if (clock.hour < 10) {
  1818.     lcd.print("0");
  1819.   }
  1820.   lcd.print(clock.hour, DEC);
  1821.   lcd.print(":");
  1822.   if (clock.minute < 10) {
  1823.     lcd.print("0");
  1824.   }
  1825.   lcd.print(clock.minute, DEC);
  1826.   lcd.print(":");
  1827.   if (clock.second < 10) {
  1828.     lcd.print("0");
  1829.   }
  1830.   lcd.print(clock.second, DEC);
  1831.   lcd.print(" ");
  1832.   if (clock.month < 10) {
  1833.     lcd.print("0");
  1834.   }
  1835.   lcd.print(clock.month, DEC);
  1836.   lcd.print("/");
  1837.   if (clock.dayOfMonth < 10) {
  1838.     lcd.print("0");
  1839.   }
  1840.   lcd.print(clock.dayOfMonth, DEC);
  1841.   lcd.print("/");
  1842.   lcd.print(clock.year + 2000, DEC);
  1843. }
  1844. void memoryUpdater() {
  1845.   if (noSave == 1) {
  1846.     memory_update = 0;
  1847.   }
  1848.   noSave = 0;
  1849.   if (memory_update == 1) {
  1850.     EEPROM.put(0, temp_setpoint);//float
  1851.     EEPROM.write (4, turnerAlarm );// int
  1852.     EEPROM.put(8, highTempSetPoint);//float
  1853.     EEPROM.put(12, lowTempAlarmPoint);//float
  1854.     EEPROM.put(16, highHumidAlarmPoint);//float
  1855.     EEPROM.put(20, lowHumidAlarmPoint);//float
  1856.     EEPROM.write(24, audioalarm );
  1857.     EEPROM.write(28, tempalarm );
  1858.     EEPROM.write(32, humalarm );
  1859.     EEPROM.write(36, hatchAlarm );
  1860.     EEPROM.write(40, tempinF);
  1861.     EEPROM.put(48, cal_temp);
  1862.     EEPROM.put(52, cal_humidity);
  1863.     EEPROM.put(56, tempSwing);
  1864.     EEPROM.put(60, humiditySwing);
  1865.     EEPROM.write(64, hatchDays );
  1866.     EEPROM.write(68, hatchCountUp );
  1867.     EEPROM.write(72, turnerType );
  1868.     EEPROM.write(76, tunerDisable );
  1869.     EEPROM.write(80, TimeBetweenTurns );
  1870.     EEPROM.write(84, TimeTurnerTurns);
  1871.     EEPROM.put(88, humidity_setpoint);
  1872.   }
  1873.   memory_update = 0;
  1874. }
  1875. void turnerCountForDisplay() {
  1876.   clock.getTime();
  1877.   if (reboot == 1) {
  1878.     prev_clock_day = clock.dayOfMonth;
  1879.     reboot = 0;
  1880.   }
  1881.   if (prev_clock_day != clock.dayOfMonth) {
  1882.     hatchCountUp++;
  1883.     hatchDays = hatchDays - hatchCountUp;
  1884.   }
  1885.  
  1886.   prev_clock_day = clock.dayOfMonth;
  1887. }
  1888. void alarmcheck () {
  1889.  
  1890.   alarm_active = 0;
  1891.   if (adj_temp >= highTempSetPoint ) {
  1892.     alarm_active = 1;
  1893.     if (tempalarm == 1) {
  1894.       soundalarm = 1;
  1895.     } else {
  1896.       soundalarm = 0;
  1897.     }
  1898.   }
  1899.   if (adj_temp <= lowTempAlarmPoint) {
  1900.     alarm_active = 2;
  1901.     if (tempalarm == 1) {
  1902.       soundalarm = 1;
  1903.     } else {
  1904.       soundalarm = 0;
  1905.     }
  1906.   }
  1907.   if (adj_humidity >= highHumidAlarmPoint) {
  1908.     alarm_active = 3;
  1909.     if (humalarm == 1) {
  1910.       soundalarm = 1;
  1911.     } else {
  1912.       soundalarm = 0;
  1913.     }
  1914.   }
  1915.   if (adj_humidity <= lowHumidAlarmPoint) {
  1916.     alarm_active = 4;
  1917.     if (humalarm == 1) {
  1918.       soundalarm = 1;
  1919.     } else {
  1920.       soundalarm = 0;
  1921.     }
  1922.   }
  1923.   if (hatchDays == 0) {
  1924.     alarm_active = 9;
  1925.     hatchAlarm;
  1926.     if (hatchAlarm == 1) {
  1927.       soundalarm = 1;
  1928.     } else {
  1929.       soundalarm = 0;
  1930.     }
  1931.   }
  1932.   if (audioalarm == 0) {
  1933.     soundalarm = 0;
  1934.   }
  1935.  
  1936.   if ((alarm_active != 0) && (soundalarm == 1)) {
  1937.     digitalWrite (alarmrelay, LOW);
  1938.     tone(11, 1000);
  1939.   } else {
  1940.     digitalWrite (alarmrelay, HIGH);
  1941.     soundalarm = 0;
  1942.     noTone(11);
  1943.   }
  1944. }
  1945.  
  1946. void clockset() {
  1947.   if (clock_update == 1) {
  1948.     clock.fillByYMD(set_year, set_month, set_day); //Jan 19,2013
  1949.     clock.fillByHMS(set_hour, set_minute, 30); //15:28 30"
  1950.     clock.fillDayOfWeek(SAT);//Saturday
  1951.     clock.setTime();//write time to the RTC chip
  1952.     clock_update = 0;
  1953.   }
  1954. }
  1955.  
  1956.  
  1957. void tunerDisableScreen() {
  1958.   while (escape == 0) {
  1959.     checkeditbutton();
  1960.     buttons(21);
  1961.     if (tunerDisable > 1) {
  1962.       tunerDisable = 0;
  1963.     }
  1964.     if (tunerDisable < 0) {
  1965.       tunerDisable = 1;
  1966.     }
  1967.  
  1968.     lcd.setCursor(3, 0);
  1969.     lcd.print (F("turner off/on"));
  1970.     lcd.setCursor(1, 1);
  1971.     lcd.print (F("on/off"));
  1972.  
  1973.     lcd.setCursor(12, 1);
  1974.     if (tunerDisable == 0) {
  1975.       lcd.print (F("off"));
  1976.     }
  1977.     else {
  1978.       lcd.print (F("on"));
  1979.       addSpace(1);
  1980.     }
  1981.     lcd.setCursor(0, 3);
  1982.     lcd.print(standardText[1]);
  1983.   }
  1984.   memory_update = 1;
  1985.   lcd.clear();
  1986.   editMode = editMode - 1;
  1987. }
  1988. void setTimeBetweenTurns() {
  1989.   while (escape == 0) {
  1990.     checkeditbutton();
  1991.     buttons(18);
  1992.     lcd.setCursor(1, 0);
  1993.     lcd.print (F("time between turns"));
  1994.     lcd.setCursor(0, 1);
  1995.     lcd.print (F("set in hours :"));
  1996.     addSpace(1);
  1997.     lcd.print (TimeBetweenTurns);
  1998.     lcd.setCursor(0, 3);
  1999.     lcd.print(standardText[1]);
  2000.     memory_update = 1;
  2001.   }
  2002.   editMode = editMode - 1;
  2003. }
  2004. void setturnerAlarm() {
  2005.   while (escape == 0) {
  2006.     if (tunerDisable == 0) {
  2007.       lcd.setCursor(3, 0);
  2008.       lcd.print (F("turner is disabled"));
  2009.       delay(3000);
  2010.       turnerAlarm = 0;
  2011.       escape = 1;
  2012.       editMode = editMode - 1;
  2013.     }
  2014.     checkeditbutton();
  2015.     buttons(20);
  2016.     lcd.setCursor(3, 0);
  2017.     lcd.print (F("turner off/on"));
  2018.     lcd.setCursor(1, 1);
  2019.     lcd.print (F("on/off"));
  2020.  
  2021.     lcd.setCursor(12, 1);
  2022.     if (turnerAlarm == 0) {
  2023.       lcd.print (F("off"));
  2024.     }
  2025.     else {
  2026.       lcd.print (F("on"));
  2027.       addSpace(1);
  2028.     }
  2029.     lcd.setCursor(0, 3);
  2030.     lcd.print(standardText[1]);
  2031.     memory_update = 1;
  2032.   }
  2033.   lcd.clear();
  2034.   editMode = editMode - 1;
  2035. }
  2036. void turnercontrols() {
  2037.   turnerstop = digitalRead(turnerinput);
  2038.   turnerEstop = digitalRead(overrun);
  2039.  
  2040.   timeBetweenTurnsSeconds = TimeBetweenTurns * 3600L;
  2041.   turn_timer = timeBetweenTurnsSeconds - secondTurnercounter;
  2042.   countdown = turn_timer;
  2043.   turn_timer = turn_timer / 60;
  2044.  
  2045.   if (tunerDisable == 1) {
  2046.     switch (turnerType) {
  2047.       case 1:
  2048.         //always running
  2049.         digitalWrite (turnerrelay1, LOW);
  2050.         display_stat_turn = 3;
  2051.         break;
  2052.       case 2://same as case 3
  2053.       case 3://cam signal input used on case 3
  2054.         timeBetweenTurnsSeconds = TimeBetweenTurns * 3600L;
  2055.         turn_timer = timeBetweenTurnsSeconds - secondTurnercounter;
  2056.         countdown = turn_timer;
  2057.         turn_timer = turn_timer / 60;
  2058.         if ((secondTurnercounter >= timeBetweenTurnsSeconds) || (testTurner == 1)) { //time to turn
  2059.           if (turnerRunCounter <= TimeTurnerTurns) {//turn for this time
  2060.             digitalWrite (turnerrelay1, LOW);
  2061.             display_stat_turn = 3;
  2062.           } else {//done turning
  2063.             if ((turnerstop == 0) || (turnerType == 2)) {
  2064.               digitalWrite (turnerrelay1, HIGH);//high is off
  2065.               secondTurnercounter = 0;//reset time to turn
  2066.               testTurner = 0;
  2067.             }
  2068.           }
  2069.         } else {//not time to turn prime turn for this time
  2070.           turnerRunCounter = 0;
  2071.           display_stat_turn = 2;
  2072.         }
  2073.         break;
  2074.       case 4:
  2075.         //reversing tilt
  2076.         if (turnerEstop == 1) {
  2077.           timeBetweenTurnsSeconds = TimeBetweenTurns * 3600L;
  2078.           turn_timer = timeBetweenTurnsSeconds - secondTurnercounter;
  2079.           countdown = turn_timer;
  2080.           turn_timer = turn_timer / 60;
  2081.           if ((secondTurnercounter >= timeBetweenTurnsSeconds) || (testTurner == 1)) { //time to turn
  2082.             tilt = !tilt;
  2083.             onetime = 1;
  2084.             display_stat_turn = 3;
  2085.             secondTurnercounter = 0;//reset time to turn
  2086.             testTurner = 0;
  2087.           } else {
  2088.             turnerRunCounter = 0;
  2089.             display_stat_turn = 2;
  2090.           }
  2091.           if ((tilt == 1) && ((turnerstop == 1) || (onetime == 1))) {
  2092.             digitalWrite (turnerrelay1, LOW);
  2093.             digitalWrite (turnerrelay2, HIGH);
  2094.             display_stat_turn = 3;
  2095.           } if ((tilt == 0) && ((turnerstop == 1) || (onetime == 1))) {
  2096.             digitalWrite (turnerrelay1, HIGH);
  2097.             digitalWrite (turnerrelay2, LOW);
  2098.             display_stat_turn = 3;
  2099.           }
  2100.           if (prevturnerstop != turnerstop) {
  2101.             onetime = 0;
  2102.             prevturnerstop = turnerstop;
  2103.           }
  2104.           if ((turnerstop == 0) && (onetime == 0)) {
  2105.             digitalWrite (turnerrelay1, HIGH);
  2106.             digitalWrite (turnerrelay2, HIGH);
  2107.             display_stat_turn = 2;
  2108.  
  2109.           }
  2110.  
  2111.         } else {     //if (turnerEstop == 1) {
  2112.           digitalWrite (turnerrelay1, HIGH);
  2113.           digitalWrite (turnerrelay2, HIGH);
  2114.           alarm_active = 8;
  2115.         }
  2116.         break;
  2117.  
  2118.       default :
  2119.         display_stat_turn = 1;
  2120.         break;
  2121.     }
  2122.   } else {
  2123.     // display_stat_turn = 1;
  2124.     digitalWrite (turnerrelay1, HIGH);
  2125.     digitalWrite (turnerrelay2, HIGH);
  2126.   }
  2127. }
  2128.  
  2129.  
  2130. void turntester() {
  2131.   while (escape == 0) {
  2132.     checkeditbutton();
  2133.     lcd.setCursor(5, 1);
  2134.     lcd.print (F("press enter"));
  2135.     lcd.setCursor(5, 2);
  2136.     lcd.print (F("to test"));
  2137.   }
  2138.   testTurner = 1;
  2139.   editMode = 0;
  2140. }
  2141. void timers() {
  2142.   unsigned long currentMillis = millis();//one second timers
  2143.   if (currentMillis - previousMillis > interval) {
  2144.     temp_timer++;//slow call to sensors
  2145.     secondTurnercounter++;//delay between turns
  2146.     turnerRunCounter++;
  2147.     previousMillis = currentMillis;
  2148.   }
  2149. }
  2150.  
  2151.  
  2152. void addSign() {
  2153.   if (tempinF == 0) {
  2154.     lcd.write(6);//6 is F sign
  2155.   }
  2156.   else {
  2157.     lcd.write(7);//7 is c sign
  2158.   }
  2159. }
  2160.  
  2161. void addSpace(int number) {
  2162.   for (int i = 1; i <= number; i++) {
  2163.     lcd.print(" ");
  2164.   }
  2165. }
  2166.  
  2167.  
  2168. //void showprint() {
  2169. // static unsigned long prevMillis1;
  2170. // unsigned long currentMillis1 = millis();
  2171. // if (currentMillis1 - prevMillis1 >= 500) {
  2172. //   Serial.print("tilt ");
  2173. //  Serial.println(tilt);
  2174. //  Serial.print("onetime ");
  2175. //  Serial.println(onetime);
  2176. //  Serial.print("testTurner ");
  2177. //  Serial.println(testTurner);
  2178. //  Serial.print("turnerstop ");
  2179. //  Serial.println(turnerstop);
  2180.  
  2181. //  prevMillis1 = currentMillis1;
  2182. // }
  2183. //}
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!