hydroponic-controller/include/ec.h

#ifndef _EC_H_
#define _EC_H_

#include <Arduino.h>

float ecEC_ADS_CHANNEL_mean=0;

bool ec_flag_measurement_available=false;

#define EC_PIN_RELAY_PROBE 27
#define EC_PIN_RELAY_RANGEMSB 25
#define EC_PIN_RELAY_RANGELSB 26


//#define EC_PIN_ADC 4
#define EC_ADS_CHANNEL 0
#define EC_PIN_FREQ 5
#define EC_PWM_CH 0
#define EC_RESOLUTION 8
#define EC_FREQUENCY 5000

#define EC_ARRAY_SIZE 64
uint16_t ec_array_range00[EC_ARRAY_SIZE]; //00=NC,NC = highest value
uint16_t ec_array_range01[EC_ARRAY_SIZE];
uint16_t ec_array_range10[EC_ARRAY_SIZE];
uint16_t ec_array_range11[EC_ARRAY_SIZE]; //11= NO,NO = lowest value
uint16_t ec_array_pos=EC_ARRAY_SIZE*4;
unsigned long last_measurement_ec=0;
#define EC_MEASUREMENT_INTERVAL 10000 //complete filtered measurement every x ms
  //One filtered measurement takes EC_READ_INTERVAL*EC_ARRAY_SIZE*4
#define EC_READ_INTERVAL 2 //interval of reading adc value inside a measurement

#define EC_RELAY_SWITCH_SETTLETIME 500  //time until voltage of ec circuit has settled

const uint16_t ec_centerADCvalue=1909; //adc value when probe resistance is equal to the range resistor (mean of both)

unsigned long ec_last_change_relay=0; //millis of last relay change

enum ECState{IDLE,MEASURE};

ECState ecstate=IDLE;

float adc_range00;
float adc_range01;
float adc_range10;
float adc_range11;


bool ec_measurementReady();
void ec_startMeasurement();
void ec_setRange(uint8_t range);
void ec_connectProbe(bool);
void ec_releaseRelay();

void ec_setup() {
  //pinMode(EC_PIN_ADC,INPUT);

  ledcSetup(EC_PWM_CH, EC_FREQUENCY, EC_RESOLUTION);
  ledcAttachPin(EC_PIN_FREQ, EC_PWM_CH);
  ledcWrite(EC_PWM_CH, 127); //50% duty cycle

  pinMode(EC_PIN_RELAY_PROBE,OUTPUT); //LOW=Calibration/idle, HIGH=Probe connected
  pinMode(EC_PIN_RELAY_RANGELSB,OUTPUT); //LOW=NC, HIGH=NO
  pinMode(EC_PIN_RELAY_RANGEMSB,OUTPUT); //LOW=NC, HIGH=NO
  ec_releaseRelay();

}

void ec_loop(unsigned long loopmillis) {
  
  static unsigned long last_read_ec=0;

  switch (ecstate) {
    case IDLE:
      
      if (loopmillis>last_measurement_ec+EC_MEASUREMENT_INTERVAL && ecstate==IDLE) { //start measurement if idle
        last_measurement_ec=loopmillis;
        ec_startMeasurement();
        ec_connectProbe(true);
        ecstate=MEASURE;
      }
      break;

    case MEASURE:
      if (ec_measurementReady()) {
        ec_releaseRelay();
        adc_range00=getMean(ec_array_range00,EC_ARRAY_SIZE); //good for low conductivity/high resistance
        adc_range01=getMean(ec_array_range01,EC_ARRAY_SIZE);
        adc_range10=getMean(ec_array_range10,EC_ARRAY_SIZE);
        adc_range11=getMean(ec_array_range11,EC_ARRAY_SIZE); //good for high conductivity/low resistance

        
        //ec_mean=0; //TODO select right range of all readings

        ec_flag_measurement_available=true;

        
        

        ecstate=IDLE;
      }
      
      break;

  }



  if (loopmillis>last_read_ec+EC_READ_INTERVAL && ec_array_pos/4<EC_ARRAY_SIZE) { //take reading into array if measurement running
    last_read_ec=loopmillis;

    //flag_print= ec_array_pos==EC_ARRAY_SIZE;
    //ec_array_pos%=EC_ARRAY_SIZE;

    ec_setRange(ec_array_pos/EC_ARRAY_SIZE);


    if (loopmillis>ec_last_change_relay+EC_RELAY_SWITCH_SETTLETIME) { //values have settled
      //uint16_t value=analogRead(EC_PIN_ADC);
      
      uint16_t value = ADS.readADC(EC_ADS_CHANNEL);
      switch (ec_array_pos/EC_ARRAY_SIZE){ //low range
        case 0:
          ec_array_range00[ec_array_pos%EC_ARRAY_SIZE]=value;
        break;

        case 1:
          ec_array_range01[ec_array_pos%EC_ARRAY_SIZE]=value;
        break;

        case 2:
          ec_array_range10[ec_array_pos%EC_ARRAY_SIZE]=value;
        break;

        case 3:
          ec_array_range11[ec_array_pos%EC_ARRAY_SIZE]=value;
        break;        
      }
      ec_array_pos++;

    }
    
  }  
  
}



void ec_startMeasurement() {
  ec_array_pos=0;
}

bool ec_measurementReady(){
  if (ec_array_pos/EC_ARRAY_SIZE>=4) { //reached end of both arrays
    return true;
  }else{
    return false;
  }
}

void ec_setRange(uint8_t range) {
  //range low means low resistor value -> NO -> relay High

  uint8_t crange=digitalRead(EC_PIN_RELAY_RANGELSB)+2*digitalRead(EC_PIN_RELAY_RANGEMSB);
  
  if (crange!=range) { //write only if different
    digitalWrite(EC_PIN_RELAY_RANGELSB,range%2);
    digitalWrite(EC_PIN_RELAY_RANGEMSB,range/2);
    ec_last_change_relay=millis();
  }
}

void ec_connectProbe(bool relay) {
  bool val=digitalRead(EC_PIN_RELAY_PROBE);
  if (val!=relay) { //write only if different
    digitalWrite(EC_PIN_RELAY_PROBE,relay);
    ec_last_change_relay=millis();
  }
}

void ec_releaseRelay() {
  digitalWrite(EC_PIN_RELAY_PROBE,LOW);
  digitalWrite(EC_PIN_RELAY_RANGEMSB,LOW);
  digitalWrite(EC_PIN_RELAY_RANGELSB,LOW);
  ec_last_change_relay=millis();
}


#endif