CHESS_CLOCK4DIGIT.ino

//#include <TM1637Display.h>
#include <TM1637TinyDisplay6.h>
#include <avdweb_Switch.h>
#include <LiquidCrystal_I2C.h>
#include <FrequencyTimer2.h>
#include <EEPROM.h> // TODO: save custom (slots?)

TM1637TinyDisplay6 display0(2, 3);
TM1637TinyDisplay6 display1(4, 5);

// Use 470 ohm resistor for the LEDs...
int ledPin0 = 11;
int ledPin1 = 10;

Switch switch0(6, INPUT_PULLUP, LOW, 12);
Switch switch1(12, INPUT_PULLUP, LOW, 12);
Switch switchLeft(7, INPUT_PULLUP, LOW, 12);
Switch switchRight(8, INPUT_PULLUP, LOW, 12);
Switch switchPause(9, INPUT_PULLUP, LOW, 12);

LiquidCrystal_I2C lcd(0x27,  16, 2);
String Lcd_Lines[2];
bool LcdQueued = false;

unsigned long last_ms_tick;

struct TimeValue {
  long hours;
  long minutes;
  long seconds;
  long milliseconds;
};

enum Phase {
  Playing = 0,
  SettingUp,
  Done
};

enum SetupState {
  None = 0,
  BaseHours,
  BaseMinutes,
  BaseSeconds,
  IncrementSeconds,
  DelaySeconds,
  AllDone,
};

struct Preset {
  String name;
  long base_ms;
  long increment;
  long delay;
};

Preset CustomPresets[2];

const int PRESET_COUNT = 5;
Preset PRESETS[PRESET_COUNT] = {
  {"3+2", 180000, 2000, 0},
  {"3+0", 180000, 0, 0},
  {"5+0", 300000, 0, 0},
  {"1+0", 60000, 0, 0},
  {"Custom", 0, 0, 0},
};

// holds all state
struct Game {
  long base_ms[2];
  long ms[2];
  long increment[2];
  long delay[2];
  long delay_remaining[2];
  long start_ms; // since previous hit or start
  bool is_paused;
  int on_the_clock;
  int phase;
  long move_counter;
  int preset;
  int entered_number;
  int custom_setup_phase;
  int custom_setup_side;
  TimeValue preset_base_starting_values[2];
};



Game game;

void setup() {
  Serial.begin(9600);
  display0.setBrightness(1);
  display1.setBrightness(1);
  pinMode(ledPin0, OUTPUT);
  pinMode(ledPin1, OUTPUT);
  digitalWrite(ledPin0, LOW);
  digitalWrite(ledPin1, LOW);
  lcd.init();
  lcd.backlight();
  Lcd_Lines[0] = "";
  Lcd_Lines[1] = "";
  game.is_paused = true;
  game.on_the_clock = 0;
  game.move_counter = 0;
  game.delay_remaining[0] = 0;
  game.delay_remaining[1] = 0;
  game.ms[0] = 0;
  game.ms[1] = 0;
  game.phase = Phase::SettingUp;
  game.custom_setup_phase = SetupState::None;
  game.custom_setup_side = 0;
  LoadEEPromPreset();
  LoadPreset(0);
  FrequencyTimer2::setPeriod(1000);
  FrequencyTimer2::setOnOverflow(timer2ISR);
}

String SideToString(int side) {
  if (side == 0) {
    return "A";
  } else {
    return "B";
  }
}

