debugging and all good

README.md

@@ -0,0 +1,7 @@
+
+## TODO
+
+* check the ai suggestion
+* time after completion is not displayed
+* eeprom saving every 5 minutes and resuming
+* profile selection

hot_fermentation.ino

@@ -1,7 +1,8 @@
 #include <max6675.h>
 #include <Wire.h>
 #include <PID_v1.h>
-#include <GyverOLED.h>  // Include the GyverOLED library
+#include <GyverOLED.h>
+#include "GyverEncoder.h"  // Include the GyverEncoder library
 
 // MAX6675 configuration
 int max_SO = 12;
@@ -12,6 +13,12 @@ MAX6675 thermocouple(max_SCK, max_CS, max_SO);
 // OLED configuration
 GyverOLED<SSD1306_128x64> oled;
 
+// Encoder configuration
+#define CLK 5
+#define DT 6
+#define SW 7
+Encoder enc1(CLK, DT, SW, TYPE2);
+
 // SSR pin configuration
 const int ssrPin = 7;
 
@@ -23,21 +30,28 @@ struct Phase {
 
 struct Profile {
   const char* name;
+  int transitionMinutesPerDegree;
   Phase phases[6]; // Maximum of 6 phases per profile
   int numPhases;
 };
 
 // Profiles definition
 Profile profiles[] = {
-  {"Test", {{49, 1}, {51, 1}, {55, 1}, {45, 1}}, 4},
+  {"Test", 0, {{49, 1}, {51, 1}}, 2},
-  {"Пшеница", {{47, 40}, {55, 40}, {65, 20}, {72, 20}, {85, 20}}, 5},
+  {"Пшеница", 1, {{47, 40}, {55, 40}, {65, 20}, {72, 20}, {85, 20}}, 5},
-  {"Veggies Sous Vide", {{85, 120}}, 1},
+  {"Veggies Sous Vide", 0, {{85, 120}}, 1},
-  {"Фитаза/Протеаза", {{47, 120}, {53, 120}, {65, 150}, {72, 60}, {90, 105}, {50, 60}}, 6},
+  {"Фитаза/Протеаза", 2, {{47, 120}, {53, 120}, {65, 150}, {72, 60}, {90, 105}, {50, 60}}, 6},
 };
 
-// Select active profile (constant at this point)
+// Global variables for profile selection and execution
-const int activeProfileIndex = 0;  // Index of the active profile, starting from 0
+int activeProfileIndex = 100;  // 100 indicates no profile selected yet
-Profile activeProfile = profiles[activeProfileIndex];
+int selectedProfileIndex = 0;  // Index of the currently selected profile in the selection mode
+Profile activeProfile;         // The active profile once selected
+
+// Global variables for current phase, setpoint, and transition state
+int currentPhase;
+bool isInTransition = false;
+bool inSelectionMode = true;
 
 // PID Control variables
 double Setpoint, Input, Output;
@@ -50,6 +64,8 @@ unsigned long totalStartTime;
 unsigned long ssrLastSwitchTime;
 unsigned long totalElapsedTime;
 unsigned long totalProcessTime;
+unsigned long finishTime = 0;
+bool isComplete = false;
 const int ssrSwitchInterval = 1000;  // SSR switching interval in milliseconds
 
 // Buffer for formatted time strings
@@ -60,25 +76,21 @@ void setup() {
   Serial.begin(9600);
   oled.init();          // Initialize the OLED
   oled.clear();         // Clear the display
-  oled.setScale(2);     // Set text scale to 2 for better visibility
+  displaySelection();
-  oled.print("Starting...");
-  oled.update();
-  oled.setScale(1);     // Set text scale back to 1 for more detailed information
-
-  // Begin the first phase
-  phaseStartTime = totalStartTime = millis();
-  Setpoint = activeProfile.phases[0].temperature;
-  myPID.SetMode(AUTOMATIC);
-  myPID.SetOutputLimits(0, 1);  // SSR is either ON or OFF
-  digitalWrite(ssrPin, HIGH); // Start with heater on
-  ssrLastSwitchTime = millis();
 }
 
 void loop() {
-  static int currentPhase = 0;
+  enc1.tick();  // Mandatory encoder update function
-  Input = (int) thermocouple.readCelsius(); // Cast to integer for display and control
-  unsigned long currentTime = millis();
 
+  if (inSelectionMode) {
+    handleProfileSelection();  // Handle profile selection mode
+  } else {
+    unsigned long currentTime = millis();
+    totalElapsedTime = (currentTime - totalStartTime) / 1000; // Total elapsed time in seconds
+
+    getPhaseAndTemperature(totalElapsedTime);
+
+    Input = (int) thermocouple.readCelsius(); // Cast to integer for display and control
     myPID.Compute();
 
     // Switch SSR based on PID output and interval control
@@ -87,40 +99,140 @@ void loop() {
       ssrLastSwitchTime = currentTime;
     }
 
-  // Display time calculations
+    if (isComplete && currentPhase >= activeProfile.numPhases) {
-  totalElapsedTime = (currentTime - totalStartTime) / 1000; // Total elapsed time in seconds
+      finishTime = currentTime;
-  totalProcessTime = 0;
-  for (int i = 0; i < activeProfile.numPhases; i++) {
-    totalProcessTime += activeProfile.phases[i].duration * 60;
     }
 
-  // Check if the phase duration is complete
-  if ((unsigned long)((currentTime - phaseStartTime) / 1000) >= (unsigned long)activeProfile.phases[currentPhase].duration * 60) {
-    currentPhase++;
-    if (currentPhase >= activeProfile.numPhases) {
-      oled.clear();
-      oled.print("Complete");
-      digitalWrite(ssrPin, LOW); // Turn off the heater
-      return; // Stop further execution
-    }
-    phaseStartTime = currentTime; // Reset the start time for the new phase
-    Setpoint = activeProfile.phases[currentPhase].temperature;
-  }
-
-
     // Display all phases and highlight the current one
-  printPhases(currentPhase, currentTime - phaseStartTime);
+    printPhases(currentPhase, currentTime - phaseStartTime, currentTime);
 
     oled.update();
 
     delay(1000); // Update every second
+  }
 }
 
-void printPhases(int currentPhase, unsigned long phaseElapsedTime) {
+void handleProfileSelection() {
+
+  bool click = enc1.isClick();
+  bool turn = enc1.isTurn();
+  if (!click && !turn) {
+    return;
+  }
+
+  // Handle encoder input for selecting the profile
+  if (enc1.isRight()) {
+    selectedProfileIndex = (selectedProfileIndex + 1) % (sizeof(profiles) / sizeof(profiles[0]));
+  } else if (enc1.isLeft()) {
+    selectedProfileIndex = (selectedProfileIndex - 1 + (sizeof(profiles) / sizeof(profiles[0]))) % (sizeof(profiles) / sizeof(profiles[0]));
+  }
+
+  displaySelection();
+
+  // Start the selected profile on button press
+  if (click) {
+    activeProfileIndex = selectedProfileIndex;
+    activeProfile = profiles[activeProfileIndex];
+    calculateTotalTime();
+    inSelectionMode = false;  // Switch to execution mode
+    phaseStartTime = totalStartTime = millis();  // Start the timer
+    myPID.SetMode(AUTOMATIC);
+    myPID.SetOutputLimits(0, 1);  // SSR is either ON or OFF
+    digitalWrite(ssrPin, HIGH);   // Start with heater on
+    ssrLastSwitchTime = millis();
+  }
+}
+
+void displaySelection() {
+  oled.clear();
+  // Display all profiles with the selected one highlighted
+  for (int i = 0; i < (int) (sizeof(profiles) / sizeof(profiles[0])); i++) {
+    if (i == selectedProfileIndex) {
+      oled.invertText(true);  // Highlight the selected profile
+    }
+
+    oled.setCursor(0, i);  // Set cursor to the correct row
+    oled.print(profiles[i].name);
+
+    oled.invertText(false);  // Reset text inversion for other profiles
+  }
+  oled.update();
+}
+
+void calculateTotalTime() {
+ // Calculate total process time, including transitions
+  totalProcessTime = 0;
+  for (int i = 0; i < activeProfile.numPhases; i++) {
+    totalProcessTime += activeProfile.phases[i].duration * 60;
+    if (i < activeProfile.numPhases - 1) {
+      int tempDiff = abs(activeProfile.phases[i + 1].temperature - activeProfile.phases[i].temperature);
+      totalProcessTime += tempDiff * 60 * activeProfile.transitionMinutesPerDegree;
+    }
+  }
+}
+
+void getPhaseAndTemperature(unsigned long elapsedSeconds) {
+  unsigned long accumulatedTime = 0;
+
+  for (int i = 0; i < activeProfile.numPhases; i++) {
+    int phaseDuration = activeProfile.phases[i].duration * 60;
+
+    // Check for transition
+    if (i > 0) {
+      int previousTemp = activeProfile.phases[i - 1].temperature;
+      int targetTemp = activeProfile.phases[i].temperature;
+      int tempDiff = abs(targetTemp - previousTemp);
+      int transitionDuration = tempDiff * 60 * activeProfile.transitionMinutesPerDegree;
+
+      if (elapsedSeconds < accumulatedTime + transitionDuration) {
+        isInTransition = true;
+        currentPhase = i - 1;  // Keep currentPhase as the previous phase
+        int timeInTransition = elapsedSeconds - accumulatedTime;
+        Setpoint = previousTemp + (double)timeInTransition / (60 * activeProfile.transitionMinutesPerDegree) * (targetTemp > previousTemp ? 1 : -1);
+        return;
+      }
+
+      accumulatedTime += transitionDuration;
+    }
+
+    // Check if we're within the current phase
+    if (elapsedSeconds < accumulatedTime + phaseDuration) {
+      isInTransition = false;
+      currentPhase = i;
+      Setpoint = activeProfile.phases[i].temperature;
+      return;
+    }
+
+    accumulatedTime += phaseDuration;
+  }
+
+  // If the elapsed time exceeds the total duration, indicate completion
+  currentPhase = activeProfile.numPhases;  // Indicate completion
+  Setpoint = 45;  // Default to 45°C after completion
+  isInTransition = false;
+  isComplete = true;  // Mark the process as complete
+}
+
+void printPhases(int currentPhase, unsigned long phaseElapsedTime, unsigned long currentTime) {
   oled.clear();
 
+  if (isComplete) {
+    // Show completion time and current temperature instead of the title
+    oled.setCursor(0, 0);
+    oled.invertText(true);
+    oled.print("Done!");
+    oled.invertText(false);
+    oled.print(" ");
+    formatTime((currentTime - finishTime) / 1000, timeBuffer); // Time since completion
+    oled.print(timeBuffer);
+    oled.print(" ");
+    oled.print((int)Input);
+    oled.print("c");
+  } else {
     oled.setCursor(0, 0);
     oled.print(activeProfile.name);
+  }
+
   // Display the totals and current state on the OLED
   oled.setCursor(18, 1);
   formatTime(totalElapsedTime, timeBuffer);
@@ -130,7 +242,7 @@ void printPhases(int currentPhase, unsigned long phaseElapsedTime) {
   oled.print(timeBuffer);
 
   for (int i = 0; i < activeProfile.numPhases; i++) {
-    if (i == currentPhase) {
+    if (i == currentPhase && !isComplete) {
       oled.invertText(true);  // Invert text for the current phase
 
       oled.setCursor(0, i + 2);  // Set cursor to the row corresponding to the phase
@@ -140,7 +252,11 @@ void printPhases(int currentPhase, unsigned long phaseElapsedTime) {
       oled.print(". ");
       oled.print((int)Input);
       oled.print("c ");
-      oled.print((int)Setpoint);
+      if (fabs(Setpoint - round(Setpoint)) < 0.05) {
+          oled.print((int)Setpoint);  // Print without decimals
+      } else {
+          oled.print(Setpoint, 1);    // Print with 1 decimal place
+      }
       oled.print("c ");
       oled.print(timeBuffer);
     } else {