Compare commits

..

No commits in common. "9e539682e8b7fc3680591d47841cd6def206fe96" and "c63b4d01f0ee712b4be2da29cce7c54186e6a764" have entirely different histories.

6 changed files with 313 additions and 403 deletions

View File

@ -1,53 +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_CALIBRATION_RESISTOR_NC 100000
#define EC_CALIBRATION_RESISTOR_NO 1000
#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 1024
uint16_t ec_array[EC_ARRAY_SIZE];
uint16_t ec_array_pos=0;
unsigned long last_read_ec=0;
#define EC_READ_INTERVAL 1
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);
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
digitalWrite(EC_PIN_RELAY_PROBE,LOW);
digitalWrite(EC_PIN_RELAY_CALIBRATION,LOW);
digitalWrite(EC_PIN_RELAY_RANGE,LOW);
}
void ec_loop(unsigned long loopmillis, unsigned long pInterval) {
if (loopmillis>last_read_ec+pInterval) {
last_read_ec=loopmillis;
ec_array_pos++;
flag_print= ec_array_pos==EC_ARRAY_SIZE;
ec_array_pos%=EC_ARRAY_SIZE;
ec_array[ec_array_pos]=analogRead(EC_PIN_ADC);
//Serial.print(ec_array[ec_array_pos]); Serial.print(" ");
}
}
#endif

View File

@ -1,38 +0,0 @@
#ifndef _FLOW_H_
#define _FLOW_H_
#define FLOW_PIN 19
uint16_t flow_counter=0; //maximum counts/s measured with Eden 128 Pump was 171
void IRAM_ATTR isr_flow();
unsigned long last_read_flow=0;
#define READINTERVAL_FLOW 1000
float flow_factor=7.5; //F=7.5*flowrate[L/min]
float flow;
uint32_t flow_counter_sum=0;
void flow_setup() {
pinMode(FLOW_PIN, INPUT_PULLUP);
attachInterrupt(FLOW_PIN, isr_flow, CHANGE);
}
void flow_loop(unsigned long loopmillis, unsigned long pInterval) {
if (loopmillis>=last_read_flow+pInterval) {
flow=flow_counter*1000.0/(loopmillis-last_read_flow)/2.0; //Frequency [Hz]
flow/=flow_factor; //[L/min]
flow_counter=0;
last_read_flow=loopmillis;
}
}
void IRAM_ATTR isr_flow() {
flow_counter++;
flow_counter_sum++;
}
#endif

View File

@ -1,117 +0,0 @@
#ifndef _HELPFUNCTIONS_H_
#define _HELPFUNCTIONS_H_
#include <Arduino.h>
#include <ArduinoSort.h>
float getMean(uint16_t *parray,uint16_t psize);
float getMeanf(float *parray,uint16_t psize);
uint16_t getMin(uint16_t *parray, uint16_t psize);
uint16_t getMax(uint16_t *parray, uint16_t psize);
float getMaxf(float *parray,uint16_t psize);
float getMinf(float *parray, uint16_t psize);
bool isValueArrayOK(uint16_t *parray,uint16_t psize, uint16_t pcheck);
bool isValueArrayOKf(float *parray,uint16_t psize, float pcheck);
float getFilteredf(float *parray,uint16_t psize, uint16_t pcutOff);
float getMean(uint16_t *parray,uint16_t psize) {
double mean=0;
for (uint16_t i=0;i<psize;i++) {
mean+=parray[i];
}
return mean/psize;
}
float getMeanf(float *parray,uint16_t psize) {
double mean=0;
for (uint16_t i=0;i<psize;i++) {
mean+=parray[i];
}
return mean/psize;
}
bool isValueArrayOK(uint16_t *parray,uint16_t psize, uint16_t pcheck) { //check if array has error values
for (uint16_t i=0;i<psize;i++) {
if (parray[i]==pcheck){
return false;
}
}
return true;
}
bool isValueArrayOKf(float *parray,uint16_t psize, float pcheck) { //check if array has error values
for (uint16_t i=0;i<psize;i++) {
if (parray[i]==pcheck){
return false;
}
}
return true;
}
uint16_t getMin(uint16_t *parray, uint16_t psize) {
uint16_t min=65535;
for (uint16_t i=0;i<psize;i++) {
if (parray[i]<min) {
min=parray[i];
}
}
return min;
}
uint16_t getMax(uint16_t *parray,uint16_t psize) {
uint16_t max=0;
for (uint16_t i=0;i<psize;i++) {
if (parray[i]>max) {
max=parray[i];
}
}
return max;
}
float getMinf(float *parray, uint16_t psize) {
float min=65535;
for (uint16_t i=0;i<psize;i++) {
if (parray[i]<min) {
min=parray[i];
}
}
return min;
}
float getMaxf(float *parray,uint16_t psize) {
float max=0;
for (uint16_t i=0;i<psize;i++) {
if (parray[i]>max) {
max=parray[i];
}
}
return max;
}
float getFilteredf(float *parray,uint16_t psize, uint16_t pcutOff) {
//cuts off lowest and highest pcutOff values from array, then returns the mean of the psize-2*pcutOff center values.
//pcutOff < psize/2
float _copy[psize];
std::copy(parray,parray + psize, _copy);
sortArray(_copy,psize);
double mean=0;
for (uint16_t i=pcutOff;i<psize-pcutOff;i++) {
mean+=_copy[i];
}
return mean/(psize-2*pcutOff);
}
#endif

