API tools faq
paste
Advertisement
Guest User

particle_dryer

a guest
Jul 11th, 2015
288
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 20.42 KB | None | 0 0
raw download clone embed print report
  1. // This #include statement was automatically added by the Spark IDE.
  2. #include "Adafruit_RGBLCDShield/Adafruit_RGBLCDShield.h"
  3. #include "Adafruit_RGBLCDShield/Adafruit_MCP23017.h"
  4. // This #include statement was automatically added by the Spark IDE.
  5. #include "PietteTech_DHT/PietteTech_DHT.h"
  6. #include "math.h"
  7.  
  8. // Uncomment whatever type you're using!
  9. #define DHTTYPE  DHT22       // Sensor type DHT11/21/22/AM2301/AM2302
  10.  
  11. //includes
  12. //define pins
  13. #define DHTPIN 3     // what pin we're connected to
  14. #define ON 0x7
  15. #define OFF 0x0
  16. //inititalize dht temp sensor and lcd shield
  17. void dht_wrapper(); // must be declared before the lib initialization
  18. // Lib instantiate
  19. PietteTech_DHT DHT(DHTPIN, DHTTYPE, dht_wrapper);
  20. Adafruit_RGBLCDShield lcd = Adafruit_RGBLCDShield();
  21. //initialize icons
  22. byte icons[3][7] = {{ 0x0, 0x4, 0x6, 0x1f, 0x6, 0x4, 0x0},
  23.   {0x0, 0xe, 0x15, 0x17, 0x11, 0xe, 0x0},
  24.   {0x4, 0xe, 0xe, 0x1e, 0x1b, 0xb, 0x6}
  25. };
  26. //! Index into the bitmap array for the  icons.
  27. const int ARROW_ICON_IDX = 0;
  28. const int CLOCK_ICON_IDX = 1;
  29. const int FLAME_ICON_IDX = 2;
  30.  
  31. //constants
  32. const long meas_interval = 3000;
  33. const int motorPin = 7;
  34. const int heaterPin = A5;
  35. const long heater_timeout_interval = 120000; //2 minute lockout
  36. const long time_interval = 3000; //check how much time left every 3 seconds
  37. const long temp_interval = 3000; //check what to set temp to every 3 seconds
  38.  
  39. //variables
  40. uint8_t clicked_buttons;
  41. int menu = 0;
  42. unsigned long previous_print_millis;
  43. const unsigned long printInterval = 3000;
  44. unsigned long heater_last_used_millis;
  45. int motorState = LOW;
  46. int heaterState = LOW;
  47. boolean heater_timeout = false;
  48. unsigned long previous_meas_millis = 0;
  49. String currentMode;
  50. unsigned long previous_time_millis = 0;
  51. unsigned long previous_temp_millis = 0;
  52. float inside_temp;
  53. float inside_moisture;
  54. int time_remaining = 60;
  55. int temp_setpoint = 101;
  56. unsigned long currentMillis;
  57. unsigned long cooldown_start_millis = 0;
  58. unsigned long cooldown_interval = 300000;
  59.  
  60. //button variables
  61. int buttonPin = 6;         // the number of the input pin
  62. int reading;           // the current reading from the input pin
  63. int buttonPrevious = LOW;
  64.  
  65. //variables and constants for moving average of moisture
  66. const int numReadings = 10;
  67. int readings[numReadings];      // the readings from the analog input
  68. int reading_idx = 0;                  // the index of the current reading
  69. int total = 0;                  // the running total
  70. int average_moisture = 0;                // the average
  71.  
  72. //variables for time and temp selections
  73. String run_selected;
  74. String temp_selected;
  75. String time_selected;
  76. int run_type = 0;
  77. int prev_time_remaining = 0;
  78. unsigned long previous_run_millis = 0;
  79. unsigned long time_elapsed = 0;
  80.  
  81.  
  82. /*--- *****setup****** ---*/
  83. void setup() {
  84.   Serial.begin(9600);
  85.   lcd.begin(16, 2);
  86.   lcd.createChar(ARROW_ICON_IDX, icons[ARROW_ICON_IDX]);
  87.   lcd.createChar(CLOCK_ICON_IDX, icons[CLOCK_ICON_IDX]);
  88.   lcd.createChar(FLAME_ICON_IDX, icons[FLAME_ICON_IDX]);
  89.   pinMode(motorPin, OUTPUT);
  90.   pinMode(heaterPin, OUTPUT);
  91.   pinMode(buttonPin, INPUT);
  92.   //dht.begin();
  93.   for (int thisReading = 0; thisReading < numReadings; thisReading++) //initialize counter for moving average of moisture
  94.     readings[thisReading] = 0;
  95.   lcd.setCursor(0, 0);
  96.   lcd.write(FLAME_ICON_IDX);
  97.   lcd.write(CLOCK_ICON_IDX);
  98.   lcd.print(" Welcome to ");
  99.   lcd.write(CLOCK_ICON_IDX);
  100.   lcd.write(FLAME_ICON_IDX);
  101.   lcd.setCursor(2, 1);
  102.   lcd.print("Dryerbot9000");
  103.   delay(2000);
  104.   lcd.clear();
  105.   menu_fun();
  106. }
  107.  
  108. void dht_wrapper() {
  109.     DHT.isrCallback();
  110. }
  111. float read_inside_temp() {
  112.   //float t = dht.readTemperature();
  113.   // Read temperature as farenheit
  114.   inside_temp = DHT.getFahrenheit();
  115.   // Check if any reads failed and exit early (to try again).
  116.   if (isnan(inside_temp)) {
  117.     //lcd.print("Failed to read from DHT sensor!");
  118.     Serial.println("Failed to read from DHT sensor!");
  119.   }
  120.   return inside_temp; //?? this was commented out, why?
  121. }
  122.  
  123. float read_inside_moisture() {
  124.   inside_moisture = DHT.getHumidity();
  125.   if (isnan(inside_moisture)) {
  126.     //lcd.print("Failed to read from DHT sensor!");
  127.     Serial.println("Failed to read from DHT sensor!");
  128.   }
  129.   return inside_moisture;
  130. }
  131.  
  132.  
  133. int auto_heat() {
  134.   if (average_moisture >= 52) {
  135.     temp_setpoint = 160;
  136.   }
  137.  
  138.   else if ( average_moisture < 52 && average_moisture >= 50) {
  139.     temp_setpoint = 150;
  140.   }
  141.   else if (average_moisture < 50 && average_moisture >= 47) {
  142.     temp_setpoint = 140;
  143.   }
  144.   else if (average_moisture < 47 && average_moisture >= 44) {
  145.     temp_setpoint = 130;
  146.   }
  147.   else if (average_moisture < 44 && average_moisture >= 41) {
  148.     temp_setpoint = 120;
  149.   }
  150.   else if (average_moisture < 41 && average_moisture >= 38) {
  151.     temp_setpoint = 110;
  152.   }
  153.   else if (average_moisture < 38 && average_moisture >= 35) {
  154.     temp_setpoint = 100;
  155.   }
  156.   else if (average_moisture < 35) {
  157.     temp_setpoint = 0;
  158.   }
  159.   else {
  160.     temp_setpoint = 0;
  161.   }
  162.   return temp_setpoint;
  163. }
  164.  
  165. int auto_time() {
  166.  
  167.   if (average_moisture >= 53) {
  168.     time_remaining = 60;
  169.   }
  170.   else if (average_moisture < 53 && average_moisture >= 50) {
  171.     time_remaining = 50;
  172.   }
  173.   else if (average_moisture < 50 && average_moisture >= 47) {
  174.     time_remaining = 40;
  175.   }
  176.   else if (average_moisture < 47 && average_moisture >= 44) {
  177.     time_remaining = 30;
  178.   }
  179.  
  180.   else if (average_moisture < 44 && average_moisture >= 41) {
  181.     time_remaining = 20;
  182.   }
  183.  
  184.   else if (average_moisture < 41 && average_moisture >= 38) {
  185.     time_remaining = 10;
  186.   }
  187.  
  188.   else if (average_moisture < 38 && average_moisture >= 35) {
  189.     time_remaining = 5;
  190.   }
  191.  
  192.   else if (average_moisture < 35) {
  193.     time_remaining = 0;
  194.   }
  195.  
  196.   else {
  197.     time_remaining = 60;
  198.   }
  199.  
  200.   return time_remaining;
  201. }
  202.  
  203. boolean heater_timeout_check() {
  204.   //heaterState = digitalRead(heaterPin);
  205.   if (heaterState == HIGH) {
  206.     heater_last_used_millis = currentMillis;
  207.     heater_timeout = false;
  208.   }
  209.  
  210.   else if (heaterState == LOW && (currentMillis - heater_last_used_millis >= heater_timeout_interval)) {
  211.     heater_timeout = false;
  212.   }
  213.   else {
  214.     heater_timeout = true;
  215.   }
  216.   return heater_timeout;
  217. }
  218.  
  219.  
  220. String run_mode() {
  221.   //digitalWrite(motorPin, HIGH);
  222.   cooldown_start_millis = currentMillis;
  223.   if (time_selected == "auto" && temp_selected == "auto") {
  224.     run_type = 0;
  225.   }
  226.   else if (time_selected == "auto" && temp_selected.toInt() > 0) {
  227.     temp_setpoint = temp_selected.toInt();
  228.     run_type = 1;
  229.   }
  230.   else if (time_selected.toInt() > 0 && temp_selected == "auto") {
  231.     prev_time_remaining = time_selected.toInt(); //convert to number
  232.     run_type = 2;
  233.   }
  234.   else if (time_selected.toInt() > 0 && temp_selected.toInt() > 0) {
  235.     prev_time_remaining = time_selected.toInt(); //convert to number
  236.     temp_setpoint = temp_selected.toInt();
  237.     run_type = 3;
  238.   }
  239.   else {
  240.     run_type = 0;
  241.   }
  242.  
  243.  
  244.   switch (run_type) {
  245.     case 0: //auto time auto heat
  246.       if (currentMillis - previous_time_millis >= time_interval) {
  247.         previous_time_millis = currentMillis;
  248.         auto_time();
  249.       }
  250.       if (currentMillis - previous_temp_millis >= temp_interval) {
  251.         previous_temp_millis = currentMillis;
  252.         auto_heat();
  253.       }
  254.       break;
  255.  
  256.     case 1:  //auto time set heat
  257.       if (currentMillis - previous_time_millis >= time_interval) {
  258.         previous_time_millis = currentMillis;
  259.         auto_time();
  260.       }
  261.       break;
  262.  
  263.     case 2: //set time auto heat
  264.       if (currentMillis - previous_temp_millis >= temp_interval) {
  265.         previous_temp_millis = currentMillis;
  266.         auto_heat();
  267.       }
  268.  
  269.       time_remaining = prev_time_remaining - ((currentMillis - previous_run_millis) * 60000);
  270.       previous_run_millis = currentMillis;
  271.       break;
  272.  
  273.     case 3: //set time set heat
  274.       time_remaining = prev_time_remaining - ((currentMillis - previous_run_millis) * 60000);
  275.       previous_run_millis = currentMillis;
  276.       break;
  277.   }
  278.  
  279.  
  280.  
  281.  
  282.   motorState = HIGH;
  283.   heater_timeout_check();
  284.   //motorState = digitalRead(motorPin);
  285.   if (inside_temp <= temp_setpoint && heater_timeout == false) {
  286.     //digitalWrite(heaterPin, HIGH);
  287.     heaterState = HIGH;
  288.   }
  289.   else {
  290.     //digitalWrite(heaterPin, LOW);
  291.     heaterState = LOW;
  292.   }
  293.   currentMode = "run_mode";
  294.   //}
  295.   //else {
  296.   // cooldown_mode();
  297.   // }
  298.   return currentMode;
  299. }
  300.  
  301. String cooldown_mode() {
  302.   //if (currentMillis - cooldown_start_millis <= cooldown_interval) {
  303.   // digitalWrite(motorPin, HIGH);
  304.   // digitalWrite(heaterPin,LOW);
  305.  
  306.   motorState = HIGH;
  307.   heaterState = LOW;
  308.   currentMode = "cooldown_mode";
  309.   // }
  310.   //else if (temp_setpoint != 0 && time_remaining != 0) {
  311.   // run_mode();
  312.   //}
  313.  
  314.   // else {
  315.   //  stop_mode();
  316.   //}
  317.   return currentMode;
  318. }
  319.  
  320. String stop_mode() {
  321.   // digitalWrite(heaterPin, LOW);
  322.   //digitalWrite(motorPin, LOW);
  323.   //cooldown_start_millis = currentMillis;
  324.  
  325.   heaterState = LOW;
  326.   motorState = LOW;
  327.   time_remaining = 0;
  328.   temp_setpoint = 0;
  329.   currentMode = "stop_mode";
  330.   return currentMode;
  331. }
  332.  
  333. void read_button_clicks() {
  334.   static uint8_t last_buttons = 0;
  335.   uint8_t buttons = lcd.readButtons();
  336.   clicked_buttons = (last_buttons ^ buttons) & (~buttons);
  337.   last_buttons = buttons;
  338.   /*if (clicked_buttons) {
  339.     menu_fun();
  340.   }*/
  341.  
  342. }
  343. int prev_menu=-1;
  344.  
  345. int menu_fun() {
  346.   if (clicked_buttons & BUTTON_RIGHT) {
  347.     menu++;
  348.   }
  349.   if (clicked_buttons & BUTTON_LEFT) {
  350.     menu--;
  351.   }
  352.   if (menu > 2 && menu < 100) {
  353.     menu = 0;
  354.   }
  355.   if (menu < 0) {
  356.     menu = 2;
  357.   }
  358.   if (menu > 106 && menu < 200) {
  359.     menu = 101;
  360.   }
  361.   if (menu < 101 && menu > 99) {
  362.     menu = 106;
  363.   }
  364.   if (menu > 205 && menu < 300) {
  365.     menu = 201;
  366.   }
  367.   if (menu < 201 && menu > 199) {
  368.     menu = 205;
  369.   }
  370.   switch (menu) {
  371.     case 0: //time
  372.       //lcd.clear();
  373.       lcd.setCursor(0,0);
  374.       lcd.write(ARROW_ICON_IDX);
  375.       lcd.print("time ");
  376.       lcd.print("heat         ");
  377.       //if (time_selected && temp_selected){
  378.       lcd.setCursor(0,1);
  379.       lcd.print("time:");
  380.       lcd.print(time_selected);
  381.       lcd.print(" temp:");
  382.       lcd.print(temp_selected);//}
  383.       if (clicked_buttons & (BUTTON_SELECT | BUTTON_DOWN)) {
  384.         lcd.clear();
  385.         menu=101;
  386.       }
  387.       break;
  388.     case 1: //heat
  389.     lcd.setCursor(0,0);
  390.       lcd.print(" time");
  391.       lcd.write(ARROW_ICON_IDX);
  392.       lcd.print("heat        ");
  393.       //if (time_selected && temp_selected){
  394.       lcd.setCursor(0,1);
  395.       lcd.print("time:");
  396.       lcd.print(time_selected);
  397.       lcd.print(" temp:");
  398.       lcd.print(temp_selected);//}
  399.       if (clicked_buttons & (BUTTON_SELECT | BUTTON_DOWN)) {
  400.         lcd.clear();
  401.         menu = 201;
  402.       }
  403.       //prev_menu = 1;
  404.       break;
  405.     case 101: //time auto
  406.       lcd.setCursor(0,0);
  407.       lcd.write(CLOCK_ICON_IDX);
  408.       lcd.print("time           ");
  409.       lcd.setCursor(0, 1);
  410.       lcd.write(ARROW_ICON_IDX);
  411.       lcd.print("Auto 90 60 45 30 15");
  412.      
  413.       if (clicked_buttons & BUTTON_UP) {
  414.         lcd.clear();
  415.         menu = 0;
  416.       }
  417.       if (clicked_buttons & BUTTON_SELECT) {
  418.         time_selected = "auto";
  419.         lcd.clear();
  420.         lcd.print("Auto Time");
  421.         delay(1000);
  422.         lcd.clear();
  423.         menu =1;
  424.       }
  425.       break;
  426.     case 102: //time 90
  427.       lcd.setCursor(0,0);
  428.       lcd.write(CLOCK_ICON_IDX);
  429.       lcd.print("time           ");
  430.       lcd.setCursor(0, 1);
  431.       lcd.print(" Auto");
  432.       lcd.write(ARROW_ICON_IDX);
  433.       lcd.print("90 60 45 30 15");
  434.       if (clicked_buttons & BUTTON_UP) {
  435.         lcd.clear();
  436.         menu = 0;
  437.       }
  438.       if (clicked_buttons & BUTTON_SELECT) {
  439.         time_selected = "90";
  440.         lcd.clear();
  441.         lcd.print("90 Minutes");
  442.         delay(1000);
  443.         lcd.clear();
  444.         menu =1;
  445.       }
  446.       break;
  447.     case 103: //time 60
  448.       lcd.setCursor(0,0);
  449.       lcd.write(CLOCK_ICON_IDX);
  450.       lcd.print("time           ");
  451.       lcd.setCursor(0, 1);
  452.       lcd.print(" Auto 90");
  453.       lcd.write(ARROW_ICON_IDX);
  454.       lcd.print("60 45 30 15");
  455.       if (clicked_buttons & BUTTON_UP) {
  456.         lcd.clear();
  457.         menu = 0;
  458.       }
  459.       if (clicked_buttons & BUTTON_SELECT) {
  460.         time_selected = "60";
  461.         lcd.clear();
  462.         lcd.print("60 Minutes");
  463.         delay(1000);
  464.         lcd.clear();
  465.         menu = 1;
  466.       }
  467.       break;
  468.     case 104: //time 45
  469.       lcd.setCursor(0,0);
  470.       lcd.write(CLOCK_ICON_IDX);
  471.       lcd.print("time           ");
  472.       lcd.setCursor(0, 1);
  473.       lcd.print(" Auto 90 60");
  474.       lcd.write(ARROW_ICON_IDX);
  475.       lcd.print("45 30 15");
  476.       if (clicked_buttons & BUTTON_UP) {
  477.         lcd.clear();
  478.         menu = 0;
  479.       }
  480.       if (clicked_buttons & BUTTON_SELECT) {
  481.         time_selected = "45";
  482.         lcd.clear();
  483.         lcd.print("45 Minutes");
  484.         delay(1000);
  485.         lcd.clear();
  486.         menu =1;
  487.       }
  488.       break;
  489.     case 105: //time30
  490.       lcd.setCursor(0,0);
  491.       lcd.write(CLOCK_ICON_IDX);
  492.       lcd.print("time           ");
  493.       lcd.setCursor(0, 1);
  494.       lcd.print("90 60 45");
  495.       lcd.write(ARROW_ICON_IDX);
  496.       lcd.print("30 15  ");
  497.       if (clicked_buttons & BUTTON_UP) {
  498.         lcd.clear();
  499.         menu = 0;
  500.       }
  501.       if (clicked_buttons & BUTTON_SELECT) {
  502.         time_selected = "30";
  503.         lcd.clear();
  504.         lcd.print("30 Minutes");
  505.         delay(1000);
  506.         lcd.clear();
  507.         menu =1;
  508.       }
  509.       break;
  510.     case 106:  //time 15
  511.       lcd.setCursor(0,0);
  512.       lcd.write(CLOCK_ICON_IDX);
  513.       lcd.print("time           ");
  514.       lcd.setCursor(0, 1);
  515.       lcd.print("90 60 45 30");
  516.       lcd.write(ARROW_ICON_IDX);
  517.       lcd.print("15  ");
  518.       if (clicked_buttons & BUTTON_UP) {
  519.         lcd.clear();
  520.         menu = 0;
  521.       }
  522.       if (clicked_buttons & BUTTON_SELECT) {
  523.         time_selected = "15";
  524.         lcd.clear();
  525.         lcd.print("15 Minutes");
  526.         delay(1000);
  527.         lcd.clear();
  528.         menu =1;
  529.       }
  530.       break;
  531.     case 201: //heat auto
  532.       lcd.setCursor(0,0);
  533.       lcd.write(FLAME_ICON_IDX);
  534.       lcd.print("heat           ");
  535.       lcd.setCursor(0, 1);
  536.       lcd.write(ARROW_ICON_IDX);
  537.       lcd.print("Auto Hi Med Low Off");
  538.       if (clicked_buttons & BUTTON_UP) {
  539.         lcd.clear();
  540.         menu = 0;
  541.       }
  542.       if (clicked_buttons & BUTTON_SELECT) {
  543.         temp_selected = "auto";
  544.         lcd.clear();
  545.         lcd.print("Auto heat");
  546.         delay(1000);
  547.         lcd.clear();
  548.         menu =0;
  549.       }
  550.  
  551.       break;
  552.     case 202:  //heat hi
  553.       lcd.setCursor(0,0);
  554.       lcd.write(FLAME_ICON_IDX);
  555.       lcd.print("heat           ");
  556.       lcd.setCursor(0, 1);
  557.       lcd.print(" Auto");
  558.       lcd.write(ARROW_ICON_IDX);
  559.       lcd.print("Hi Med Low Off");
  560.       if (clicked_buttons & BUTTON_UP) {
  561.         lcd.clear();
  562.         menu = 0;
  563.       }
  564.       if (clicked_buttons & BUTTON_SELECT) {
  565.         temp_selected = "150";
  566.         lcd.clear();
  567.         lcd.print("High heat");
  568.         delay(1000);
  569.         lcd.clear();
  570.         menu = 0;
  571.       }
  572.       break;
  573.     case 203: //heat med
  574.       lcd.setCursor(0,0);
  575.       lcd.write(FLAME_ICON_IDX);
  576.       lcd.print("heat           ");
  577.       lcd.setCursor(0, 1);
  578.       lcd.print(" Auto Hi");
  579.       lcd.write(ARROW_ICON_IDX);
  580.       lcd.print("Med Low Off");
  581.       if (clicked_buttons & BUTTON_UP) {
  582.         lcd.clear();
  583.         menu = 0;
  584.       }
  585.       if (clicked_buttons & BUTTON_SELECT) {
  586.         temp_selected = "130";
  587.         lcd.clear();
  588.         lcd.print("Medium heat");
  589.         delay(1000);
  590.         lcd.clear();
  591.         menu = 0;
  592.       }
  593.       break;
  594.     case 204:  //heat low
  595.       lcd.setCursor(0,0);
  596.       lcd.write(FLAME_ICON_IDX);
  597.       lcd.print("heat           ");
  598.       lcd.setCursor(0, 1);
  599.       lcd.print("Hi Med");
  600.       lcd.write(ARROW_ICON_IDX);
  601.       lcd.print("Low Off  ");
  602.       if (clicked_buttons & BUTTON_UP) {
  603.         lcd.clear();
  604.         menu = 0;
  605.       }
  606.       if (clicked_buttons & BUTTON_SELECT) {
  607.         temp_selected = "110";
  608.         lcd.clear();
  609.         lcd.print("Low heat");
  610.         delay(1000);
  611.         lcd.clear();
  612.         menu = 0;
  613.        
  614.       }
  615.       break;
  616.     case 205: //heat off
  617.       lcd.setCursor(0,0);
  618.       lcd.write(FLAME_ICON_IDX);
  619.       lcd.print("heat           ");
  620.       lcd.setCursor(0, 1);
  621.       lcd.print("Hi Med Low");
  622.       lcd.write(ARROW_ICON_IDX);
  623.       lcd.print("Off  ");
  624.       if (clicked_buttons & BUTTON_UP) {
  625.         lcd.clear();
  626.         menu = 0;
  627.       }
  628.       if (clicked_buttons & BUTTON_SELECT) {
  629.         temp_selected = "32";
  630.         lcd.clear();
  631.         lcd.print("Heat Off");
  632.         delay(1000);
  633.         lcd.clear();
  634.         menu = 0;
  635.       }
  636.       break;
  637.      
  638.     case 999: //display in run mode
  639.      lcd.setCursor(0,0);
  640.      lcd.write(CLOCK_ICON_IDX);
  641.       lcd.print(":");
  642.       lcd.print(time_remaining);
  643.       lcd.print(" dry:");
  644.       lcd.print(map(average_moisture,35,100,100,0));
  645.       lcd.print(" ");
  646.       lcd.print(currentMode);
  647.       //if (time_selected && temp_selected){
  648.       lcd.setCursor(0,1);
  649.       lcd.print("time:");
  650.       lcd.print(time_selected);
  651.       lcd.print(" temp:");
  652.       lcd.print(temp_selected);//}
  653.       if (clicked_buttons) {
  654.         lcd.clear();
  655.         menu=0;
  656.       }
  657.       break;
  658.   }
  659. }
  660.  
  661. /* --- ******* Loop ****** --- */
  662. void loop() {
  663.   delay(10);
  664.   lcd.setBacklight(ON);
  665.   read_button_clicks();
  666.   menu_fun();
  667.   currentMillis = millis();
  668.   digitalWrite(motorPin, motorState);
  669.   digitalWrite(heaterPin, heaterState);
  670.   reading = digitalRead(buttonPin);
  671.  
  672.   total = total - readings[reading_idx];
  673.  
  674.   if (currentMillis - previous_meas_millis >= meas_interval) {
  675.     previous_meas_millis = currentMillis;
  676.     DHT.acquire();//?? do I need this?
  677.     readings[reading_idx] = read_inside_moisture();
  678.     read_inside_temp();
  679.   }
  680.   total = total + readings[reading_idx];
  681.   reading_idx = reading_idx + 1;
  682.   if (reading_idx >= numReadings)
  683.     reading_idx = 0;
  684.   average_moisture = total / numReadings;
  685.  
  686.   //probably need to move these to the run function
  687.   //calculate time remaining
  688.   /*
  689.   if (currentMillis - previous_time_millis >= time_interval) {
  690.     previous_time_millis = currentMillis;
  691.     auto_time();
  692.  
  693.   }
  694.  
  695.   if (currentMillis - previous_temp_millis >= temp_interval) {
  696.     previous_temp_millis = currentMillis;
  697.     auto_heat();
  698.   }*/
  699.   //////////
  700.   if (reading == HIGH && time_remaining > 0 && temp_setpoint > 0) {
  701.     run_mode();
  702.   }
  703.   else if (reading == HIGH && (time_remaining == 0 || temp_setpoint == 0) && (currentMillis - cooldown_start_millis <= cooldown_interval)) {
  704.     cooldown_mode();
  705.   }
  706.  
  707.   else if (reading == HIGH && currentMode == "cooldown_mode" && (currentMillis - cooldown_start_millis > cooldown_interval)) {
  708.     stop_mode();
  709.   }
  710.  
  711.   else if (reading == LOW) {
  712.     cooldown_start_millis = currentMillis;
  713.     stop_mode();
  714.   }
  715.  
  716.   else {
  717.     stop_mode();
  718.   }
  719.  
  720.  
  721.  
  722.  
  723.   if (currentMillis - previous_print_millis >= printInterval) {
  724.     previous_print_millis = currentMillis;
  725.  
  726.     Serial.print("time=");
  727.     Serial.print(currentMillis / 1000);
  728.     Serial.print(", ");
  729.     Serial.print("currentMode=");
  730.     Serial.print(currentMode);
  731.     Serial.print(", ");
  732.     Serial.print("inside_temp=");
  733.     Serial.print(inside_temp);
  734.     Serial.print(", ");
  735.     Serial.print("inside_moisture=");
  736.     Serial.print(inside_moisture);
  737.     Serial.print(", average= ");
  738.     Serial.print(average_moisture);
  739.     Serial.print(", ");
  740.     Serial.print("time_remaining=");
  741.     Serial.print(time_remaining);
  742.     Serial.print(", ");
  743.     Serial.print("temp_setpoint=");
  744.     Serial.print(temp_setpoint);
  745.     Serial.print(", ");
  746.     Serial.print("heater on?=");
  747.     Serial.print(heaterState);
  748.     Serial.print(", ");
  749.     Serial.print("motor on?=");
  750.     Serial.print(motorState);
  751.     Serial.print(", ");
  752.     Serial.print("button pressed?=");
  753.     Serial.print(reading);
  754.     Serial.print(", ");
  755.     Serial.print("heater timeout?=");
  756.     Serial.print(heater_timeout);
  757.     Serial.print(", cooldown start=");
  758.     Serial.println(cooldown_start_millis / 1000);
  759.     /*
  760.     lcd.clear();
  761.       lcd.setCursor(0, 0);
  762.     lcd.print("tr=");
  763.     lcd.print(time_remaining);
  764.     lcd.print(" ");
  765.     lcd.print("h=");
  766.     lcd.print(heaterState);
  767.     lcd.print("ts=");
  768.     lcd.print(temp_setpoint);
  769.         lcd.setCursor(0, 1);
  770.     lcd.print("temp=");
  771.     lcd.print(inside_temp);
  772.     lcd.print(" ");
  773.     lcd.print("moist=");
  774.     lcd.print(inside_moisture);
  775.     */
  776.   }
  777.  
  778. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!