hot-fermentation/hot_fermentation.ino

#define useEEPROM 1

#include <max6675.h>
#include <Wire.h>
#include <PID_v1.h>
#include <GyverOLED.h>
#include "GyverEncoder.h"

#if useEEPROM
#include <EEPROM.h>
#endif

// MAX6675 configuration
int max_SO = 12;
int max_CS = 10;
int max_SCK = 13;
MAX6675 thermocouple(max_SCK, max_CS, max_SO);

// OLED configuration
// GyverOLED<SSD1306_128x64> oled;
GyverOLED<SSD1306_128x64, OLED_NO_BUFFER> oled;

// Encoder configuration
#define CLK 5
#define DT 6
#define SW 7
Encoder enc1(CLK, DT, SW, TYPE2);

// SSR pin configuration
const int ssrPin = 2;

// Profile structure definition
struct Phase {
  int temperature;
  int duration; // in minutes
};

struct Profile {
  const char* name;
  int transitionMinutesPerDegree;
  Phase phases[6]; // Maximum of 6 phases per profile
  int numPhases;
};

// Profiles definition
Profile profiles[] = {
  {"Chickpeas", 3, {{47, 120}, {53, 120}, {65, 180}, {72, 90}, {90, 90}}, 5},
  {"Lentils", 3, {{47, 120}, {53, 120}, {65, 180}, {72, 90}, {90, 15}}, 5},
  {"Lentils gradual", 10, {{48, 120}, {80, 60}}, 2},
  {"Wheat", 3, {{47, 60}, {53, 60}, {65, 20}, {72, 20}, {85, 20}}, 5},
  {"Sous Vide 55+120", 1, {{55, 30}, {85, 120}}, 2},
  {"46 (45)", 0, {{46, 45}}, 1},
  {"Test", 1, {{49, 1}, {51, 1}}, 2},
};

// Global variables for profile selection and execution
int activeProfileIndex = 100;  // 100 indicates no profile selected yet
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;
double Kp = 0.5, Ki = 1, Kd = 0.05;
PID myPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);

// Timing variables
long phaseStartTime;
long totalStartTime;
long ssrLastSwitchTime;
long totalElapsedTime;
long totalProcessTime;
long finishTime = 0;
long currentTime = 0;
long lastEEPROMWriteTime = 0;
bool isClick = false;
bool isLeft = false;
bool isRight = false;
bool isComplete = false;
const int ssrSwitchInterval = 1000;  // SSR switching interval in milliseconds

// Buffer for formatted time strings
char timeBuffer[10];

uint32_t timer = 0;
#define T_PERIOD 1000  // period of Execution processing
uint32_t timerSSR = 0;
#define T_PERIOD_SSR 500  // period of heater handling

#define PARTS 10

void setup() {
  pinMode(ssrPin, OUTPUT);
  Serial.begin(9600);

  oled.init();          // Initialize the OLED
  oled.clear();         // Clear the display
  readEEPROM();
  myPID.SetMode(AUTOMATIC);
  myPID.SetOutputLimits(0, 1);

}

void loop() {
  enc1.tick();
  isLeft = enc1.isLeft();
  isRight = enc1.isRight();
  isClick = enc1.isClick();
  if (isLeft || isRight || isClick) {
    handleEncoder();
  }
  handleExecution();
  handleHeaterAdv();
}

void handleHeaterSimple() {
  long time = millis();
  static int currentPart = 0;

  if (time - timerSSR < T_PERIOD_SSR) {
    return;
  }
  if (inSelectionMode) {
    digitalWrite(ssrPin, LOW);
    return;
  }
  timerSSR = time;

  int current = Output * PARTS;

  oled.setCursor(104, 7);
  char symbol;
  for (int i = 0; i < PARTS; i++) {
    symbol = current > i ? '=' : '-';
    if (currentPart == i) {
      oled.invertText(true);
    }
    oled.print(symbol);
    oled.invertText(false);
  }

  digitalWrite(ssrPin, currentPart < current ? HIGH : LOW);
  currentPart++;
  if (currentPart >= PARTS) {
    currentPart = 0;
  }
}