void EnterSetupState(SetupState state, int side) {
  ExitSetupState(game.custom_setup_phase, game.custom_setup_side);
  game.custom_setup_phase = state;
  game.custom_setup_side = side;
  game.ms[0] = game.base_ms[0];
  game.ms[1] = game.base_ms[1];
  switch (state) {
    case None: {
      break;
    }
    case BaseHours: {
      LcdQueue(0, "Hours " + SideToString(side));
      game.entered_number = game.preset_base_starting_values[side].hours;
      LcdQueue(1, String(game.entered_number));
      break;
    }
    case BaseMinutes: {
      LcdQueue(0, "Minutes " + SideToString(side));
      game.entered_number = game.preset_base_starting_values[side].minutes;
      LcdQueue(1, String(game.entered_number));
      break;
    }
    case BaseSeconds: {
      LcdQueue(0, "Seconds " + SideToString(side));
      game.entered_number = game.preset_base_starting_values[side].seconds;
      LcdQueue(1, String(game.entered_number));
      break;
    }
    case IncrementSeconds: {
      LcdQueue(0, "Increment " + SideToString(side));
      game.entered_number = CustomPresets[side].increment / 1000.0f;
      LcdQueue(1, String(game.entered_number));
      break;
    }
    case DelaySeconds: {
      LcdQueue(0, "Delay " + SideToString(side));
      game.entered_number = CustomPresets[side].delay / 1000.0f;
      LcdQueue(1, String(game.entered_number));
      break;
    }
    case AllDone: {
      for (int i = 0; i < 2; i++) {
        CustomPresets[i].base_ms = game.base_ms[i];
        CustomPresets[i].increment = game.increment[i];
        CustomPresets[i].delay = game.delay[i];
      }
      SaveEEPromPreset();
      game.ms[0] = game.base_ms[0];
      game.ms[1] = game.base_ms[1];
      LcdQueue(0, TimeControlToString(0));
      LcdQueue(1, TimeControlToString(1));
      break;
    }
  }
}

long LoadEEPromLong_(int start) {
  long value;
  EEPROM.get(start, value);
  return value;
}

void StoreEEPromLong_(long value, int start) {
  EEPROM.put(start, value);
}

void LoadEEPromPreset() {
  // load from EEPRom -> presets[-1]
  CustomPresets[0].base_ms = LoadEEPromLong_(0);
  CustomPresets[0].increment = LoadEEPromLong_(4);
  CustomPresets[0].delay = LoadEEPromLong_(8);
  CustomPresets[1].base_ms = LoadEEPromLong_(12);
  CustomPresets[1].increment = LoadEEPromLong_(16);
  CustomPresets[1].delay = LoadEEPromLong_(20);
}

void SaveEEPromPreset() {
  // save presets[-1] -> eeprom
  // WRITES ARE EXPENSIVE!! TODO ONLY DO WHEN CHANGED...
  StoreEEPromLong_(CustomPresets[0].base_ms, 0);
  StoreEEPromLong_(CustomPresets[0].increment, 4);
  StoreEEPromLong_(CustomPresets[0].delay, 8);
  StoreEEPromLong_(CustomPresets[1].base_ms, 12);
  StoreEEPromLong_(CustomPresets[1].increment, 16);
  StoreEEPromLong_(CustomPresets[1].delay, 20);
}

void ExitSetupState(SetupState state, int side) {
  switch (state) {
    case None: {
      // set the default values
      game.preset_base_starting_values[0] = time_chunk(CustomPresets[0].base_ms);
      game.preset_base_starting_values[1] = time_chunk(CustomPresets[1].base_ms);
      break;
    }
    case BaseHours: {
      game.base_ms[side] = game.entered_number * 1000L * 60L * 60L;
      break;
    }
    case BaseMinutes: {
      game.base_ms[side] += game.entered_number * 1000L * 60L;
      break;
    }
    case BaseSeconds: {
      game.base_ms[side] += game.entered_number * 1000L;
      break;
    }
    case IncrementSeconds: {
      game.increment[side] = game.entered_number * 1000L;
      break;
    }
    case DelaySeconds: {
      game.delay[side] = game.entered_number * 1000L;
      break;
    }
    case AllDone: {
      break;
    }
  }
}


