hot-fermentation/hot_fermentation.ino

#define useEEPROM 1
// #define TempSensorMax
#define TempSensorDallas
// #define PlotValues

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

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

#ifdef TempSensorMax
  #include <max6675.h>
  // MAX6675 configuration
  int max_SO = 12;
  int max_CS = 10;
  int max_SCK = 13;
  MAX6675 thermocouple(max_SCK, max_CS, max_SO);
#endif
#ifdef TempSensorDallas
  #include <OneWire.h>
  #include <DallasTemperature.h>
  // Data wire is plugged into port 2 on the Arduino
  #define ONE_WIRE_BUS 9

  // Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
  OneWire oneWire(ONE_WIRE_BUS);

  // Pass our oneWire reference to Dallas Temperature. 
  DallasTemperature sensors(&oneWire);
#endif

// 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;
const int activeBuzzerPin = 8;

// 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", 1, {{46, 120}, {55, 60}, {65, 150}, {70, 60}, {90, 105}}, 5},
  {"Chickpeas v2", 1, {{46, 120}, {55, 120}, {65, 120}, {72, 240}, {85, 300}}, 5},
  {"Lentils", 3, {{46, 120}, {53, 120}, {65, 180}, {72, 90}, {90, 15}}, 5},
  {"Gradual", 10, {{46, 120}, {80, 60}}, 2},
  {"Long gradual", 10, {{46, 120}, {80, 60}, {90, 15}}, 3},
  {"Wheat", 1, {{46, 120}, {53, 40}, {65, 40}, {72, 40}, {85, 40}}, 5},
  {"SV1", 1, {{55, 30}, {85, 120}}, 2},
  {"SV2", 0, {{46, 45}}, 1},
  // {"Yoghurt maker", 0, {{40, 300}, {40, 300}, {30, 300}}, 3},
};

// 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 Kp = 0.5, Ki = 1, Kd = 0.05;
// PID myPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);

#include "GyverPID.h"
double Setpoint, Input, Output;
GyverPID regulator(25, 0, 0, 1000);

bool temperatureSensorError = false;

// 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 timerExecution = 0;
#define T_PERIOD_EXEC 1000  // period of Execution processing
uint32_t timerSSR = 0;
#define T_PERIOD_SSR 500  // period of heater handling
uint32_t timerTemp = 0;
#define T_PERIOD_TEMP 1000  // period of dallas sensor requesting
uint32_t timerChecks= 0;
#define T_PERIOD_Checks 1000  // period of additional checks

bool boolLastCompletedState = false;

float failedReadingLastValue = 0;
int failedReadingCount = 0;

#define PARTS 8

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

  oled.init();          // Initialize the OLED
  oled.clear();         // Clear the display
  readEEPROM();
  regulator.setDirection(NORMAL); // направление регулирования (NORMAL/REVERSE). ПО УМОЛЧАНИЮ СТОИТ NORMAL
  regulator.setLimits(0, 100);    // пределы (ставим для 8 битного ШИМ). ПО УМОЛЧАНИЮ СТОЯТ 0 И 255
  regulator.setpoint = 0;

  #ifdef TempSensorDallas
    sensors.begin();
    DeviceAddress tempDeviceAddress;
    sensors.getAddress(tempDeviceAddress, 0);
    sensors.setResolution(tempDeviceAddress, 12);
    sensors.setWaitForConversion(false);
  #endif
}

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

void handleAdditionalChecks() {
  long time = millis();

  if (time - timerChecks < T_PERIOD_Checks) {
    return;
  }
  timerChecks = time;

  if (isComplete && !boolLastCompletedState) {
    boolLastCompletedState = true;
    for(int i=0; i<10; i++) {
      digitalWrite(activeBuzzerPin, HIGH);
      delay(100);
      digitalWrite(activeBuzzerPin, LOW);
      delay(100);
    }
  }
}

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

  if (time - timerTemp < T_PERIOD_TEMP) {
    return;
  }
  timerTemp = time;

#ifdef TempSensorDallas
  Input = (double) sensors.getTempCByIndex(0);

  sensors.requestTemperatures(); // Send the command to get temperatures
#endif
#ifdef TempSensorMax // to go into the read temp function, rename from dallas temp
  Input = thermocouple.readCelsius();
#endif

  if (isnan(Input) || Input < 20 || Input > 95) {
    failedReadingLastValue = (float) Input;
    failedReadingCount++;
    temperatureSensorError = true;
  }
  else {
    temperatureSensorError = false;
  }

}

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/100 * 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;
  if (Output < 1) next = false;
  states[PARTS-1] = next;

  oled.setCursor(128-6*PARTS, 7);
  sprintf(timeBuffer, "%3d", (int)(Output));
  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);
  }

  if (temperatureSensorError) {
    next = 0;
  }

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

#ifdef PlotValues
  Serial.print(Setpoint);
  Serial.print(",");
  Serial.print(Input);
  Serial.print(",");
  Serial.print(Output);
  Serial.println(",0,100");
#endif

}

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

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

}

void handleExecution() {
  currentTime = millis();

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

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

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

  getPhaseAndTemperature();

  regulator.input = (float)Input;
  regulator.setpoint = Setpoint;
  regulator.getResultNow();
  Output = regulator.output;

  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;
  regulator.setpoint = 0;
  // digitalWrite(ssrPin, HIGH);   // Start with heater on
  ssrLastSwitchTime = millis();
  calculateTotalTime();
  getPhaseAndTemperature();
  writeEEPROM();
  oled.clear();
  boolLastCompletedState = 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("             ");
    }
  }

  if (temperatureSensorError) {
    oled.invertText(true);
    oled.setCursor(0, 0);
    oled.setScale(2);
    oled.print("T = ");
    oled.print(Input);
    oled.print("   ");
    oled.setScale(1);
    digitalWrite(activeBuzzerPin, HIGH);
    delay(5);
    digitalWrite(activeBuzzerPin, LOW);
  }

  if (failedReadingCount) {
    oled.setCursor(0, 7);
    oled.print(failedReadingCount);
    oled.print(" (");
    oled.print(failedReadingLastValue);
    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
}