void handleHeaterAdv() {
  long time = millis();
  static int currentPart = 0;
  static bool states[PARTS];

  if (time - timerSSR < T_PERIOD_SSR) {
    return;
  }
  if (inSelectionMode) {
    digitalWrite(ssrPin, LOW);
    return;
  }
  timerSSR = time;

  int current = Output * PARTS;

  int last = 0;
  for (int i = 1; i < PARTS; i++) {
    last += states[i] ? 1 : 0;
    if (i) {
      states[i-1] = states[i];
    }
  }
  bool next = current > last ? true : false;
  states[PARTS-1] = next;

  oled.setCursor(128-6*PARTS, 7);
  sprintf(timeBuffer, "%3d", (int)(Output*100));
  char symbol;
  for (int i = 0; i < PARTS; i++) {
    int index = i - (PARTS - 3);
    symbol = index < 0 ? ' ' : timeBuffer[index];
    oled.invertText(states[i]);
    oled.print(symbol);
    oled.invertText(false);
  }

  digitalWrite(ssrPin, next);
  currentPart++;
  if (currentPart >= PARTS) {
    currentPart = 0;
  }
}

void handleEncoder() {
  if (inSelectionMode) {
    handleProfileSelection();
  } 
  else {
    handleExecutionSelection();
  }
}

void handleExecutionSelection() {
  if (isClick) {
    Serial.println("clicked! resetting...");
    activeProfileIndex = 100;
    activeProfile = profiles[activeProfileIndex];
    inSelectionMode = true;
    writeEEPROM();
    oled.clear();
    displaySelection();
    return;
  }

}

void handleExecution() {
  currentTime = millis();

  if (inSelectionMode || (currentTime - timer < T_PERIOD)) { // таймер на millis()
    return;
  }
  timer = currentTime;

  totalElapsedTime = (currentTime - totalStartTime) / 1000; // Total elapsed time in seconds

  if ((currentTime - lastEEPROMWriteTime) >= (long)10*60*1000) {
    writeEEPROM();
  }

  getPhaseAndTemperature();

  Input = thermocouple.readCelsius();
  if (isnan(Input)) {
    Input = 0;
  }
  myPID.Compute();

  if (isComplete && currentPhase >= activeProfile.numPhases && !finishTime) {
    finishTime = currentTime;
  }

  // Display all phases and highlight the current one
  printPhases();
}

void startExecution() {
  activeProfile = profiles[activeProfileIndex];
  inSelectionMode = false;  // Switch to execution mode
  phaseStartTime = totalStartTime = millis();  // Start the timer
  totalElapsedTime = 0;
  myPID.SetMode(AUTOMATIC);
  myPID.SetOutputLimits(0, 1);  // SSR is either ON or OFF
  // digitalWrite(ssrPin, HIGH);   // Start with heater on
  ssrLastSwitchTime = millis();
  calculateTotalTime();
  getPhaseAndTemperature();
  writeEEPROM();
  oled.clear();
  isComplete = false;
}

void handleProfileSelection() {
  if (!isClick && !isLeft && !isRight) {
    return;
  }

  // Handle encoder input for selecting the profile
  if (isRight) {
    selectedProfileIndex = (selectedProfileIndex + 1) % (sizeof(profiles) / sizeof(profiles[0]));
  } else if (isLeft) {
    selectedProfileIndex = (selectedProfileIndex - 1 + (sizeof(profiles) / sizeof(profiles[0]))) % (sizeof(profiles) / sizeof(profiles[0]));
  }

  displaySelection();

  // Start the selected profile on button press
  if (isClick) {
    activeProfileIndex = selectedProfileIndex;
    startExecution();
  }
}

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
  activeProfile = profiles[activeProfileIndex];
  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() {
  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 (totalElapsedTime < accumulatedTime + transitionDuration) {
        isInTransition = true;
        currentPhase = i - 1;  // Keep currentPhase as the previous phase
        int timeInTransition = totalElapsedTime - accumulatedTime;
        Setpoint = previousTemp + (double)timeInTransition / (60 * activeProfile.transitionMinutesPerDegree) * (targetTemp > previousTemp ? 1 : -1);
        phaseStartTime = totalStartTime + accumulatedTime * 1000; // Set phase start time
        return;
      }

      accumulatedTime += transitionDuration;
    }

    // Check if we're within the current phase
    if (totalElapsedTime < accumulatedTime + phaseDuration) {
      isInTransition = false;
      currentPhase = i;
      Setpoint = activeProfile.phases[i].temperature;
      phaseStartTime = totalStartTime + accumulatedTime * 1000; // Set phase start time
      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
  phaseStartTime = totalStartTime + accumulatedTime * 1000;  // Set phase start time to the end
}