void timer2ISR()
{ 
  switch0.poll();
  switch1.poll();
  switchPause.poll();
  switchLeft.poll();
  switchRight.poll();

  if (game.phase == Phase::SettingUp) {
    if (switchLeft.pushed()) {
      // left button
      if (game.preset == PRESET_COUNT - 1 && game.custom_setup_phase != SetupState::None) {
        game.entered_number -= 1;
        if (game.entered_number < 0) {
          game.entered_number = 0;
        }
        LcdQueue(1, String(game.entered_number));
      } else {
        LoadPreset((game.preset - 1 + PRESET_COUNT) % PRESET_COUNT);
      }
    } else if (switchRight.pushed()) {
      // right button
      if (game.preset == PRESET_COUNT - 1 && game.custom_setup_phase != SetupState::None) {
        game.entered_number += 1;
        LcdQueue(1, String(game.entered_number));
      } else {
        LoadPreset((game.preset + 1) % PRESET_COUNT);
      }
    } else if (switchPause.pushed()) {
      // pause button on top
      if (game.preset == PRESET_COUNT - 1) { 
        switch (game.custom_setup_phase) {
          case None: {
            EnterSetupState(SetupState::BaseHours, 0);
            break;
          }
          case BaseHours: {
            if (game.custom_setup_side == 0) {
              EnterSetupState(SetupState::BaseHours, 1);
            } else {
              EnterSetupState(SetupState::BaseMinutes, 0); 
            }
            break;
          }
          case BaseMinutes: {
            if (game.custom_setup_side == 0) {
              EnterSetupState(SetupState::BaseMinutes, 1);
            } else {
              EnterSetupState(SetupState::BaseSeconds, 0); 
            }
            break;
          }
          case BaseSeconds: {
            if (game.custom_setup_side == 0) {
              EnterSetupState(SetupState::BaseSeconds, 1);
            } else {
              EnterSetupState(SetupState::IncrementSeconds, 0); 
            }
            break;
          }
          case IncrementSeconds: {
            if (game.custom_setup_side == 0) {
              EnterSetupState(SetupState::IncrementSeconds, 1);
            } else {
              EnterSetupState(SetupState::DelaySeconds, 0); 
            }
            break;
          }
          case DelaySeconds: {
            if (game.custom_setup_side == 0) {
              EnterSetupState(SetupState::DelaySeconds, 1);
            } else {
              EnterSetupState(SetupState::AllDone, 0); 
            }
            break;
          }
          case AllDone: {
            // TODO: do we need to handle this state...
            // probably, start game...
            break;
          }
          default:
            break;
        }
      }
    }
  }

  bool clock_is_hit = false;
  int clock_hit = -1;
  bool switch_cond0 = switch0.switched() && !switch0.on();
  bool switch_cond1 = switch1.switched() && !switch1.on();
  if (switch_cond0 && switch_cond1) {
    clock_is_hit = true;
    clock_hit = game.on_the_clock;
    last_ms_tick = millis();
  } else if (switch_cond0) {
    clock_is_hit = true;
    clock_hit = 0;
    last_ms_tick = millis();
  } else if (switch_cond1) {
    clock_is_hit = true;
    clock_hit = 1;
    last_ms_tick = millis();
  }

  if (game.phase == Phase::SettingUp) {
    if (clock_is_hit) {
      game.phase = Phase::Playing;
      if (clock_hit == 0) {
        game.on_the_clock = 1;
      } else {
        game.on_the_clock = 0;
      }
      Unpause();
    }
  } else if (game.phase == Phase::Playing) {
    if (game.is_paused) {
      if (clock_is_hit && clock_hit == game.on_the_clock) {
        Unpause();
        ClockHit();
      } else if (switchPause.pushed()) {
        Unpause();
      }
    } else {
      if (clock_is_hit) {
        if (clock_hit == game.on_the_clock) {
          ClockHit();
        }
      } else if (switchPause.pushed()) {
        Pause();
      } else {
        long elapsed = millis() - game.start_ms;
        // TODO: delay...
        if (elapsed < game.delay[game.on_the_clock]) {
          game.delay_remaining[game.on_the_clock] = game.delay[game.on_the_clock] - elapsed;
        } else if (elapsed == game.delay[game.on_the_clock]) {
          game.delay_remaining[game.on_the_clock] = 0;
        } else {
          game.ms[game.on_the_clock] = game.base_ms[game.on_the_clock] - elapsed;
        }
        if (game.ms[game.on_the_clock] <= 0) {
          game.phase = Phase::Done;
        }
      }
    }
  }
}

void loop() {
  for (int i = 0; i < 2; i++) {
    TimeValue tv;
    if (game.delay_remaining[i] > 0) {
      tv = time_chunk(game.delay_remaining[i]);
    } else {
      tv = time_chunk(game.ms[i]);
    }
    SyncTime(i, tv.hours, tv.minutes, tv.seconds, tv.milliseconds);
  }
  if (LcdQueued) {
    LcdQueued = false;
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(Lcd_Lines[0]);
    lcd.setCursor(0, 1);
    lcd.print(Lcd_Lines[1]);
  }
  if (!game.is_paused) {
    if (game.on_the_clock == 0) {
      digitalWrite(ledPin0, HIGH);
      digitalWrite(ledPin1, LOW);
    } else {
      digitalWrite(ledPin0, LOW);
      digitalWrite(ledPin1, HIGH);
    }
  } else {
    digitalWrite(ledPin0, LOW);
    digitalWrite(ledPin1, LOW);
  }
}

