/*
 * TIMED SIGNAL CONTROLLER for the ARDUINO UNO
 * Timed Traffic Light Controller Sketch
 * Written by Jacob Jewett - May 2018
 *
 * Concept idea:
 * Use a 5VDC relay board to control a 3-section 120VAC traffic signal
 * from green to red based timers.
 *
 * Dependencies:
 * Atomic.h (Arduino standard lib)
 *
 * Breadboard parts:
 * - 4Ch. Relay Board
 * - 2x LED's: one red, one green
 *
 * Pinout:
 * A0: Relay 1, SIGNAL RED
 * A1: Relay 2, SIGNAL YELLOW
 * A2: Relay 3, SIGNAL GREEN
 * A3: Relay 4, Unused
 * A4: Status indicator
 * A5: Power indicator
 */

#include <util/atomic.h>

//User controllable defines
#define RELAY_ACTIVE_LOW 1 //If the signal to relays should be inverted
#define RLY1 A0 //Red
#define RLY2 A1 //Yellow
#define RLY3 A2 //Green
#define RLY4 A3 //Relay 4

#define STSIND A4 //Status indicator
#define PWRIND A5 //Power indicator

#define TIME_STOP_MAX 60
#define TIME_CAUTION_MAX 10
#define TIME_GO_MAX 60
#define TIME_INIT_MAX 10

//Control types
enum SignalMode
{
  SIGNAL_BLANK,
  SIGNAL_GO,
  SIGNAL_GO_F,
  SIGNAL_CAUTION,
  SIGNAL_CAUTION_F,
  SIGNAL_STOP,
  SIGNAL_STOP_F
};
enum SignalState
{
  STATE_INIT_FLASH,
  STATE_STOP,
  STATE_CAUTION,
  STATE_GO
};

//Runtime variables
unsigned long tNow = millis();
volatile bool flashReference = false;
volatile bool timer0Active = false;
volatile unsigned int timer0 = 0;
bool hasInit = false;
bool initFlash = true;
unsigned int signalState = STATE_INIT_FLASH;

void relayOn(int relay)
{
  if (RELAY_ACTIVE_LOW)
  {
    digitalWrite(relay, LOW);
  }
  else
  {
    digitalWrite(relay, HIGH);
  }
}
void relayOff(int relay)
{
  if (RELAY_ACTIVE_LOW)
  {
    digitalWrite(relay, HIGH);
  }
  else
  {
    digitalWrite(relay, LOW);
  }
}
bool relayState(int relay)
{
  if (RELAY_ACTIVE_LOW)
  {
    return !digitalRead(relay);
  }
  return digitalRead(relay);
}
void relayState(int relay, int value)
{
  if (RELAY_ACTIVE_LOW)
  {
    digitalWrite(relay, !value);
  }
  else
  {
   digitalWrite(relay, value);
  }
}
void flashPin(int pin)
{
  digitalWrite(pin, flashReference);
}
void flashPinI(int pin)
{
  digitalWrite(pin, !flashReference);
}
void flashRelay(int relayPin)
{
  relayState(relayPin, flashReference);
}
class Signal3S
{
  public:
    Signal3S(unsigned int red, unsigned int yellow, unsigned int green) : _pin_red(red), _pin_yellow(yellow), _pin_green(green) {}
    void setMode(int mode)
    {
      if (_mode != mode)
      {
        _mode = mode;
      }
    }
    int getMode() { return _mode;  }
    void updateSignal()
    {
      if (_mode == SIGNAL_BLANK)
      {
        relayOff(_pin_green);
        relayOff(_pin_yellow);
        relayOff(_pin_red);
      }
      if (_mode == SIGNAL_GO)
      {
        relayOn(_pin_green);
        relayOff(_pin_yellow);
        relayOff(_pin_red);
      }
      if (_mode == SIGNAL_GO_F)
      {
        flashRelay(_pin_green);
        relayOff(_pin_yellow);
        relayOff(_pin_red);
      }
      if (_mode == SIGNAL_CAUTION)
      {
        relayOn(_pin_yellow);
        relayOff(_pin_red);
        relayOff(_pin_green);
      }
      if (_mode == SIGNAL_CAUTION_F)
      {
        flashRelay(_pin_yellow);
        relayOff(_pin_red);
        relayOff(_pin_green);
      }
      if (_mode == SIGNAL_STOP)
      {
        relayOn(_pin_red);
        relayOff(_pin_yellow);
        relayOff(_pin_green);
      }
      if (_mode == SIGNAL_STOP_F)
      {
        flashRelay(_pin_red);
        relayOff(_pin_yellow);
        relayOff(_pin_green);
      }
    }
  private:
    unsigned int _pin_red;
    unsigned int _pin_yellow;
    unsigned int _pin_green;
    unsigned int _mode;
};

//Objects
Signal3S s0(RLY1,RLY2,RLY3);
void setup()
{
  //Interupts
  cli();
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT1  = 0;
  OCR1A = 15624;
  TCCR1B |= (1 << WGM12);
  TCCR1B |= (1 << CS12) | (1 << CS10);
  TIMSK1 |= (1 << OCIE1A);
  sei();
  //Relays:
  pinMode(RLY1, OUTPUT);
  pinMode(RLY2, OUTPUT);
  pinMode(RLY3, OUTPUT);
  pinMode(RLY4, OUTPUT);
  relayOff(RLY1);
  relayOff(RLY2);
  relayOff(RLY3);
  relayOff(RLY4);
  //Indicators
  pinMode(STSIND, OUTPUT);
  pinMode(PWRIND, OUTPUT);
  digitalWrite(PWRIND, HIGH);
  //Flags
  timer0Active = true;
  //Comms
  Serial.begin(9600);
}
ISR(TIMER1_COMPA_vect)
{
  flashReference = !flashReference;
  if (timer0Active)
  {
    timer0++;
  }
}
void loop()
{
  tNow = millis();
  flashPin(STSIND);
  if (signalState == 0 && timer0 >= TIME_INIT_MAX)
  {
    hasInit = true;
    signalState = 1;
    timer0 = 0;
  }
  else
  {
    s0.setMode(SIGNAL_STOP_F);
  }
  if (hasInit)
  {
    if (signalState == STATE_STOP)
    {
      s0.setMode(SIGNAL_STOP);
    }
    if (signalState == STATE_CAUTION)
    {
      s0.setMode(SIGNAL_CAUTION);
    }
    if (signalState == STATE_GO)
    {
      s0.setMode(SIGNAL_GO);
    }

    if (signalState == STATE_STOP && timer0 >= TIME_STOP_MAX)
    {
      signalState = 3;
      timer0 = 0;
    }
    if (signalState == STATE_CAUTION && timer0 >= TIME_CAUTION_MAX)
    {
      signalState = 1;
      timer0 = 0;
    }
    if (signalState == STATE_GO && timer0 >= TIME_GO_MAX)
    {
      signalState = 2;
      timer0 = 0;
    }
  }
  s0.updateSignal();
}