void printPhases() {
  // 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(Input,0);
    oled.print("c");
    oled.print("->");
    oled.print((int)Setpoint);
    oled.print("c              ");
  } else {
    oled.setCursor(0, 0);
    oled.print(activeProfile.name);
    oled.print("               ");
  }

  // Display the totals and current state on the OLED
  oled.setCursor(0, 1);
  oled.print("    ");
  oled.setCursor(18, 1);
  formatTime(totalElapsedTime, timeBuffer);
  oled.print(timeBuffer);
  oled.print(" / ");
  formatTime(totalProcessTime, timeBuffer);
  oled.print(timeBuffer);
  oled.print("                  ");
  
  for (int i = 0; i < activeProfile.numPhases; i++) {
    if (i == currentPhase) {
      oled.invertText(true);  // Invert text for the current phase

      oled.setCursor(0, i + 2);  // Set cursor to the row corresponding to the phase
      long timeRemaining = (activeProfile.phases[i].duration * 60) - ((currentTime - phaseStartTime) / 1000);
      formatTime(timeRemaining, timeBuffer);
      oled.print(i + 1);
      oled.print(". ");
      oled.print(Input, 1);
      oled.print("c ");
      if (fabs(Setpoint - round(Setpoint)) < 0.05) {
          oled.print(Setpoint, 0);  // Print without decimals
      } else {
          oled.print(Setpoint, 1);  // Print with 1 decimal place
      }
      oled.print("c ");
      if (!isInTransition) {
        oled.print(timeBuffer);
      }
      oled.print("        ");
    } else {
      oled.invertText(false); // Normal text for other phases

      oled.setCursor(0, i + 2);  // Set cursor to the row corresponding to the phase
      formatTime(activeProfile.phases[i].duration * 60, timeBuffer);
      oled.print(i + 1);
      oled.print(". ");
      oled.print(activeProfile.phases[i].temperature);
      oled.print("c ");
      oled.print(timeBuffer);
      oled.print("             ");
    }
  }

  oled.invertText(false); // Ensure text inversion is off after the loop

  // oled.setCursor(110,7);
  // sprintf(timeBuffer, "%3d", (int)(Output*100));
  // oled.print(timeBuffer);
  // oled.update();
}

void formatTime(long seconds, char* buffer) {
    long hours = seconds / 3600;
    long mins = (seconds % 3600) / 60;
    int secs = seconds % 60;

    buffer[0] = '\0';  // Ensure the buffer is empty

    if (hours > 0) {
        sprintf(buffer + strlen(buffer), "%ldh", hours);
    }
    if (mins > 0) {
        sprintf(buffer + strlen(buffer), "%ldm", mins);
    }
    if (secs > 0) {
        sprintf(buffer + strlen(buffer), "%ds", secs);
    }
}

void writeEEPROM() {
  #if useEEPROM
  lastEEPROMWriteTime = millis();
  EEPROM.put(0, activeProfileIndex);  // Store the active profile index
  EEPROM.put(4, totalElapsedTime);    // Store the total elapsed time
  Serial.print("EEPROM written: ");
  Serial.print(activeProfileIndex);
  Serial.print(" ");
  Serial.println(totalElapsedTime);
  #endif
}

void readEEPROM() {
  #if useEEPROM
  long time = 0;
  EEPROM.get(0, activeProfileIndex);  // Store the active profile index
  EEPROM.get(4, time);    // Store the total elapsed time
  if (activeProfileIndex != 100) {
    totalStartTime = millis() - time*1000;
    calculateTotalTime();
    getPhaseAndTemperature();
    inSelectionMode = false;
  }
  else {
    oled.clear();
    displaySelection();
  }
  Serial.print("EEPROM read: ");
  Serial.print(activeProfileIndex);
  Serial.print(" ");
  Serial.println(time);
  #endif
}