TimeValue time_chunk(long ms) {
  TimeValue tv;
  tv.hours = ms / 3600000;
  tv.minutes = (ms - (tv.hours * 3600000)) / 60000;
  tv.seconds = (ms - (tv.hours * 3600000) - (tv.minutes * 60000)) / 1000;
  tv.milliseconds = ms - (tv.hours * 3600000) - (tv.minutes * 60000) - (tv.seconds * 1000);
  return tv;
}

String time_value_string(TimeValue time_control) {
  String prefix;
  if (time_control.hours > 0) {
    prefix += String(time_control.hours) + "h";
  }
  if (time_control.minutes > 0) {
    prefix += String(time_control.minutes) + "m";
  }
  if (time_control.seconds > 0) {
    prefix += String(time_control.seconds) + "s";
  }
  return prefix;
}

/* Write out to clock faces. This would differ if we had a 4-digit or 6 digit boi. */
void SyncTime(int who, unsigned long hours, unsigned long minutes, unsigned long seconds, unsigned long milliseconds) {
  uint8_t decimal_set;
  long num;
  if (hours > 0) {
    decimal_set = 0b01010000;
    num = (hours * 10000) + (minutes*100) + seconds;
  } else if (minutes < 1) {
    decimal_set = 0b00010000;
    num = (minutes * 10000) + (seconds*100) + ((milliseconds / 1000.0f) * 60.0f);
  } else {
    decimal_set = 0b00010000;
    num = (minutes*100) + seconds;
  }
  if (who == 0) {
    display0.showNumberDec(num, decimal_set);
  } else {
    display1.showNumberDec(num, decimal_set);
  }
}

void LcdQueue(int line, String message) {
  // TODO: some kind of ticker?
  Lcd_Lines[line] = message;
  LcdQueued = true;
}

void LoadPreset(int preset) {
  game.preset = preset;
  game.base_ms[0] = PRESETS[preset].base_ms;
  game.base_ms[1] = PRESETS[preset].base_ms;
  game.ms[0] = game.base_ms[0];
  game.ms[1] = game.base_ms[1];
  game.increment[0] = PRESETS[preset].increment;
  game.increment[1] = PRESETS[preset].increment;
  LcdQueue(0, PRESETS[preset].name);
}

String TimeControlToString(int side) {
  TimeValue base_time_control = time_chunk(game.base_ms[side]);
  String prefix = time_value_string(base_time_control);
  String postfix = "";
  if (game.increment[side] > 0) {
    postfix += "+" + time_value_string(time_chunk(game.increment[side]));
  }
  if (game.delay[side] > 0) {
    postfix += "d" + time_value_string(time_chunk(game.delay[side]));
  }
  return prefix + postfix;
}

void ClockHit() {
  game.start_ms = last_ms_tick; //  TODO: more precise clock
  game.delay_remaining[game.on_the_clock] = 0;
  game.delay_remaining[!game.on_the_clock] = game.delay[!game.on_the_clock];
  game.base_ms[game.on_the_clock] = game.ms[game.on_the_clock] + game.increment[game.on_the_clock];
  game.ms[game.on_the_clock] = game.base_ms[game.on_the_clock];
  game.on_the_clock = !game.on_the_clock;
  game.move_counter++;
  game.ms[game.on_the_clock] = game.base_ms[game.on_the_clock];

  //String count = String(1 + (game.move_counter/2));
}

void Unpause() {
  LcdQueue(0, "Playing");
  LcdQueue(1, "");
  game.is_paused = false;
  game.base_ms[game.on_the_clock] = game.ms[game.on_the_clock];
  game.start_ms = millis();
  String count = String(1 + (game.move_counter/2));
}

void Pause() {
  LcdQueue(0, "Paused");
  game.is_paused = true;
}