View File

@ -1,131 +0,0 @@
#ifndef _TEMPERATURE_H_
#define _TEMPERATURE_H_
#include <OneWire.h>
#include <DallasTemperature.h>
void printAddress(DeviceAddress deviceAddress);
//first address: 28FF6C1C7216058B
//second address:
#define ONE_WIRE_BUS 18 //GPIO pin
#define TEMPERATURE_PRECISION 12 //max is 12
#define READINTERVAL_DS18B20 1000 //ms
// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);
#define TEMPMEAN_SIZE 16
uint16_t tempCmean_pos=0;
// arrays to hold device addresses
DeviceAddress thermometerReservoir={0x28,0xFF,0x30,0xBA,0x85,0x16,0x03,0xB5};
float tempC_reservoir;
float tempCmean_reservoir[TEMPMEAN_SIZE];
DeviceAddress thermometerAir={0x28,0xFF,0x6C,0x1C,0x72,0x16,0x05,0x8B};
float tempC_air;
float tempCmean_air[TEMPMEAN_SIZE];
void temperature_setup() {
//initialize mean array
for (uint16_t i=0;i<TEMPMEAN_SIZE;i++) {
tempCmean_reservoir[i]=-127;
tempCmean_air[i]=-127;
}
sensors.begin();
delay(1000);
Serial.print("Locating devices...");
Serial.print("Found ");
Serial.print(sensors.getDeviceCount(), DEC);
Serial.println(" devices.");
delay(1000);
Serial.print("Parasite power is: ");
if (sensors.isParasitePowerMode()) Serial.println("ON");
else Serial.println("OFF");
delay(1000);
//Just search for devices. Only needed when connecting a new sensor to find the address
oneWire.reset_search();
for (uint8_t i=0;i<sensors.getDeviceCount();i++){
DeviceAddress _addr;
if (!oneWire.search(_addr)) {
Serial.print("Error: Device not found");
}else{
Serial.print("Found device. Address:");
printAddress(_addr);
}
Serial.println();
}
sensors.setResolution(thermometerReservoir, TEMPERATURE_PRECISION);
sensors.setResolution(thermometerAir, TEMPERATURE_PRECISION);
}
void temperature_loop(unsigned long loopmillis, unsigned long pInterval) {
static unsigned long last_read_ds18b20;
static bool flag_requestTemperatures=false;
if (loopmillis>last_read_ds18b20+pInterval) {
if (loopmillis>last_read_ds18b20+pInterval*10) { //timeout
Serial.println("Warn: Request Temperatures Timeout!");
flag_requestTemperatures=false;
}
if (!flag_requestTemperatures) {
sensors.requestTemperatures(); //this takes ~600ms
flag_requestTemperatures=true;
}
if (sensors.isConversionComplete()) {
flag_requestTemperatures=false;
last_read_ds18b20=loopmillis;
tempC_reservoir = sensors.getTempC(thermometerReservoir);
if (tempC_reservoir == DEVICE_DISCONNECTED_C)
{
Serial.print(" Error reading: "); printAddress(thermometerReservoir);
}else{
tempCmean_reservoir[tempCmean_pos]=tempC_reservoir;
}
tempC_air = sensors.getTempC(thermometerAir);
if (tempC_air == DEVICE_DISCONNECTED_C)
{
Serial.print(" Error reading: "); printAddress(thermometerReservoir);
}else{
tempCmean_air[tempCmean_pos]=tempC_air;
}
tempCmean_pos++;
tempCmean_pos%=TEMPMEAN_SIZE;
}
}
}
void printAddress(DeviceAddress deviceAddress)
{
for (uint8_t i = 0; i < 8; i++)
{
// zero pad the address if necessary
if (deviceAddress[i] < 16) Serial.print("0");
Serial.print(deviceAddress[i], HEX);
}
}
#endif

View File

@ -1,44 +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 100
#define WATERLEVELMEAN_SIZE 32
float waterlevelMean[WATERLEVELMEAN_SIZE];
uint16_t waterlevelMean_pos=0;
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[i]=-1; //-1 is also timeout value
}
}
void waterlevel_loop(unsigned long loopmillis, unsigned long pInterval) {
static unsigned long last_read_hcsr04;
if (loopmillis>=last_read_hcsr04+pInterval) {
last_read_hcsr04=loopmillis;
float temperature=20.0;
if (tempC_air!=DEVICE_DISCONNECTED_C && isValueArrayOKf(tempCmean_air,TEMPMEAN_SIZE,DEVICE_DISCONNECTED_C)) { //sensor ok
temperature=getMeanf(tempCmean_air,TEMPMEAN_SIZE);
}
double* distances = HCSR04.measureDistanceMm(temperature);
waterlevelMean[waterlevelMean_pos]=distances[0];
waterlevelMean_pos++;
waterlevelMean_pos%=WATERLEVELMEAN_SIZE;
}
}
#endif

View File

@ -1,22 +1,71 @@
#include <Arduino.h> #include <Arduino.h>
#include <ArduinoSort.h>
bool flag_print=false;
#include "helpfunctions.h"
// ######## EC // ######## EC
#include "ec.h" #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 1024
uint16_t ec_array[EC_ARRAY_SIZE];
uint16_t ec_array_pos=0;
unsigned long last_read_ec=0;
#define EC_READ_INTERVAL 1
// ######## Temperature // ######## Temperature
#include "temperature.h" #include <OneWire.h>
#include <DallasTemperature.h>
//first address: 28FF6C1C7216058B
//second address:
#define ONE_WIRE_BUS 18 //GPIO pin
#define TEMPERATURE_PRECISION 12 //max is 12
#define READINTERVAL_DS18B20 1000 //ms
// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);
#define TEMPMEAN_SIZE 16
uint16_t tempCmean_pos=0;
// arrays to hold device addresses
DeviceAddress thermometerReservoir={0x28,0xFF,0x30,0xBA,0x85,0x16,0x03,0xB5};
float tempC_reservoir;
float tempCmean_reservoir[TEMPMEAN_SIZE];
DeviceAddress thermometerAir={0x28,0xFF,0x6C,0x1C,0x72,0x16,0x05,0x8B};
float tempC_air;
float tempCmean_air[TEMPMEAN_SIZE];
// ######## Water Level // ######## Water Level
#include "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 100
#define WATERLEVELMEAN_SIZE 32
float waterlevelMean[WATERLEVELMEAN_SIZE];
uint16_t waterlevelMean_pos=0;
// ######## Flow Rate // ######## Flow Rate
#include "flow.h" #define FLOW_PIN 19
uint16_t flow_counter=0; //maximum counts/s measured with Eden 128 Pump was 171
void IRAM_ATTR isr_flow();
unsigned long last_read_flow=0;
#define READINTERVAL_FLOW 1000
float flow_factor=7.5; //F=7.5*flowrate[L/min]
float flow;
uint32_t flow_counter_sum=0;
unsigned long last_print=0; unsigned long last_print=0;
@ -24,22 +73,84 @@ unsigned long last_print=0;
float getMean(uint16_t *parray,uint16_t psize);
float getMeanf(float *parray,uint16_t psize);
uint16_t getMin(uint16_t *parray, uint16_t psize);
uint16_t getMax(uint16_t *parray, uint16_t psize);
float getMaxf(float *parray,uint16_t psize);
float getMinf(float *parray, uint16_t psize);
bool isValueArrayOK(uint16_t *parray,uint16_t psize, uint16_t pcheck);
bool isValueArrayOKf(float *parray,uint16_t psize, float pcheck);
float getFilteredf(float *parray,uint16_t psize, uint16_t pcutOff);
void printAddress(DeviceAddress deviceAddress);
void printTemperature(DeviceAddress deviceAddress);
void printResolution(DeviceAddress deviceAddress);
void printData(DeviceAddress deviceAddress);
void setup() { void setup() {
Serial.begin(115200); Serial.begin(115200);
pinMode(EC_PIN_ADC,INPUT);
ec_setup(); ledcSetup(EC_PWM_CH, EC_FREQUENCY, EC_RESOLUTION);
ledcAttachPin(EC_PIN_FREQ, EC_PWM_CH);
ledcWrite(EC_PWM_CH, 127);
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[i]=-1; //-1 is also timeout value
}
temperature_setup(); //initialize mean array
for (uint16_t i=0;i<TEMPMEAN_SIZE;i++) {
tempCmean_reservoir[i]=-127;
tempCmean_air[i]=-127;
}
sensors.begin();
delay(1000);
Serial.print("Locating devices...");
Serial.print("Found ");
Serial.print(sensors.getDeviceCount(), DEC);
Serial.println(" devices.");
delay(1000);
Serial.print("Parasite power is: ");
if (sensors.isParasitePowerMode()) Serial.println("ON");
else Serial.println("OFF");
delay(1000);
//Just search for devices. Only needed when connecting a new sensor to find the address
oneWire.reset_search();
flow_setup(); for (uint8_t i=0;i<sensors.getDeviceCount();i++){
DeviceAddress _addr;
if (!oneWire.search(_addr)) {
Serial.print("Error: Device not found");
}else{
Serial.print("Found device. Address:");
printAddress(_addr);
}
Serial.println();
}
sensors.setResolution(thermometerReservoir, TEMPERATURE_PRECISION);
sensors.setResolution(thermometerAir, TEMPERATURE_PRECISION);
pinMode(FLOW_PIN, INPUT_PULLUP);
attachInterrupt(FLOW_PIN, isr_flow, CHANGE);
Serial.println("Setup finished"); Serial.println("Setup finished");
delay(500); delay(500);
@ -48,20 +159,86 @@ void setup() {
void loop() { void loop() {
unsigned long loopmillis=millis(); unsigned long loopmillis=millis();
flag_print=false; bool flag_print=false;
ec_loop(loopmillis, EC_READ_INTERVAL);
temperature_loop(loopmillis, READINTERVAL_DS18B20); if (loopmillis>last_read_ec+EC_READ_INTERVAL) {
last_read_ec=loopmillis;
ec_array_pos++;
flag_print= ec_array_pos==EC_ARRAY_SIZE;
ec_array_pos%=EC_ARRAY_SIZE;
ec_array[ec_array_pos]=analogRead(EC_PIN_ADC);
//Serial.print(ec_array[ec_array_pos]); Serial.print(" ");
}
static unsigned long last_read_ds18b20;
static bool flag_requestTemperatures=false;
if (loopmillis>last_read_ds18b20+READINTERVAL_DS18B20) {
if (loopmillis>last_read_ds18b20+READINTERVAL_DS18B20*10) { //timeout
Serial.println("Warn: Request Temperatures Timeout!");
flag_requestTemperatures=false;
}
if (!flag_requestTemperatures) {
sensors.requestTemperatures(); //this takes ~600ms
flag_requestTemperatures=true;
}
if (sensors.isConversionComplete()) {
flag_requestTemperatures=false;
last_read_ds18b20=loopmillis;
tempC_reservoir = sensors.getTempC(thermometerReservoir);
if (tempC_reservoir == DEVICE_DISCONNECTED_C)
{
Serial.print(" Error reading: "); printAddress(thermometerReservoir);
}else{
tempCmean_reservoir[tempCmean_pos]=tempC_reservoir;
}
tempC_air = sensors.getTempC(thermometerAir);
if (tempC_air == DEVICE_DISCONNECTED_C)
{
Serial.print(" Error reading: "); printAddress(thermometerReservoir);
}else{
tempCmean_air[tempCmean_pos]=tempC_air;
}
tempCmean_pos++;
tempCmean_pos%=TEMPMEAN_SIZE;
}
}
waterlevel_loop(loopmillis, READINTERVAL_HCSR04);
flow_loop(loopmillis, READINTERVAL_FLOW); static unsigned long last_read_hcsr04;
if (loopmillis>=last_read_hcsr04+READINTERVAL_HCSR04) {
last_read_hcsr04=loopmillis;
float temperature=20.0;
if (tempC_air!=DEVICE_DISCONNECTED_C && isValueArrayOKf(tempCmean_air,TEMPMEAN_SIZE,DEVICE_DISCONNECTED_C)) { //sensor ok
temperature=getMeanf(tempCmean_air,TEMPMEAN_SIZE);
}
double* distances = HCSR04.measureDistanceMm(temperature);
waterlevelMean[waterlevelMean_pos]=distances[0];
waterlevelMean_pos++;
waterlevelMean_pos%=WATERLEVELMEAN_SIZE;
}
static uint16_t _last_flowconter; //for debugging
if (loopmillis>=last_read_flow+READINTERVAL_FLOW) {
flow=flow_counter*1000.0/(loopmillis-last_read_flow)/2.0; //Frequency [Hz]
flow/=flow_factor; //[L/min]
_last_flowconter=flow_counter; //for debugging
flow_counter=0;
last_read_flow=loopmillis;
}
if (loopmillis>last_print+500) { if (loopmillis>last_print+500) {
@ -97,7 +274,7 @@ void loop() {
Serial.print("\t waiting for distance"); Serial.print("\t waiting for distance");
} }
Serial.print("\t Flow="); Serial.print(flow,2); Serial.print("\t Flow="); Serial.print(flow,2); Serial.print(" ("); Serial.print(_last_flowconter); Serial.print(")");
Serial.print("\t Flowsum="); Serial.print(flow_counter_sum); Serial.print("\t Flowsum="); Serial.print(flow_counter_sum);
@ -107,3 +284,119 @@ void loop() {
} }
} }
float getMean(uint16_t *parray,uint16_t psize) {
double mean=0;
for (uint16_t i=0;i<psize;i++) {
mean+=parray[i];
}
return mean/psize;
}
float getMeanf(float *parray,uint16_t psize) {
double mean=0;
for (uint16_t i=0;i<psize;i++) {
mean+=parray[i];
}
return mean/psize;
}
bool isValueArrayOK(uint16_t *parray,uint16_t psize, uint16_t pcheck) { //check if array has error values
for (uint16_t i=0;i<psize;i++) {
if (parray[i]==pcheck){
return false;
}
}
return true;
}
bool isValueArrayOKf(float *parray,uint16_t psize, float pcheck) { //check if array has error values
for (uint16_t i=0;i<psize;i++) {
if (parray[i]==pcheck){
return false;
}
}
return true;
}
uint16_t getMin(uint16_t *parray, uint16_t psize) {
uint16_t min=65535;
for (uint16_t i=0;i<psize;i++) {
if (parray[i]<min) {
min=parray[i];
}
}
return min;
}
uint16_t getMax(uint16_t *parray,uint16_t psize) {
uint16_t max=0;
for (uint16_t i=0;i<psize;i++) {
if (parray[i]>max) {
max=parray[i];
}
}
return max;
}
float getMinf(float *parray, uint16_t psize) {
float min=65535;
for (uint16_t i=0;i<psize;i++) {
if (parray[i]<min) {
min=parray[i];
}
}
return min;
}
float getMaxf(float *parray,uint16_t psize) {
float max=0;
for (uint16_t i=0;i<psize;i++) {
if (parray[i]>max) {
max=parray[i];
}
}
return max;
}
void printAddress(DeviceAddress deviceAddress)
{
for (uint8_t i = 0; i < 8; i++)
{
// zero pad the address if necessary
if (deviceAddress[i] < 16) Serial.print("0");
Serial.print(deviceAddress[i], HEX);
}
}
void IRAM_ATTR isr_flow() {
flow_counter++;
flow_counter_sum++;
}
float getFilteredf(float *parray,uint16_t psize, uint16_t pcutOff) {
//cuts off lowest and highest pcutOff values from array, then returns the mean of the psize-2*pcutOff center values.
//pcutOff < psize/2
float _copy[psize];
std::copy(parray,parray + psize, _copy);
sortArray(_copy,psize);
double mean=0;
for (uint16_t i=pcutOff;i<psize-pcutOff;i++) {
mean+=_copy[i];
}
return mean/(psize-2*pcutOff);
}