#include "Arduino.h"

#include "Metro.h"

#include "ads1210.h"
#include "led.h"
#include "SimpleModbusSlave.h"
#include "Thermometer.h"
#include "Config.h"



const uint8_t LED_PIN = 8;

const uint8_t ADC_1_CS_PIN = 9;
const uint8_t ADC_1_RDY_PIN = 7;

const uint8_t ADC_2_CS_PIN = 2;
const uint8_t ADC_2_RDY_PIN = 3;

const uint8_t CAL_ENABLE = 18;
const uint8_t CAL_OFFSET_ENABLE = 19;
const uint8_t CAL_FACTOR_ENABLE = 20;

const uint8_t MODBUS_TX_ENABLE_PIN = 6;
const uint8_t MODBUS_ID = 3;
const uint32_t MODBUS_BAUD = 1200;

const uint16_t CALIBRATION_CYCLES = 100;

const uint8_t NUM_OF_CHANNELS = 2;

ADS1210 ads1210[NUM_OF_CHANNELS];
Thermometer thermometer[NUM_OF_CHANNELS];
LED led;
Metro secondTick = Metro(1000);
uint32_t uptimeSeconds = 0;


typedef enum { e_CAL_IDLE, e_CAL_RUNNING, e_CAL_SET, e_CAL_COMPLETE } tCalibrationState;

tCalibrationState calibrationState = e_CAL_IDLE;
uint16_t calibrationCycleCnt = 0;
float calibrationValueSum[NUM_OF_CHANNELS];



struct {
  struct {
	  union {
	 	  uint32_t in;
		  uint16_t modbusRegisters[2];
	  } adcValue;
	  union {
		  float in;
		  uint16_t modbusRegisters[2];
 	  } adcU;
	  union {
		  float in;
		  uint16_t modbusRegisters[2];
 	  } adcR;
	  union {
		  float in;
		  uint16_t modbusRegisters[2];
 	  } calOffset;
	  union {
		  float in;
		  uint16_t modbusRegisters[2];
 	  } calFactor;
	  union {
		  float in;
		  uint16_t modbusRegisters[2];
	  } temperatureRaw;
	  union {
		  float in;
		  uint16_t modbusRegisters[2];
	  } temperature;
	  union {
		  float in;
		  uint16_t modbusRegisters[2];
	  } alpha;
  } channelVariables[NUM_OF_CHANNELS];	
  union {
	  uint32_t in;
	  uint16_t modbusRegisters[2];
  } uptimeSeconds;
} modbusHoldingRegisters;


void setup() {  
  delay(100);
  bool initializeConfig = Config::initialize();
  led.begin(LED_PIN);
  ads1210[0].begin(ADC_1_CS_PIN, ADC_1_RDY_PIN, initializeConfig, Config::ADC1START);
  ads1210[1].begin(ADC_2_CS_PIN, ADC_2_RDY_PIN, initializeConfig, Config::ADC2START);
  thermometer[0].begin(initializeConfig, Config::THERMO1START);
  thermometer[1].begin(initializeConfig, Config::THERMO2START);
  modbus_configure(&Serial, MODBUS_BAUD, SERIAL_8N2, MODBUS_ID, MODBUS_TX_ENABLE_PIN,
                   sizeof(modbusHoldingRegisters), (uint16_t*)(&modbusHoldingRegisters));

  for (uint8_t i = 0; i < NUM_OF_CHANNELS; i++) {
    modbusHoldingRegisters.channelVariables[i].calOffset.in = ads1210[i].getCalOffset();
    modbusHoldingRegisters.channelVariables[i].calFactor.in = ads1210[i].getCalFactor();
    modbusHoldingRegisters.channelVariables[i].alpha.in = thermometer[i].getAlpha();
    calibrationValueSum[i] = 0.0;
  }
}

void loop() {
  for (uint8_t i = 0; i < NUM_OF_CHANNELS; i++) {
    ads1210[i].exec();
    modbusHoldingRegisters.channelVariables[i].adcValue.in = ads1210[i].getValue();
    modbusHoldingRegisters.channelVariables[i].adcU.in = ads1210[i].getU();
    modbusHoldingRegisters.channelVariables[i].adcR.in = ads1210[i].getR();
    
    thermometer[i].exec(ads1210[i].getR());
    modbusHoldingRegisters.channelVariables[i].temperatureRaw.in = thermometer[i].getTemperatureRaw();
    modbusHoldingRegisters.channelVariables[i].temperature.in = thermometer[i].getTemperature();
    
    if (modbusHoldingRegisters.channelVariables[i].alpha.in != thermometer[i].getAlpha()) {
      thermometer[i].setAlpha(modbusHoldingRegisters.channelVariables[i].alpha.in);
    }
	}

  if ((digitalRead(CAL_ENABLE) != 0) && 
      ((digitalRead(CAL_OFFSET_ENABLE) != 0) || (digitalRead(CAL_FACTOR_ENABLE) != 0)) &&
      (calibrationState != e_CAL_COMPLETE)) {
    led.toggle();

    switch (calibrationState) {
      case e_CAL_IDLE:
        calibrationState = e_CAL_RUNNING;
        break;
      case e_CAL_RUNNING:
        calibrationCycleCnt++;
        for (uint8_t i = 0; i < NUM_OF_CHANNELS; i++) {
          calibrationValueSum += ads1210[i].getValue();
        }
        if (calibrationCycleCnt >= CALIBRATION_CYCLES) {
          calibrationState = e_CAL_SET;
        }
        break;
      case e_CAL_SET:
        // calculate and set according to selected calibration mode
        if (digitalRead(CAL_OFFSET_ENABLE) != 0) {
          // for offset calibration, the terminals needs to be shorten
          // offset calibration needs to be performed first
          float offset = calibrationValueSum / calibrationCycleCnt;
          for (uint8_t i = 0; i < NUM_OF_CHANNELS; i++) {
            ads1210[i].setCalOffset(offset);
          }     
        }
        if (digitalRead(CAL_FACTOR_ENABLE) != 0) {
          // for factor calibration, a 1000R resistor needs to be connected
          // to the terminals
          float factor = 1000.0 / (calibrationValueSum / calibrationCycleCnt);
          for (uint8_t i = 0; i < NUM_OF_CHANNELS; i++) {
            ads1210[i].setCalFactor(offset);
          }     
        }
        calibrationState = e_CAL_COMPLETE;
        break;
      default:
        calibrationState = e_CAL_COMPLETE;
        break;
    }
  }

  if ((digitalRead(CAL_ENABLE) == 0) && (secondTick.check() == 1)) {
    led.toggle();
	  uptimeSeconds++;
	  modbusHoldingRegisters.uptimeSeconds.in = uptimeSeconds;
  }

  modbus_update();
}