Compare commits
No commits in common. "f0678485be7d27280f3f0661a06cd9256d87ec9e" and "07fe2240b73ff9462c01fa8dea4571e5c17919e9" have entirely different histories.
f0678485be
...
07fe2240b7
File diff suppressed because it is too large
Load Diff
112
include/ec.h
112
include/ec.h
|
|
@ -2,13 +2,11 @@
|
|||
#define _EC_H_
|
||||
|
||||
#include <Arduino.h>
|
||||
/*
|
||||
mqttValueTiming timing_ec_adc;
|
||||
mqttValueTiming timing_ec_calibadc;
|
||||
mqttValueTiming timing_ec_adcadjusted;
|
||||
mqttValueTiming timing_ec_ec;
|
||||
mqttValueTiming timing_ec_sc;
|
||||
*/
|
||||
|
||||
|
||||
|
||||
|
|
@ -19,7 +17,6 @@ bool ec_flag_measurement_available=false;
|
|||
|
||||
|
||||
#define EC_PIN_RELAY_PROBE 27
|
||||
#define EC_PIN_RELAY_PROBESELECT 26
|
||||
|
||||
|
||||
//#define EC_PIN_ADC 4
|
||||
|
|
@ -29,8 +26,7 @@ bool ec_flag_measurement_available=false;
|
|||
#define EC_RESOLUTION 8
|
||||
#define EC_FREQUENCY 5000
|
||||
|
||||
//#define EC_CALIB_ARRAY_SIZE 128
|
||||
#define EC_CALIB_ARRAY_SIZE 32 //temporarily changed
|
||||
#define EC_CALIB_ARRAY_SIZE 128
|
||||
uint16_t ec_calib_array[EC_CALIB_ARRAY_SIZE];
|
||||
uint16_t ec_calib_array_pos=0;
|
||||
#define EC_CALIB_READ_INTERVAL 250 //interval of reading adc value inside a measurement
|
||||
|
|
@ -52,22 +48,13 @@ unsigned long ec_last_change_relay=0; //millis of last relay change
|
|||
|
||||
enum ECState{IDLE,MEASURE};
|
||||
|
||||
uint8_t probeselect=0;
|
||||
const uint8_t num_probes=2;
|
||||
|
||||
ECState ecstate=IDLE;
|
||||
|
||||
float ec_adc;
|
||||
float ec_adc_adjusted; //adjusted for reference resistor
|
||||
float ec_calib_adc;
|
||||
|
||||
float ec_adc_A;
|
||||
float ec_adc_adjusted_A; //adjusted for reference resistor
|
||||
float ec_A; //ec value after adjustment for reference (at current temperature)
|
||||
float ec25_A; //ec value but temperature adjusted for 25 degC
|
||||
|
||||
float ec_adc_B;
|
||||
float ec_adc_adjusted_B; //adjusted for reference resistor
|
||||
float ec_B; //ec value after adjustment for reference (at current temperature)
|
||||
float ec25_B; //ec value but temperature adjusted for 25 degC
|
||||
float ec; //ec value after adjustment for reference (at current temperature)
|
||||
float ec25; //ec value but temperature adjusted for 25 degC
|
||||
|
||||
float ec_tempadjust_alpa=0.02;
|
||||
float ec_reference_adc=6016.88; //adc reference value for the calibration resistor measurement.
|
||||
|
|
@ -79,27 +66,21 @@ float ec_reference_adc=6016.88; //adc reference value for the calibration resist
|
|||
//float ec_calibration_polynom[]={1033.928052655456,-3.8909104921922895,0.005627541436014758,-4.103988840997024e-06,1.7231981870816133e-09,-4.433707707721975e-13,7.203892111369395e-17,-7.406549810844244e-21,4.667420606439905e-25,-1.6439457516812463e-29,2.477292190335455e-34}; //20220505
|
||||
//float ec_calibration_polynom[]={-323.68589929771457,0.5836096440900665,-0.000279737392438965,5.98673062873e-08,-5.4460235093798435e-12,1.8535134644431135e-16}; //20230509
|
||||
//float ec_calibration_polynom[]={212.6826331524675,-0.6043878865263305,0.000571551634082491,-1.827897106718841e-07,2.682337041246909e-11,-1.8368511021965982e-15,4.8269168538877025e-20}; //20230509 manuell
|
||||
float ec_calibration_polynom_A[]={18.953002079376887,-0.057529180570340156,7.44612274805891e-05,-8.847448650204697e-09,5.388914121653647e-13}; //20240423, graphite electrodes
|
||||
float ec_calibration_linearize_below_adc_A=2000; //use linear approximation below this adc value. 0=disable
|
||||
float ec_calibration_linear_lowADC_A=728; //x0
|
||||
float ec_calibration_linear_lowEC_A=0; //y0
|
||||
|
||||
|
||||
float ec_calibration_polynom_B[]={40.838922264426685,-0.08846039894456156,7.671298605466989e-05,-9.161423581523883e-09,5.529701600660142e-13}; //20240423, graphite electrodes
|
||||
float ec_calibration_linearize_below_adc_B=2000; //use linear approximation below this adc value. 0=disable
|
||||
float ec_calibration_linear_lowADC_B=728; //x0
|
||||
float ec_calibration_linear_lowEC_B=0; //y0
|
||||
float ec_calibration_polynom[]={-202.42892340068445,0.3775267988688599,-0.0001603031198536654,3.398964768344757e-08,-3.0277753798278316e-12,1.0137804308289433e-16}; //20230620, graphite electrodes
|
||||
float ec_calibration_linearize_below_adc=4000; //use linear approximation below this adc value. 0=disable
|
||||
float ec_calibration_linear_lowADC=746; //x0
|
||||
float ec_calibration_linear_lowEC=0; //y0
|
||||
|
||||
bool ec_measurementReady();
|
||||
void ec_startMeasurement();
|
||||
void ec_setRange(uint8_t range);
|
||||
void ec_connectProbe(bool, uint8_t);
|
||||
void ec_connectProbe(bool);
|
||||
void ec_releaseRelay();
|
||||
float ec_getECfromADC(float adc, float ec_calibration_polynom[], size_t len_ec_calibration_polynom, float ec_calibration_linearize_below_adc, float ec_calibration_linear_lowADC, float ec_calibration_linear_lowEC);
|
||||
float ec_getECfromADC(float adc);
|
||||
float ec_calculateEC25(float pEC,float pTemp);
|
||||
|
||||
void ec_setup() {
|
||||
/*
|
||||
|
||||
timing_ec_adc.minchange=0.0;
|
||||
timing_ec_adc.maxchange=250;
|
||||
timing_ec_adc.mintime=10*000;
|
||||
|
|
@ -124,14 +105,13 @@ void ec_setup() {
|
|||
timing_ec_sc.maxchange=50;
|
||||
timing_ec_sc.mintime=10*000;
|
||||
timing_ec_sc.maxtime=60*60*1000;
|
||||
*/
|
||||
|
||||
|
||||
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_PROBESELECT,OUTPUT); //LOW=Probe A, HIGH=Probe B
|
||||
ec_releaseRelay();
|
||||
|
||||
}
|
||||
|
|
@ -145,12 +125,10 @@ void ec_loop(unsigned long loopmillis) {
|
|||
case IDLE:
|
||||
|
||||
if (loopmillis>last_measurement_ec+EC_MEASUREMENT_INTERVAL || force_ec_measurement) { //start measurement if idle
|
||||
//Serial.println("DEBUG: Start measurement");
|
||||
last_measurement_ec=loopmillis;
|
||||
force_ec_measurement=false;
|
||||
ec_startMeasurement();
|
||||
ec_connectProbe(true,0); //Probe A
|
||||
|
||||
ec_connectProbe(true);
|
||||
|
||||
ecstate=MEASURE;
|
||||
}
|
||||
|
|
@ -158,58 +136,23 @@ void ec_loop(unsigned long loopmillis) {
|
|||
|
||||
case MEASURE:
|
||||
if (ec_measurementReady()) {
|
||||
//Serial.println("DEBUG: Measurement Ready");
|
||||
float ec_adc;
|
||||
float ec_adc_adjusted;
|
||||
float ec;
|
||||
float ec25;
|
||||
|
||||
ec_releaseRelay();
|
||||
ec_adc=getMean(ec_array,EC_ARRAY_SIZE);
|
||||
if (isValueArrayOK(ec_calib_array,EC_CALIB_ARRAY_SIZE,EC_ADC_UNAVAILABLE)){
|
||||
ec_calib_adc=getMean(ec_calib_array,EC_CALIB_ARRAY_SIZE);
|
||||
ec_adc_adjusted=mapf(ec_adc,0,ec_calib_adc,0,ec_reference_adc);
|
||||
if (probeselect==0) {
|
||||
ec=ec_getECfromADC(ec_adc_adjusted, ec_calibration_polynom_A, sizeof(ec_calibration_polynom_A), ec_calibration_linearize_below_adc_A, ec_calibration_linear_lowADC_A, ec_calibration_linear_lowEC_A);
|
||||
}else if (probeselect==1) {
|
||||
ec=ec_getECfromADC(ec_adc_adjusted, ec_calibration_polynom_B, sizeof(ec_calibration_polynom_B), ec_calibration_linearize_below_adc_B, ec_calibration_linear_lowADC_B, ec_calibration_linear_lowEC_B);
|
||||
}
|
||||
ec=ec_getECfromADC(ec_adc_adjusted);
|
||||
ec25=ec_calculateEC25(ec,tempC_reservoir);
|
||||
//Serial.println("DEBUG: EC OK");
|
||||
}else{
|
||||
ec_calib_adc=EC_ADC_UNAVAILABLE;
|
||||
ec_adc_adjusted=EC_ADC_UNAVAILABLE;
|
||||
ec=EC_UNAVAILABLE;
|
||||
ec25=EC_UNAVAILABLE;
|
||||
//Serial.println("DEBUG: EC unavailable");
|
||||
}
|
||||
|
||||
if (probeselect==0) {
|
||||
//Serial.println("DEBUG: Assigning to A");
|
||||
ec_adc_A=ec_adc;
|
||||
ec_adc_adjusted_A=ec_adc_adjusted;
|
||||
ec_A=ec;
|
||||
ec25_A=ec25;
|
||||
|
||||
last_measurement_ec=loopmillis;
|
||||
force_ec_measurement=false;
|
||||
ec_startMeasurement();
|
||||
probeselect=1; //Select Probe B
|
||||
ec_connectProbe(true,probeselect); //Probe B
|
||||
ecstate=MEASURE;
|
||||
|
||||
}else if(probeselect==1) {
|
||||
//Serial.println("DEBUG: Assigning to B");
|
||||
ec_adc_B=ec_adc;
|
||||
ec_adc_adjusted_B=ec_adc_adjusted;
|
||||
ec_B=ec;
|
||||
ec25_B=ec25;
|
||||
|
||||
probeselect=0; //Reset to Probe A
|
||||
ec_flag_measurement_available=true;
|
||||
ecstate=IDLE;
|
||||
}
|
||||
ec_flag_measurement_available=true;
|
||||
|
||||
ecstate=IDLE;
|
||||
}
|
||||
|
||||
break;
|
||||
|
|
@ -266,36 +209,21 @@ bool ec_measurementReady(){
|
|||
}
|
||||
|
||||
|
||||
void ec_connectProbe(bool relay, uint8_t probeselect) {
|
||||
void ec_connectProbe(bool relay) {
|
||||
bool val=digitalRead(EC_PIN_RELAY_PROBE);
|
||||
bool valsel=digitalRead(EC_PIN_RELAY_PROBESELECT);
|
||||
if (val!=relay) { //write only if different
|
||||
digitalWrite(EC_PIN_RELAY_PROBE,relay);
|
||||
//Serial.print("DEBUG: Set Relay to "); Serial.println(relay);
|
||||
ec_last_change_relay=millis();
|
||||
}
|
||||
if (valsel!=probeselect) { //write only if different
|
||||
if (probeselect==0) {
|
||||
digitalWrite(EC_PIN_RELAY_PROBESELECT,false);
|
||||
//Serial.println("DEBUG: Selected Probe A");
|
||||
}else if (probeselect==1) {
|
||||
digitalWrite(EC_PIN_RELAY_PROBESELECT,true);
|
||||
//Serial.println("DEBUG: Selected Probe B");
|
||||
}
|
||||
ec_last_change_relay=millis();
|
||||
}
|
||||
}
|
||||
|
||||
void ec_releaseRelay() {
|
||||
digitalWrite(EC_PIN_RELAY_PROBE,LOW);
|
||||
digitalWrite(EC_PIN_RELAY_PROBESELECT,LOW);
|
||||
//Serial.println("DEBUG: Released Relays");
|
||||
ec_last_change_relay=millis();
|
||||
}
|
||||
|
||||
float ec_getECfromADC(float adc, float ec_calibration_polynom[], size_t len_ec_calibration_polynom, float ec_calibration_linearize_below_adc, float ec_calibration_linear_lowADC, float ec_calibration_linear_lowEC) {
|
||||
//uint8_t polynom_order=sizeof(ec_calibration_polynom) / sizeof(ec_calibration_polynom[0]);
|
||||
uint8_t polynom_order=len_ec_calibration_polynom / sizeof(ec_calibration_polynom[0]);
|
||||
float ec_getECfromADC(float adc) {
|
||||
uint8_t polynom_order=sizeof(ec_calibration_polynom) / sizeof(ec_calibration_polynom[0]);
|
||||
double _ec=0;
|
||||
if (adc>=ec_calibration_linearize_below_adc) { //adc is in range where polynomial approximation fits well
|
||||
for (uint8_t i=0;i<polynom_order;i++) {
|
||||
|
|
|
|||
|
|
@ -1,312 +0,0 @@
|
|||
#ifndef _EC_H_
|
||||
#define _EC_H_
|
||||
|
||||
#include <Arduino.h>
|
||||
|
||||
#define EC_PIN_RELAY_PROBE 27
|
||||
#define EC_PIN_RELAY_CALIBRATION 26
|
||||
#define EC_PIN_RELAY_RANGE 25
|
||||
|
||||
|
||||
#define EC_PIN_ADC 4
|
||||
#define EC_PIN_FREQ 5
|
||||
#define EC_PWM_CH 0
|
||||
#define EC_RESOLUTION 8
|
||||
#define EC_FREQUENCY 5000
|
||||
|
||||
#define EC_ARRAY_SIZE 128
|
||||
uint16_t ec_array_rangeLow[EC_ARRAY_SIZE];
|
||||
uint16_t ec_array_rangeHigh[EC_ARRAY_SIZE];
|
||||
uint16_t ec_array_pos=EC_ARRAY_SIZE*2;
|
||||
#define EC_MEASUREMENT_INTERVAL 10000 //complete filtered measurement every x ms
|
||||
//One filtered measurement takes EC_READ_INTERVAL*EC_ARRAY_SIZE*2
|
||||
#define EC_READ_INTERVAL 5 //interval of reading adc value inside a measurement
|
||||
|
||||
|
||||
|
||||
float ec_calib_rangeLow_Rlow=0; //adc value for low value resistor on low resistor value range
|
||||
float ec_calib_rangeLow_Rhigh=0; //adc value for high value resistor on low resistor value range
|
||||
float ec_calib_rangeHigh_Rlow=0; //adc value for low value resistor on high resistor value range
|
||||
float ec_calib_rangeHigh_Rhigh=0; //adc value for high value resistor on high resistor value range
|
||||
const float ec_calibresistor_low=990; //value of low value calibration resistor. Low is Relay NO
|
||||
const float ec_calibresistor_high=9943; //value of high value calibration resistor. HIGH is Relay NC
|
||||
|
||||
unsigned long ec_last_calibration=0; //millis of last calibration
|
||||
#define EC_CALIBRATION_VALID_TIME 120000 //time in ms a calibration is valid for
|
||||
#define EC_RELAY_SWITCH_SETTLETIME 500 //time until voltage of ec circuit has settled
|
||||
|
||||
unsigned long ec_last_change_relay=0; //millis of last relay change
|
||||
|
||||
enum ECState{IDLE,CALIBRATELOW,CALIBRATEHIGH,MEASURE};
|
||||
|
||||
ECState ecstate=CALIBRATELOW;
|
||||
|
||||
|
||||
bool ec_measurementReady();
|
||||
void ec_startMeasurement();
|
||||
void ec_setRange(bool);
|
||||
void ec_connectProbe(bool);
|
||||
void ec_setCalibration(bool calib);
|
||||
void ec_releaseRelay();
|
||||
void ec_startCalibration();
|
||||
void ec_checkIfSettleTimeOK();
|
||||
float ec_getResistance(float adc,float caliblow,float resistorlow,float calibhigh,float resistorhigh);
|
||||
|
||||
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_CALIBRATION,OUTPUT); //LOW=NC Calibration Resistor, HIGH=NO Calib. Res.
|
||||
pinMode(EC_PIN_RELAY_RANGE,OUTPUT); //LOW=NC Range Resistor, HIGH=NO Range Resistor
|
||||
ec_releaseRelay();
|
||||
|
||||
|
||||
ec_startCalibration();
|
||||
}
|
||||
|
||||
void ec_loop(unsigned long loopmillis) {
|
||||
static unsigned long last_measurement_ec=0;
|
||||
static unsigned long last_read_ec=0;
|
||||
|
||||
switch (ecstate) {
|
||||
case IDLE:
|
||||
|
||||
if (loopmillis>ec_last_calibration+EC_CALIBRATION_VALID_TIME) { //calibration needed
|
||||
ec_last_calibration=loopmillis;
|
||||
ecstate=CALIBRATELOW;
|
||||
|
||||
ec_startCalibration();
|
||||
}
|
||||
|
||||
|
||||
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;
|
||||
Serial.println("EC Take Measurement");
|
||||
}
|
||||
break;
|
||||
|
||||
|
||||
case CALIBRATELOW:
|
||||
if (ec_measurementReady()) {
|
||||
//Serial.println("EC CALIBRATELOW measurement ready");
|
||||
//save measurement
|
||||
ec_calib_rangeLow_Rlow=getMean(ec_array_rangeLow,EC_ARRAY_SIZE);
|
||||
ec_calib_rangeHigh_Rlow=getMean(ec_array_rangeHigh,EC_ARRAY_SIZE);
|
||||
|
||||
//ec_checkIfSettleTimeOK();
|
||||
|
||||
//Switch to High calibration
|
||||
ecstate=CALIBRATEHIGH;
|
||||
|
||||
ec_setCalibration(HIGH);
|
||||
ec_setRange(LOW);
|
||||
ec_startMeasurement();
|
||||
//Serial.println("EC Start calibration high");
|
||||
}
|
||||
break;
|
||||
|
||||
case CALIBRATEHIGH:
|
||||
if (ec_measurementReady()) {
|
||||
//Serial.println("EC CALIBRATEHIGH measurement ready");
|
||||
//save measurement
|
||||
ec_calib_rangeLow_Rhigh=getMean(ec_array_rangeLow,EC_ARRAY_SIZE);
|
||||
ec_calib_rangeHigh_Rhigh=getMean(ec_array_rangeHigh,EC_ARRAY_SIZE);
|
||||
|
||||
//ec_checkIfSettleTimeOK();
|
||||
|
||||
//Serial.println("EC Release Relay");
|
||||
ec_releaseRelay();
|
||||
|
||||
ecstate=IDLE;
|
||||
|
||||
/*
|
||||
Serial.println("EC Calibration done");
|
||||
Serial.print("ec_calib_rangeLow_Rlow="); Serial.println(ec_calib_rangeLow_Rlow);
|
||||
Serial.print("ec_calib_rangeHigh_Rlow="); Serial.println(ec_calib_rangeHigh_Rlow);
|
||||
Serial.print("ec_calib_rangeLow_Rhigh="); Serial.println(ec_calib_rangeLow_Rhigh);
|
||||
Serial.print("ec_calib_rangeHigh_Rhigh="); Serial.println(ec_calib_rangeHigh_Rhigh);
|
||||
*/
|
||||
Serial.println("EC Calibration Result: ");
|
||||
Serial.print(ec_calib_rangeLow_Rlow);
|
||||
Serial.print(", "); Serial.print(ec_calib_rangeHigh_Rlow);
|
||||
Serial.print(", "); Serial.print(ec_calib_rangeLow_Rhigh);
|
||||
Serial.print(", "); Serial.println(ec_calib_rangeHigh_Rhigh);
|
||||
|
||||
|
||||
}
|
||||
break;
|
||||
|
||||
case MEASURE:
|
||||
if (ec_measurementReady()) {
|
||||
ec_releaseRelay();
|
||||
float adc_rangelow=getMean(ec_array_rangeLow,EC_ARRAY_SIZE);
|
||||
float adc_rangehigh=getMean(ec_array_rangeHigh,EC_ARRAY_SIZE);
|
||||
|
||||
Serial.println();
|
||||
float resistance_rangelow=ec_getResistance(adc_rangelow,ec_calib_rangeLow_Rlow,ec_calibresistor_low,ec_calib_rangeLow_Rhigh,ec_calibresistor_high);
|
||||
Serial.print("Range Low: ADC="); Serial.print(adc_rangelow); Serial.print(", resistance="); Serial.println(resistance_rangelow);
|
||||
Serial.println();
|
||||
float resistance_rangehigh=ec_getResistance(adc_rangehigh,ec_calib_rangeHigh_Rlow,ec_calibresistor_low,ec_calib_rangeHigh_Rhigh,ec_calibresistor_high);
|
||||
Serial.print("Range High: ADC="); Serial.print(adc_rangehigh); Serial.print(", resistance="); Serial.println(resistance_rangehigh);
|
||||
ecstate=IDLE;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
if (loopmillis>last_read_ec+EC_READ_INTERVAL && ec_array_pos/2<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;
|
||||
|
||||
if (ec_array_pos<EC_ARRAY_SIZE){ //low range
|
||||
ec_setRange(LOW);
|
||||
}else{ //high range
|
||||
ec_setRange(HIGH);
|
||||
}
|
||||
|
||||
if (loopmillis>ec_last_change_relay+EC_RELAY_SWITCH_SETTLETIME) { //values have settled
|
||||
uint16_t value=analogRead(EC_PIN_ADC);
|
||||
if (ec_array_pos<EC_ARRAY_SIZE){ //low range
|
||||
ec_array_rangeLow[ec_array_pos%EC_ARRAY_SIZE]=value;
|
||||
|
||||
}else{ //high range
|
||||
ec_array_rangeHigh[ec_array_pos%EC_ARRAY_SIZE]=value;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
if (ec_array_pos==0) {
|
||||
Serial.println(""); Serial.print("Lowrange:");
|
||||
}
|
||||
if (ec_array_pos==EC_ARRAY_SIZE) {
|
||||
Serial.println(""); Serial.print("Highrange:");
|
||||
}
|
||||
Serial.print(value); Serial.print(" ");
|
||||
if (ec_array_pos==EC_ARRAY_SIZE*2-1) {
|
||||
Serial.println("");
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
ec_array_pos++;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
void ec_startCalibration() {
|
||||
//Switch to Low calibration
|
||||
ec_setCalibration(LOW);
|
||||
ec_setRange(LOW);
|
||||
ec_startMeasurement();
|
||||
Serial.println("EC Started Calibration");
|
||||
}
|
||||
|
||||
void ec_startMeasurement() {
|
||||
ec_array_pos=0;
|
||||
}
|
||||
|
||||
bool ec_measurementReady(){
|
||||
if (ec_array_pos>=EC_ARRAY_SIZE*2) { //reached end of both arrays
|
||||
return true;
|
||||
}else{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void ec_setRange(bool range) {
|
||||
//range low means low resistor value -> NO -> relay High
|
||||
bool val=digitalRead(EC_PIN_RELAY_RANGE);
|
||||
if (val!=!range) { //write only if different
|
||||
digitalWrite(EC_PIN_RELAY_RANGE,!range);
|
||||
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_setCalibration(bool calib) {
|
||||
//calib low means low resistor value -> NO -> relay high
|
||||
ec_connectProbe(false);
|
||||
bool val=digitalRead(EC_PIN_RELAY_CALIBRATION);
|
||||
if (val!=!calib) { //write only if different
|
||||
digitalWrite(EC_PIN_RELAY_CALIBRATION,!calib);
|
||||
ec_last_change_relay=millis();
|
||||
}
|
||||
}
|
||||
|
||||
void ec_releaseRelay() {
|
||||
digitalWrite(EC_PIN_RELAY_PROBE,LOW);
|
||||
digitalWrite(EC_PIN_RELAY_CALIBRATION,LOW);
|
||||
digitalWrite(EC_PIN_RELAY_RANGE,LOW);
|
||||
ec_last_change_relay=millis();
|
||||
}
|
||||
|
||||
void ec_checkIfSettleTimeOK() {
|
||||
/*
|
||||
Serial.print("ec_array_rangeLow[0]="); Serial.println(ec_array_rangeLow[0]);
|
||||
Serial.print("rangeLow min="); Serial.println(getMin(ec_array_rangeLow,EC_ARRAY_SIZE));
|
||||
Serial.print("rangeLow max="); Serial.println(getMax(ec_array_rangeLow,EC_ARRAY_SIZE));
|
||||
*/
|
||||
if (ec_array_rangeLow[0]<=getMin(ec_array_rangeLow,EC_ARRAY_SIZE) || ec_array_rangeLow[0]>=getMax(ec_array_rangeLow,EC_ARRAY_SIZE)){
|
||||
//is first value the highest or lowest?
|
||||
Serial.println("Warning: EC_RELAY_SWITCH_SETTLETIME might be too low! (ec_calib_rangeLow_Rlow)");
|
||||
}
|
||||
|
||||
/*
|
||||
Serial.print("ec_array_rangeHigh[0]="); Serial.println(ec_array_rangeHigh[0]);
|
||||
Serial.print("rangeHigh min="); Serial.println(getMin(ec_array_rangeHigh,EC_ARRAY_SIZE));
|
||||
Serial.print("rangeHigh max="); Serial.println(getMax(ec_array_rangeHigh,EC_ARRAY_SIZE));
|
||||
*/
|
||||
if (ec_array_rangeHigh[0]<=getMin(ec_array_rangeHigh,EC_ARRAY_SIZE) || ec_array_rangeHigh[0]>=getMax(ec_array_rangeHigh,EC_ARRAY_SIZE)){
|
||||
//is first value the highest or lowest?
|
||||
Serial.println("Warning: EC_RELAY_SWITCH_SETTLETIME might be too low! (ec_array_rangeHigh)");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
float ec_getResistance(float adc,float caliblow,float resistorlow,float calibhigh,float resistorhigh)
|
||||
{
|
||||
//adc = adc reading to calculate resistance for
|
||||
//caliblow = adc value from calibration. Low resistance
|
||||
//resistorlow = actual resistor value. Low resistance
|
||||
//calibhjgh = adc value from calibration. High resistance
|
||||
//resistorhigh = actual resistor value. High resistance
|
||||
|
||||
//y=mx+a;
|
||||
//resistorlow=m*caliblow+a;
|
||||
//resistorhigh=m*calibhigh+a;
|
||||
|
||||
//linear interpolation interpolate
|
||||
double m=(resistorhigh-resistorlow)/(calibhigh-caliblow);
|
||||
float a=resistorlow-m*caliblow;
|
||||
|
||||
Serial.print("m="); Serial.println(m);
|
||||
Serial.print("a="); Serial.println(a);
|
||||
|
||||
return m*adc+a;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -140,7 +140,6 @@ void temperature_loop(unsigned long loopmillis) {
|
|||
}
|
||||
}
|
||||
|
||||
/* temporarily disabled
|
||||
tempC_air = sensors.getTempC(thermometerAir);
|
||||
if (tempC_air == DEVICE_DISCONNECTED_C)
|
||||
{
|
||||
|
|
@ -153,7 +152,6 @@ void temperature_loop(unsigned long loopmillis) {
|
|||
tempCmean_air=DEVICE_DISCONNECTED_C;
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
tempC_case = sensors.getTempC(thermometerCase);
|
||||
if (tempC_case == DEVICE_DISCONNECTED_C)
|
||||
|
|
|
|||
|
|
@ -1,99 +0,0 @@
|
|||
#ifndef _WATERLEVEL_H_
|
||||
#define _WATERLEVEL_H_
|
||||
|
||||
|
||||
#include <HCSR04.h>
|
||||
#define HCSR04_PIN_ECHO 17
|
||||
#define HCSR04_PIN_TRIGGER 16
|
||||
#define HCSR04_TIMEOUT 5000 //default is 100000 (uS)
|
||||
#define READINTERVAL_HCSR04 200
|
||||
|
||||
#define WATERLEVELMEAN_SIZE 32
|
||||
#define WATERLEVELMEAN_FILTER_CUTOFF 8 //max value is around WATERLEVELMEAN_SIZE/2
|
||||
float waterlevelMean_array[WATERLEVELMEAN_SIZE];
|
||||
uint16_t waterlevelMean_array_pos=0;
|
||||
#define WATERLEVEL_UNAVAILABLE -1
|
||||
float waterlevel=WATERLEVEL_UNAVAILABLE; //distance from floor to water surface [mm]
|
||||
float watervolume=WATERLEVEL_UNAVAILABLE; //calculated Volume in Reservoir
|
||||
|
||||
uint16_t waterlevel_failcounter=0;
|
||||
#define WATERLEVEL_MAXFAILS 15 //maximum counter value
|
||||
#define WATERLEVEL_FAILTHRESHOLD 10 //if failcounter is greater or equal this value waterlevel will not be valid
|
||||
|
||||
//Calibration
|
||||
float waterlevel_calib_offset_measured=0; //Sollwert
|
||||
float waterlevel_calib_offset_sensor=178.67; //Istwert
|
||||
|
||||
float waterlevel_calib_reservoirArea=27*36.5; //area in cm^2
|
||||
|
||||
|
||||
float waterlevel_heightToVolume(float distance);
|
||||
|
||||
|
||||
void waterlevel_setup() {
|
||||
|
||||
//HCSR04.begin(HCSR04_PIN_TRIGGER, HCSR04_PIN_ECHO);
|
||||
HCSR04.begin(HCSR04_PIN_TRIGGER, HCSR04_PIN_ECHO,HCSR04_TIMEOUT, HCSR04.eUltraSonicUnlock_t::unlockSkip);
|
||||
for (uint16_t i=0;i<WATERLEVELMEAN_SIZE;i++) {
|
||||
waterlevelMean_array[i]=-1; //-1 is also timeout value
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
void waterlevel_loop(unsigned long loopmillis) {
|
||||
|
||||
static unsigned long last_read_hcsr04;
|
||||
if (loopmillis>=last_read_hcsr04+READINTERVAL_HCSR04) {
|
||||
last_read_hcsr04=loopmillis;
|
||||
float temperature=20.0;
|
||||
if (tempCmean_air!=DEVICE_DISCONNECTED_C) { //sensor ok
|
||||
temperature=tempCmean_air;
|
||||
}
|
||||
|
||||
double* distances = HCSR04.measureDistanceMm(temperature);
|
||||
double distance=distances[0];
|
||||
//Serial.print("Distance reading:"); Serial.println(distance);
|
||||
|
||||
if (distance!=WATERLEVEL_UNAVAILABLE) { //successful
|
||||
waterlevelMean_array[waterlevelMean_array_pos]=distance;
|
||||
waterlevelMean_array_pos++;
|
||||
waterlevelMean_array_pos%=WATERLEVELMEAN_SIZE;
|
||||
if (waterlevel_failcounter>0) { //reduce failcounter if sucessfull
|
||||
waterlevel_failcounter--;
|
||||
}
|
||||
}else{
|
||||
if (waterlevel_failcounter<WATERLEVEL_MAXFAILS) {
|
||||
waterlevel_failcounter++;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
if (isValueArrayOKf(waterlevelMean_array,WATERLEVELMEAN_SIZE,WATERLEVEL_UNAVAILABLE)){
|
||||
//float _distance=getFilteredf(waterlevelMean_array,WATERLEVELMEAN_SIZE,WATERLEVELMEAN_FILTER_CUTOFF);
|
||||
float _distance=getMaxf(waterlevelMean_array,WATERLEVELMEAN_SIZE);
|
||||
|
||||
//Invert distance and offset
|
||||
waterlevel=distance-(waterlevel_calib_offset_sensor+waterlevel_calib_offset_measured);
|
||||
watervolume=waterlevel_heightToVolume(_distance);
|
||||
|
||||
//float _meanWaterlevel=getMeanf(waterlevelMean,WATERLEVELMEAN_SIZE);
|
||||
//Serial.print("\t Dist="); Serial.print(_filteredWaterlevel); Serial.print("mm"); Serial.print("(+- "); Serial.print((getMaxf(waterlevelMean,WATERLEVELMEAN_SIZE)-getMinf(waterlevelMean,WATERLEVELMEAN_SIZE))/2.0); Serial.print(")"); Serial.print(" [mean="); Serial.print(_meanWaterlevel); Serial.print("]");
|
||||
}
|
||||
|
||||
if (waterlevel_failcounter>=WATERLEVEL_FAILTHRESHOLD) { //too many failed readings
|
||||
waterlevel=WATERLEVEL_UNAVAILABLE;
|
||||
watervolume=WATERLEVEL_UNAVAILABLE;
|
||||
/*if (debug) {
|
||||
Serial.print("Waterlevel Failcounter="); Serial.println(waterlevel_failcounter);
|
||||
}*/
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
float waterlevel_heightToVolume(float distance){
|
||||
return waterlevel_calib_reservoirArea/100 * distance/100; //area[cm^2] in dm^2 * height in dm = dm^3= L
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
|
||||
const char ssid[] = "fischnetziot";
|
||||
const char pass[] = "LiMkJ1sVcEAU68MPEgJ";
|
||||
const char ssid[] = "";
|
||||
const char pass[] = "";
|
||||
const char mqtt_host[] = "10.0.0.1";
|
||||
|
||||
const char client_id[] = "hydroponic";
|
||||
|
|
@ -1,5 +1,3 @@
|
|||
#Use venv
|
||||
|
||||
import numpy as np
|
||||
|
||||
from scipy.optimize import curve_fit
|
||||
|
|
@ -10,36 +8,32 @@ import matplotlib.pyplot as plt
|
|||
from pandas import *
|
||||
|
||||
# reading CSV file
|
||||
data = read_csv("20240423_EC_Calibration.csv")
|
||||
data = read_csv("20230620_NaCl_raw.csv")
|
||||
|
||||
# converting column data to list
|
||||
solutionAdded = data['solutionAdded'].tolist() #in ml
|
||||
#solutionAdded = data['solutionAdded'].tolist() #in ml
|
||||
tempReservoir = data['tempReservoir'].tolist() #in C
|
||||
adc = data['ECadcAdjusted_B'].tolist() #adc reading
|
||||
adc = data['ECadcAdjusted'].tolist() #adc reading
|
||||
|
||||
#solutionConcentration=5924.8 #mg/L NaCl
|
||||
solutionConcentration=5690 #mg/L NaCl
|
||||
startWaterAmount=300 #mL (same unit as solutionAded)
|
||||
solutionConcentration=5924.8 #mg/L NaCl
|
||||
startWaterAmount=0.3 #L
|
||||
|
||||
ppmToECfactor=1/0.46
|
||||
|
||||
concentration = [x*solutionConcentration/(startWaterAmount+x) for x in solutionAdded]
|
||||
ECcalculated = [x*ppmToECfactor for x in concentration] #uS/cm
|
||||
#concentration = [x*solutionConcentration/(startWaterAmount+x) for x in solutionAdded]
|
||||
#ECcalculated = [x*ppmToECfactor for x in concentration] #uS/cm
|
||||
|
||||
#ECmeasured = data['ecMeasured'].tolist() #in C
|
||||
ECmeasured = data['ecMeasured'].tolist() #in C
|
||||
|
||||
print("Concentration")
|
||||
print(concentration)
|
||||
print("")
|
||||
print("ECcalculated")
|
||||
print(ECcalculated)
|
||||
#print(concentration)
|
||||
#print(ECcalculated)
|
||||
|
||||
|
||||
|
||||
x = adc
|
||||
|
||||
y = ECcalculated
|
||||
#y = ECmeasured
|
||||
#y = ECcalculated
|
||||
y = ECmeasured
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +0,0 @@
|
|||
numpy==1.22
|
||||
scipy
|
||||
matplotlib
|
||||
pandas
|
||||
100
src/main.cpp
100
src/main.cpp
|
|
@ -4,13 +4,9 @@
|
|||
|
||||
#include "wifi_functions.h"
|
||||
|
||||
bool debug=false; //print Serial information
|
||||
bool mqtt=false;
|
||||
bool eccalibrationoutput=true; //serial output for ec calibration
|
||||
/* Write to file with:
|
||||
sudo stty -F /dev/ttyUSB0 115200
|
||||
cat /dev/ttyUSB0 | tee received.txt
|
||||
*/
|
||||
bool debug=true; //print Serial information
|
||||
bool mqtt=true;
|
||||
bool eccalibrationoutput=false; //serial output for ec calibration
|
||||
|
||||
|
||||
|
||||
|
|
@ -79,8 +75,8 @@ void setup() {
|
|||
Serial.println("Setup EC");
|
||||
ec_setup();
|
||||
|
||||
//Serial.println("Setup Waterlevel");
|
||||
//waterlevel_setup(); //temporarily disabled
|
||||
Serial.println("Setup Waterlevel");
|
||||
waterlevel_setup();
|
||||
|
||||
Serial.println("Setup Temperature");
|
||||
temperature_setup();
|
||||
|
|
@ -120,7 +116,7 @@ void loop() {
|
|||
|
||||
temperature_loop(loopmillis);
|
||||
|
||||
//waterlevel_loop(loopmillis);
|
||||
waterlevel_loop(loopmillis);
|
||||
|
||||
flow_loop(loopmillis);
|
||||
|
||||
|
|
@ -136,23 +132,11 @@ void loop() {
|
|||
delay(100);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
if (eccalibrationoutput && !digitalRead(PIN_BUTTON) && !getReading) {
|
||||
if (!isValueArrayOK(ec_calib_array,EC_CALIB_ARRAY_SIZE,EC_ADC_UNAVAILABLE)) {
|
||||
for (uint8_t blink=0;blink<5;blink++) {
|
||||
digitalWrite(PIN_LED,HIGH);
|
||||
delay(100);
|
||||
digitalWrite(PIN_LED,LOW);
|
||||
delay(100);
|
||||
}
|
||||
}else{
|
||||
getReading=true;
|
||||
force_ec_measurement=true;
|
||||
ec_flag_measurement_available=false;
|
||||
digitalWrite(PIN_LED,HIGH);
|
||||
}
|
||||
getReading=true;
|
||||
force_ec_measurement=true;
|
||||
ec_flag_measurement_available=false;
|
||||
digitalWrite(PIN_LED,HIGH);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -164,10 +148,8 @@ void loop() {
|
|||
Serial.print(loopmillis); Serial.print(",");
|
||||
Serial.print(tempCmean_reservoir); Serial.print(",");
|
||||
Serial.print(ec_calib_adc); Serial.print(",");
|
||||
Serial.print(ec_adc_A); Serial.print(",");
|
||||
Serial.print(ec_adc_adjusted_A); Serial.print(",");
|
||||
Serial.print(ec_adc_B); Serial.print(",");
|
||||
Serial.print(ec_adc_adjusted_B);
|
||||
Serial.print(ec_adc); Serial.print(",");
|
||||
Serial.print(ec_adc_adjusted);
|
||||
Serial.println();
|
||||
}
|
||||
|
||||
|
|
@ -182,7 +164,7 @@ void loop() {
|
|||
if (sm_mean1==SM_DISCONNECTED || sm_mean2==SM_DISCONNECTED) {
|
||||
valueError=true;
|
||||
}
|
||||
if (ec_A==EC_UNAVAILABLE || ec_B==EC_UNAVAILABLE){
|
||||
if (ec==EC_UNAVAILABLE){
|
||||
valueError=true;
|
||||
}
|
||||
|
||||
|
|
@ -231,25 +213,14 @@ void loop() {
|
|||
Serial.print("Flow = "); Serial.print(flow);
|
||||
Serial.println();
|
||||
|
||||
Serial.print("EC ec_calib_adc,ec_adc_A,ec_adc_adjusted_A = ");
|
||||
Serial.print("EC ec_calib_adc,ec_adc,ec_adc_adjusted = ");
|
||||
Serial.print(ec_calib_adc); Serial.print(",");
|
||||
Serial.print(ec_adc_A); Serial.print(",");
|
||||
Serial.print(ec_adc_adjusted_A);
|
||||
Serial.print(ec_adc); Serial.print(",");
|
||||
Serial.print(ec_adc_adjusted);
|
||||
Serial.println();
|
||||
Serial.print("EC ec_A,ec25_A = ");
|
||||
Serial.print(ec_A); Serial.print(",");
|
||||
Serial.print(ec25_A);
|
||||
Serial.println();
|
||||
|
||||
|
||||
Serial.print("EC ec_calib_adc,ec_adc_B,ec_adc_adjusted_B = ");
|
||||
Serial.print(ec_calib_adc); Serial.print(",");
|
||||
Serial.print(ec_adc_B); Serial.print(",");
|
||||
Serial.print(ec_adc_adjusted_B);
|
||||
Serial.println();
|
||||
Serial.print("EC ec_B,ec25_B = ");
|
||||
Serial.print(ec_B); Serial.print(",");
|
||||
Serial.print(ec25_B);
|
||||
Serial.print("EC ec,ec25 = ");
|
||||
Serial.print(ec); Serial.print(",");
|
||||
Serial.print(ec25);
|
||||
Serial.println();
|
||||
|
||||
Serial.print("Waterlevel,Volume = ");
|
||||
|
|
@ -302,35 +273,18 @@ void loop() {
|
|||
|
||||
if (ec_flag_measurement_available){
|
||||
ec_flag_measurement_available=false;
|
||||
|
||||
if (ec_adc!=0) {
|
||||
publishValue("ec/adc",ec_adc,0);
|
||||
}
|
||||
if (ec_calib_adc!=0) {
|
||||
publishValue("ec/eccalibadc",ec_calib_adc,0);
|
||||
}
|
||||
|
||||
//Probe A
|
||||
if (ec_adc_A!=0) {
|
||||
publishValue("ecA/adc",ec_adc_A,0);
|
||||
if (ec_adc_adjusted!=0) {
|
||||
publishValue("ec/adcadjusted",ec_adc_adjusted,0);
|
||||
}
|
||||
|
||||
if (ec_adc_adjusted_A!=0) {
|
||||
publishValue("ecA/adcadjusted",ec_adc_adjusted_A,0);
|
||||
}
|
||||
if (ec_A!=EC_UNAVAILABLE){
|
||||
publishValue("ecA/ec",ec_A,0);
|
||||
publishValue("ecA/sc",ec25_A,0);
|
||||
}
|
||||
|
||||
//Probe B
|
||||
if (ec_adc_B!=0) {
|
||||
publishValue("ecB/adc",ec_adc_B,0);
|
||||
}
|
||||
|
||||
if (ec_adc_adjusted_B!=0) {
|
||||
publishValue("ecB/adcadjusted",ec_adc_adjusted_B,0);
|
||||
}
|
||||
if (ec_B!=EC_UNAVAILABLE){
|
||||
publishValue("ecB/ec",ec_B,0);
|
||||
publishValue("ecB/sc",ec25_B,0);
|
||||
if (ec!=EC_UNAVAILABLE){
|
||||
publishValue("ec/ec",ec,0);
|
||||
publishValue("ec/sc",ec25,0);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue