Compare commits
No commits in common. "develop" and "volkmann_dev" have entirely different histories.
develop
...
volkmann_d
1
.gitignore
vendored
1
.gitignore
vendored
@ -3,4 +3,3 @@
|
||||
.vscode/c_cpp_properties.json
|
||||
.vscode/launch.json
|
||||
.vscode/ipch
|
||||
.vs
|
||||
|
||||
Binary file not shown.
@ -1,10 +1,2 @@
|
||||
# Smart_Garden
|
||||
|
||||
## Requirements
|
||||
VisualStudioCode with PlatformIO extension
|
||||
|
||||
## Build
|
||||
Configuration is defined in `platformio.ini` file. If you have PlatformIO extension installed, just use built-in build-command.
|
||||
|
||||
## Flash to µC
|
||||
Connect ESP32 to any desired USB-Port and use PlatformIOs upload-command.
|
||||
|
||||
@ -13,13 +13,14 @@ platform = espressif32
|
||||
board = az-delivery-devkit-v4
|
||||
framework = arduino
|
||||
monitor_speed = 115200
|
||||
; build_flags = -DCORE_DEBUG_LEVEL=5
|
||||
|
||||
lib_deps =
|
||||
439 #ID of Lightsensor library BH1750
|
||||
19 #DHT sensor library
|
||||
31 #Adafruit Unified Sensor
|
||||
AutoConnect@^1.1.7
|
||||
AsyncMqttClient@^0.8.2
|
||||
ArduinoJson@^6.15.2
|
||||
PubSubClient@^2.8
|
||||
ArduinoNvs@^2.5
|
||||
ESPRandom@^1.3.3
|
||||
MQTT@^2.4.7
|
||||
; PubSubClient@^2.8
|
||||
; ESPRandom@^1.3.3
|
||||
@ -1,31 +1,28 @@
|
||||
/*
|
||||
Code for the Capacitive Soil Moisture Sensor
|
||||
*/
|
||||
#include <common.h>
|
||||
|
||||
#include <header.h>
|
||||
|
||||
const int numReadings = 20;
|
||||
|
||||
// reads soil moisture multiple times and calculates average to eliminate noise
|
||||
int readCapacitiveSoilMoistureSensor() {
|
||||
int total = 0; // the running total
|
||||
// read from the sensor
|
||||
for (int readIndex = 0; readIndex < numReadings; readIndex++) {
|
||||
void setupCapacitiveSoilMoistureSensor() {
|
||||
// pinMode(PIN_MS, INPUT);
|
||||
}
|
||||
|
||||
int readCapacitiveSoilMoistureSensor()
|
||||
{
|
||||
int total = 0; // the running total
|
||||
// read from the sensor:
|
||||
for (int readIndex = 0; readIndex < numReadings; readIndex++)
|
||||
{
|
||||
total = total + analogRead(PIN_MS);
|
||||
delay(2);
|
||||
}
|
||||
int measurement = total / numReadings;
|
||||
|
||||
// map measurement to relative soil moisture value in %
|
||||
int finalRes = map(measurement, VALUE_AIR, VALUE_WATER, 0, 100);
|
||||
Serial.print("current soil moisture: ");
|
||||
Serial.println(finalRes);
|
||||
|
||||
// clamp mesurement to a value between 0 and 100
|
||||
if (finalRes < 0) {
|
||||
return 0;
|
||||
} else if (finalRes > 100) {
|
||||
return 100;
|
||||
} else {
|
||||
return finalRes;
|
||||
}
|
||||
Serial.print("soil moisture raw: ");
|
||||
Serial.println(measurement);
|
||||
// add the reading to the total:
|
||||
//int measurement = analogRead(PIN_MS);
|
||||
return map(measurement, VALUE_AIR, VALUE_WATER, 0, 100);
|
||||
}
|
||||
@ -1 +0,0 @@
|
||||
int readCapacitiveSoilMoistureSensor();
|
||||
43
src/common.h
43
src/common.h
@ -1,43 +0,0 @@
|
||||
#include <Arduino.h>
|
||||
// this common Header file defines commonly used hardware and buildtime constants
|
||||
|
||||
// PUBLISH FREQUENCY (MS)
|
||||
#define FREQUENCY 60000
|
||||
|
||||
// fix for core panic during wifi initialization
|
||||
// #define configMINIMAL_STACK_SIZE 4096
|
||||
// #define CONFIG_TIMER_TASK_STACK_SIZE 8192
|
||||
|
||||
// BH1750 lightsensor
|
||||
#define MIN_LIGHT 0
|
||||
#define MAX_LIGHT 54612
|
||||
|
||||
// DHT11
|
||||
#define PIN_DHT11 14
|
||||
|
||||
// MOISTURE SENSOR // A7
|
||||
#define PIN_MS 35
|
||||
#define VALUE_WATER 1650
|
||||
#define VALUE_AIR 3500
|
||||
|
||||
// Ventil
|
||||
#define PIN_VALVE 32
|
||||
#define MAX_VALVE_TIMEOUT 5000
|
||||
|
||||
// STATUS LED
|
||||
#define PIN_LED_R 2
|
||||
#define PIN_LED_G 0
|
||||
#define PIN_LED_B 4
|
||||
|
||||
// LIGHT LED
|
||||
#define LIGHT_LED_PIN_R 27
|
||||
#define LIGHT_LED_PIN_G 26
|
||||
#define LIGHT_LED_PIN_B 25
|
||||
#define MAX_LIGHT_TIMEOUT (FREQUENCY - 5)
|
||||
|
||||
// MQTT
|
||||
#define MQTT_HOST "mqtt.timovolkmann.de"
|
||||
#define MQTT_PORT 1883
|
||||
#define MQTT_TOPIC_BASE_SUB "smartgarden/commands"
|
||||
#define MQTT_TOPIC_BASE_PUB "smartgarden/updates"
|
||||
#define MQTT_PATH_SUB MQTT_TOPIC_BASE_SUB "/#"
|
||||
@ -1,27 +1,19 @@
|
||||
#include <ArduinoJson.h>
|
||||
#include <AutoConnect.h>
|
||||
#include <PubSubClient.h>
|
||||
#include <WebServer.h>
|
||||
#include <WiFi.h>
|
||||
#include <common.h>
|
||||
#include <store.h>
|
||||
#include <valve.h>
|
||||
#include <ntpManager.h>
|
||||
#include <MQTT.h>
|
||||
#include <header.h>
|
||||
|
||||
extern "C" {
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/timers.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/timers.h"
|
||||
}
|
||||
|
||||
#include <connections.h>
|
||||
|
||||
char MQTT_VALVE_COMMAND[72];
|
||||
char MQTT_SOIL_PROPERTIES[72];
|
||||
char MQTT_LIGHT_PROPERTIES[72];
|
||||
char MQTT_AUTO_PROPERTIES[72];
|
||||
#define MQTT_VALVE_COMMAND MQTT_TOPIC_BASE_SUB "/" MQTT_DEVICE_ID "/valve"
|
||||
#define MQTT_SOIL_PROPERTIES MQTT_TOPIC_BASE_SUB "/" MQTT_DEVICE_ID "/soil"
|
||||
|
||||
TimerHandle_t mqttReconnectTimer;
|
||||
TimerHandle_t wifiReconnectTimer;
|
||||
|
||||
// TimerHandle_t mqttProcessingTimer;
|
||||
TaskHandle_t mqttTask;
|
||||
|
||||
WebServer Server;
|
||||
@ -29,64 +21,56 @@ AutoConnect Portal(Server);
|
||||
WiFiClient client;
|
||||
|
||||
AutoConnectConfig Config;
|
||||
PubSubClient mqttClient(client);
|
||||
// Config.autoReconnect = true;
|
||||
// WiFi.config(Config);
|
||||
MQTTClient mqttClient;
|
||||
|
||||
// spins wifi up and activates green status light when wifi is conencted
|
||||
void connectWiFi() {
|
||||
yield();
|
||||
Serial.println("Start WiFi...");
|
||||
if (Portal.begin()) {
|
||||
digitalWrite(PIN_LED_G, HIGH);
|
||||
}
|
||||
}
|
||||
|
||||
// handles MQTT messages and keeps track of MQTT connection. starts reconnect timer if connection lost.
|
||||
void mqttLoop(void *parameter) {
|
||||
bool x;
|
||||
do {
|
||||
yield();
|
||||
mqttClient.loop();
|
||||
delay(100);
|
||||
x = mqttClient.loop();
|
||||
delay(50);
|
||||
} while (mqttClient.connected());
|
||||
Serial.println("Disconnected from MQTT.");
|
||||
|
||||
if (!mqttClient.connected()) {
|
||||
Serial.println("Checking WiFi Connection.");
|
||||
Serial.println("Disconnected from MQTT.");
|
||||
if (WiFi.isConnected()) {
|
||||
Serial.println("WiFi OK. Starting reconnect timer for MQTT.");
|
||||
xTimerStart(mqttReconnectTimer, 0);
|
||||
}
|
||||
}
|
||||
vTaskDelete(NULL);
|
||||
}
|
||||
|
||||
// setup MQTT connection and spins up task to handle connection and messages
|
||||
void connectMQTT() {
|
||||
yield();
|
||||
if (mqttClient.connected()) return;
|
||||
Serial.println("Connecting to MQTT...");
|
||||
|
||||
mqttClient.setServer(MQTT_HOST, MQTT_PORT);
|
||||
mqttClient.disconnect();
|
||||
mqttClient.connect(getDeviceIDcharArr());
|
||||
mqttClient.begin(MQTT_HOST, MQTT_PORT, client);
|
||||
mqttClient.connect(MQTT_DEVICE_ID);
|
||||
if (mqttClient.connected()) {
|
||||
Serial.println("Connected!");
|
||||
} else {
|
||||
Serial.println("NOT Connected!");
|
||||
}
|
||||
mqttClient.subscribe(MQTT_PATH_SUB);
|
||||
mqttClient.subscribe(MQTT_PATH_SUB, 2);
|
||||
Serial.print("subscribed to: ");
|
||||
Serial.println(MQTT_PATH_SUB);
|
||||
xTaskCreatePinnedToCore(
|
||||
mqttLoop,
|
||||
"mqttLoop",
|
||||
8192,
|
||||
NULL,
|
||||
2,
|
||||
&mqttTask,
|
||||
1);
|
||||
xTaskCreate(
|
||||
mqttLoop, /* Task function. */
|
||||
"mqttLoop", /* String with name of task. */
|
||||
8192, /* Stack size in bytes. */
|
||||
NULL, /* Parameter passed as input of the task */
|
||||
1, /* Priority of the task. */
|
||||
&mqttTask); /* Task handle. */
|
||||
//xTimerStart(mqttProcessingTimer, 0);
|
||||
}
|
||||
|
||||
// handles lost wifi connection
|
||||
void WiFiEvent(WiFiEvent_t event, WiFiEventInfo_t info) {
|
||||
void WiFiEvent(WiFiEvent_t event) {
|
||||
Serial.printf("[WiFi-event] event: %d\n", event);
|
||||
switch (event) {
|
||||
case SYSTEM_EVENT_STA_GOT_IP:
|
||||
@ -97,20 +81,14 @@ void WiFiEvent(WiFiEvent_t event, WiFiEventInfo_t info) {
|
||||
break;
|
||||
case SYSTEM_EVENT_STA_DISCONNECTED:
|
||||
digitalWrite(PIN_LED_G, LOW);
|
||||
// workaround for 202 auth failed bug: https://github.com/espressif/arduino-esp32/issues/2501
|
||||
if (info.disconnected.reason == 202) {
|
||||
Serial.println("weirdbehaviour");
|
||||
Serial.println(info.disconnected.reason);
|
||||
ESP.restart();
|
||||
}
|
||||
xTimerStop(mqttReconnectTimer, 0); // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
|
||||
// xTimerStop(mqttProcessingTimer, 0);
|
||||
xTimerStart(wifiReconnectTimer, 0);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// mqtt callback handles incoming messages
|
||||
void onMqttMessage(char *topic, byte *payload, unsigned int payload_length) {
|
||||
void onMqttMessage(MQTTClient *client, char topic[], char payload[], int payload_length) {
|
||||
Serial.print("Message arrived [");
|
||||
Serial.print(topic);
|
||||
Serial.print("] ");
|
||||
@ -119,27 +97,16 @@ void onMqttMessage(char *topic, byte *payload, unsigned int payload_length) {
|
||||
}
|
||||
Serial.println();
|
||||
|
||||
if (strcmp(topic, MQTT_LIGHT_PROPERTIES) == 0) {
|
||||
Serial.println("receiving light threshold...");
|
||||
Serial.println(topic);
|
||||
StaticJsonDocument<1024> doc;
|
||||
DeserializationError err = deserializeJson(doc, payload);
|
||||
if (err == DeserializationError::Ok) {
|
||||
int nm = doc["nm"];
|
||||
int minLX = doc["minLX"];
|
||||
setLightProperties(nm, minLX);
|
||||
} else {
|
||||
Serial.println(err.c_str());
|
||||
}
|
||||
}
|
||||
if (strcmp(topic, MQTT_VALVE_COMMAND) == 0) {
|
||||
Serial.println("toggling valve...");
|
||||
Serial.println(topic);
|
||||
toggleValve(false);
|
||||
toggleValve();
|
||||
}
|
||||
if (strcmp(topic, MQTT_SOIL_PROPERTIES) == 0) {
|
||||
Serial.println("receiving soil thresholds...");
|
||||
Serial.println(topic);
|
||||
Serial.println(payload);
|
||||
// const int capacity = JSON_OBJECT_SIZE(3) + 2 * JSON_OBJECT_SIZE(1);
|
||||
StaticJsonDocument<1024> doc;
|
||||
DeserializationError err = deserializeJson(doc, payload);
|
||||
if (err == DeserializationError::Ok) {
|
||||
@ -151,78 +118,26 @@ void onMqttMessage(char *topic, byte *payload, unsigned int payload_length) {
|
||||
Serial.println(err.c_str());
|
||||
}
|
||||
}
|
||||
if (strcmp(topic, MQTT_AUTO_PROPERTIES) == 0) {
|
||||
Serial.println("receiving auto settings...");
|
||||
Serial.println(topic);
|
||||
StaticJsonDocument<1024> doc;
|
||||
DeserializationError err = deserializeJson(doc, payload);
|
||||
if (err == DeserializationError::Ok) {
|
||||
bool ir = doc["irrigation"];
|
||||
bool li = doc["light"];
|
||||
setAutoProperties(li, ir);
|
||||
} else {
|
||||
Serial.println(err.c_str());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// generates mqtt topics based on device-uuid
|
||||
void constructMQTTpaths() {
|
||||
strcpy(MQTT_VALVE_COMMAND, MQTT_TOPIC_BASE_SUB "/");
|
||||
strcat(MQTT_VALVE_COMMAND, getDeviceIDcharArr());
|
||||
strcat(MQTT_VALVE_COMMAND, "/valve");
|
||||
|
||||
strcpy(MQTT_SOIL_PROPERTIES, MQTT_TOPIC_BASE_SUB "/");
|
||||
strcat(MQTT_SOIL_PROPERTIES, getDeviceIDcharArr());
|
||||
strcat(MQTT_SOIL_PROPERTIES, "/soil");
|
||||
|
||||
strcpy(MQTT_LIGHT_PROPERTIES, MQTT_TOPIC_BASE_SUB "/");
|
||||
strcat(MQTT_LIGHT_PROPERTIES, getDeviceIDcharArr());
|
||||
strcat(MQTT_LIGHT_PROPERTIES, "/light");
|
||||
|
||||
strcpy(MQTT_AUTO_PROPERTIES, MQTT_TOPIC_BASE_SUB "/");
|
||||
strcat(MQTT_AUTO_PROPERTIES, getDeviceIDcharArr());
|
||||
strcat(MQTT_AUTO_PROPERTIES, "/automatic");
|
||||
|
||||
Serial.println("MQTT_COMMANDS:");
|
||||
Serial.println(MQTT_VALVE_COMMAND);
|
||||
Serial.println(MQTT_SOIL_PROPERTIES);
|
||||
Serial.println(MQTT_LIGHT_PROPERTIES);
|
||||
Serial.println(MQTT_AUTO_PROPERTIES);
|
||||
}
|
||||
|
||||
// initializes Wifi and MQTT connections
|
||||
void setupConnections() {
|
||||
constructMQTTpaths();
|
||||
Serial.println();
|
||||
Serial.println();
|
||||
// disable Watchdog Task. This task made ESP stopped working, probably caused by working with arduino framework combined with multicore-concurrent patterns
|
||||
disableCore0WDT();
|
||||
Config.autoReconnect = true;
|
||||
Portal.config(Config);
|
||||
|
||||
// FreeRTOS Timer to handle loss of connections
|
||||
mqttReconnectTimer = xTimerCreate(
|
||||
"mqttTimer", pdMS_TO_TICKS(2000), pdFALSE, (void *)0, reinterpret_cast<TimerCallbackFunction_t>(connectMQTT));
|
||||
wifiReconnectTimer = xTimerCreate(
|
||||
"wifiTimer", pdMS_TO_TICKS(2000), pdFALSE, (void *)0, reinterpret_cast<TimerCallbackFunction_t>(connectWiFi));
|
||||
|
||||
// mqttProcessingTimer = xTimerCreate(
|
||||
// "messageTimer", pdMS_TO_TICKS(50), pdTRUE, (void *)0, reinterpret_cast<TimerCallbackFunction_t>(mqttLoop));
|
||||
|
||||
WiFi.onEvent(WiFiEvent);
|
||||
|
||||
mqttClient.onMessageAdvanced(onMqttMessage);
|
||||
|
||||
connectWiFi();
|
||||
connectMQTT();
|
||||
|
||||
mqttClient.setCallback(onMqttMessage);
|
||||
setupNTP();
|
||||
}
|
||||
|
||||
// method to delegate publish from other modules to connecions module
|
||||
void publishMessage(const char *topic, const char *msg) {
|
||||
if(mqttClient.connected()) {
|
||||
mqttClient.publish(topic, msg);
|
||||
Serial.print(topic);
|
||||
Serial.println(" successfully sent.");
|
||||
} else {
|
||||
Serial.println("couldn't send message. waiting for reconnect.");
|
||||
}
|
||||
mqttClient.publish(topic, msg, true, 1);
|
||||
}
|
||||
|
||||
@ -1,5 +0,0 @@
|
||||
void connectWiFi();
|
||||
void mqttLoop(void *parameter);
|
||||
void connectMQTT();
|
||||
void setupConnections();
|
||||
void publishMessage(const char *topic, const char *msg);
|
||||
77
src/header.h
Normal file
77
src/header.h
Normal file
@ -0,0 +1,77 @@
|
||||
/*
|
||||
Header file for the SmartGarden project
|
||||
*/
|
||||
|
||||
#define HEADER_H
|
||||
|
||||
#include <Arduino.h>
|
||||
#include <Wire.h>
|
||||
#include <SPI.h>
|
||||
#include <BH1750.h>
|
||||
#include <Adafruit_Sensor.h>
|
||||
#include <DHT.h>
|
||||
#include <DHT_U.h>
|
||||
|
||||
#include <WiFi.h>
|
||||
#include <WebServer.h>
|
||||
#include <AutoConnect.h>
|
||||
|
||||
// fix for core panic during wifi initialization
|
||||
// #define configMINIMAL_STACK_SIZE 2048
|
||||
// #define CONFIG_TIMER_TASK_STACK_SIZE 8192
|
||||
|
||||
// DHT11
|
||||
#define PIN_DHT11 14
|
||||
|
||||
// MQ-135
|
||||
#define PIN_MQ135_A 12
|
||||
#define PIN_MQ135_D 13
|
||||
|
||||
// MOISTURE SENSOR // A7
|
||||
#define PIN_MS 35
|
||||
#define VALUE_WATER 1650
|
||||
#define VALUE_AIR 3500
|
||||
|
||||
// Ventil
|
||||
#define PIN_VALVE 32
|
||||
#define MAX_VALVE_TIMEOUT 10000
|
||||
|
||||
// LED
|
||||
#define PIN_LED_R 2
|
||||
#define PIN_LED_G 0
|
||||
#define PIN_LED_B 4
|
||||
|
||||
// MQTT
|
||||
#define MQTT_HOST "mqtt.timovolkmann.de"
|
||||
#define MQTT_PORT 1883
|
||||
#define MQTT_DEVICE_ID "esp-timo"
|
||||
#define MQTT_TOPIC_BASE_SUB "smartgarden/commands"
|
||||
#define MQTT_TOPIC_BASE_PUB "smartgarden/updates"
|
||||
#define MQTT_PATH_PUB MQTT_TOPIC_BASE_PUB "/" MQTT_DEVICE_ID "/"
|
||||
#define MQTT_PATH_SUB MQTT_TOPIC_BASE_SUB "/#"
|
||||
// MQTT_DEVICE_ID "/#"
|
||||
|
||||
// PUBLISH FREQUENCY (MS)
|
||||
#define FREQUENCY 3000
|
||||
|
||||
// moisture
|
||||
extern void setupCapacitiveSoilMoistureSensor();
|
||||
extern int readCapacitiveSoilMoistureSensor();
|
||||
|
||||
// light
|
||||
extern void setupLightSensor();
|
||||
extern float readLightSensorValue();
|
||||
|
||||
// temperature & humidity
|
||||
extern void setupTemperatureSensor();
|
||||
extern float readHumidity();
|
||||
extern float readTemperature();
|
||||
|
||||
// mqtt & wifi
|
||||
extern void setupConnections();
|
||||
extern void publishMessage(const char *topic, const char *msg);
|
||||
|
||||
// sensors
|
||||
void readSensors();
|
||||
void toggleValve();
|
||||
void setSoilProperties(int FC, int PWP, int SAT);
|
||||
@ -1,103 +0,0 @@
|
||||
#include <common.h>
|
||||
#include <lightChecker.h>
|
||||
|
||||
// Bool to check if light is already active
|
||||
bool lightActive = false;
|
||||
// Colors in Array: purple, blue, green, yellow, orange, red, white
|
||||
int colorValueArray[][3] = {{125,0,125}, {0,0,255}, {0,255,0}, {255,255,0}, {255,140,0}, {255,0,0}, {255,255,255}};
|
||||
// Pointer for color array
|
||||
int colorCounter = 6;
|
||||
|
||||
// Setting PWM properties
|
||||
const int freq = 5000;
|
||||
const int ledChannelRed = 0;
|
||||
const int ledChannelGreen = 1;
|
||||
const int ledChannelBlue= 2;
|
||||
const int resolution = 8;
|
||||
|
||||
// Setup method for PWM configurations
|
||||
void setupPWM() {
|
||||
// Set pins as output
|
||||
pinMode(LIGHT_LED_PIN_R, OUTPUT);
|
||||
pinMode(LIGHT_LED_PIN_G, OUTPUT);
|
||||
pinMode(LIGHT_LED_PIN_B, OUTPUT);
|
||||
|
||||
// Configure LED PWM functionalitites
|
||||
ledcSetup(ledChannelRed, freq, resolution);
|
||||
ledcSetup(ledChannelGreen, freq, resolution);
|
||||
ledcSetup(ledChannelBlue, freq, resolution);
|
||||
|
||||
// Attach the channel to the GPIO2 to be controlled
|
||||
ledcAttachPin(LIGHT_LED_PIN_R, ledChannelRed);
|
||||
ledcAttachPin(LIGHT_LED_PIN_G, ledChannelGreen);
|
||||
ledcAttachPin(LIGHT_LED_PIN_B, ledChannelBlue);
|
||||
}
|
||||
|
||||
// Takes a int value representing nanometers and sets color array pointer to appropriate color
|
||||
void setValueNM(int NM) {
|
||||
getColorBasedOnValueNM(NM);
|
||||
}
|
||||
|
||||
// Logic to set color array pointer
|
||||
void getColorBasedOnValueNM(int valueNM) {
|
||||
if (valueNM <= 420) { // Purple
|
||||
colorCounter = 0;
|
||||
}
|
||||
else if (valueNM <= 490) { // Blue
|
||||
colorCounter = 1;
|
||||
}
|
||||
else if (valueNM <= 575) { // Green
|
||||
colorCounter = 2;
|
||||
}
|
||||
else if (valueNM <= 585) { // Yellow
|
||||
colorCounter = 3;
|
||||
}
|
||||
else if (valueNM <= 650) { // Orange
|
||||
colorCounter = 4;
|
||||
}
|
||||
else if (valueNM > 650) { // 650 to 750 is Red
|
||||
colorCounter = 5;
|
||||
}
|
||||
Serial.println("New color set based on: ");
|
||||
Serial.print(valueNM);
|
||||
}
|
||||
|
||||
// Shuts down the light
|
||||
bool shutdownLight() {
|
||||
ledcWrite(ledChannelRed, 0);
|
||||
ledcWrite(ledChannelGreen, 0);
|
||||
ledcWrite(ledChannelBlue, 0);
|
||||
return false;
|
||||
}
|
||||
|
||||
// Activates the light based on colorValueArray
|
||||
bool activateLight() {
|
||||
ledcWrite(ledChannelRed, colorValueArray[colorCounter][0]);
|
||||
ledcWrite(ledChannelGreen, colorValueArray[colorCounter][1]);
|
||||
ledcWrite(ledChannelBlue, colorValueArray[colorCounter][2]);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Activate light for given amount of time if not already activated
|
||||
void lightTask(void *parameter) {
|
||||
unsigned long lightTimeoutTimer = millis();
|
||||
if (lightActive == false) {
|
||||
lightActive = activateLight();
|
||||
// If current time is below or equal to light timeout do nothing
|
||||
while (millis() - lightTimeoutTimer <= MAX_LIGHT_TIMEOUT) {
|
||||
}
|
||||
lightActive = shutdownLight();
|
||||
}
|
||||
vTaskDelete(NULL);
|
||||
}
|
||||
|
||||
// Trigger for lightTask
|
||||
void triggerLight() {
|
||||
xTaskCreate(
|
||||
lightTask, /* Task function. */
|
||||
"lightTask", /* String with name of task. */
|
||||
2048, /* Stack size in bytes. */
|
||||
NULL, /* Parameter passed as input of the task */
|
||||
1, /* Priority of the task. */
|
||||
NULL); /* Task handle. */
|
||||
}
|
||||
@ -1,4 +0,0 @@
|
||||
void setupPWM();
|
||||
void setValueNM(int NM);
|
||||
void triggerLight();
|
||||
void getColorBasedOnValueNM(int valueNM);
|
||||
@ -1,19 +1,14 @@
|
||||
#include <BH1750.h>
|
||||
#include <Wire.h>
|
||||
#include <lightSensor.h>
|
||||
#include <header.h>
|
||||
|
||||
// New BH1750 class
|
||||
BH1750 lightMeter;
|
||||
|
||||
// Setup for reading light sensor (prepares i2c communication)
|
||||
void setupLightSensor() {
|
||||
Wire.begin();
|
||||
lightMeter.begin();
|
||||
Serial.println("Sensor started...");
|
||||
}
|
||||
|
||||
// Method to read and return the light value measured by BH1750 sensor
|
||||
float readLightSensorValue() {
|
||||
int intensity = lightMeter.readLightLevel();
|
||||
float intensity = lightMeter.readLightLevel();
|
||||
return intensity;
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
void setupLightSensor();
|
||||
float readLightSensorValue();
|
||||
24
src/main.cpp
24
src/main.cpp
@ -2,13 +2,9 @@
|
||||
Main file for the SmartGarden project
|
||||
*/
|
||||
|
||||
#include <common.h>
|
||||
#include <sensors.h>
|
||||
#include <store.h>
|
||||
#include <connections.h>
|
||||
#include <header.h>
|
||||
|
||||
#define TIME_TO_SLEEP 30
|
||||
volatile int noSleepTasks = 0;
|
||||
#include <string>
|
||||
|
||||
unsigned long sensorReadTimer = 0;
|
||||
bool valveOpen = false;
|
||||
@ -24,22 +20,22 @@ void setup() {
|
||||
|
||||
digitalWrite(PIN_VALVE, LOW);
|
||||
|
||||
|
||||
setupStore();
|
||||
setupSensors();
|
||||
setupConnections();
|
||||
// esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * 1000000);
|
||||
setupLightSensor();
|
||||
setupTemperatureSensor();
|
||||
setupCapacitiveSoilMoistureSensor();
|
||||
Serial.println("Setup complete...");
|
||||
Serial.println();
|
||||
Serial.println();
|
||||
// First read without delay
|
||||
readSensors();
|
||||
}
|
||||
|
||||
void loop() {
|
||||
// Main loop: read sensors
|
||||
// read sensors
|
||||
if (millis() - sensorReadTimer >= FREQUENCY) {
|
||||
readSensors();
|
||||
sensorReadTimer = millis();
|
||||
}
|
||||
}
|
||||
// toggle valve
|
||||
if (valveOpen) {
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,51 +0,0 @@
|
||||
#include <common.h>
|
||||
#include <WiFi.h>
|
||||
#include <ntpManager.h>
|
||||
|
||||
// Url to ntp server
|
||||
const char* ntpServer = "pool.ntp.org";
|
||||
// Time offset based on gmt in seconds
|
||||
const long gmtOffset_sec = 3600;
|
||||
// Offset in seconds for daylight saving time
|
||||
const int daylightOffset_sec = 3600;
|
||||
|
||||
// Start and end hour of the date
|
||||
const int dayStart = 8;
|
||||
const int dayEnd = 20;
|
||||
// Time info structure comes from time.h
|
||||
struct tm timeinfo;
|
||||
|
||||
// If wifi is connected configure time of esp32
|
||||
void setupNTP() {
|
||||
if (WiFi.isConnected()) {
|
||||
Serial.println("WiFi OK. Getting Timestamp");
|
||||
configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
|
||||
printTimestamp();
|
||||
}
|
||||
}
|
||||
|
||||
// Method to check if it is currently day or night
|
||||
bool checkForDay() {
|
||||
printTimestamp();
|
||||
if((getCurrentHour() > dayStart) && (getCurrentHour() < dayEnd)) {
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Method to get current hour in 24 hour format
|
||||
int getCurrentHour() {
|
||||
int currentHour = timeinfo.tm_hour;
|
||||
return currentHour;
|
||||
}
|
||||
|
||||
// Method to print a timestamp
|
||||
void printTimestamp() {
|
||||
if(!getLocalTime(&timeinfo)){
|
||||
Serial.println("Failed to obtain time");
|
||||
return;
|
||||
}
|
||||
Serial.println(&timeinfo, "%A, %B %d %Y %H:%M:%S");
|
||||
}
|
||||
@ -1,4 +0,0 @@
|
||||
void setupNTP();
|
||||
bool checkForDay();
|
||||
int getCurrentHour();
|
||||
void printTimestamp();
|
||||
105
src/peripherals.cpp
Normal file
105
src/peripherals.cpp
Normal file
@ -0,0 +1,105 @@
|
||||
#include <header.h>
|
||||
|
||||
#include <string>
|
||||
//using namespace std;
|
||||
extern "C" {
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
}
|
||||
|
||||
#define MQTT_MOISTURE MQTT_PATH_PUB "moisture"
|
||||
#define MQTT_TEMPERATURE MQTT_PATH_PUB "temperature"
|
||||
#define MQTT_HUMIDITY MQTT_PATH_PUB "humidity"
|
||||
#define MQTT_BRIGHTNESS MQTT_PATH_PUB "brightness"
|
||||
|
||||
char buffer[16];
|
||||
|
||||
// Feldkapazität des Bodens in Prozent: Standard ist Humus
|
||||
int fieldCapacity = 44;
|
||||
// PWP des Bodens in Prozent: Standard ist Humus
|
||||
int permanentWiltingPoint = 25;
|
||||
// Boden vollständig gesättigt bei (Prozent): Standard ist Humus
|
||||
int soilSaturation = 69;
|
||||
|
||||
void readSensors() {
|
||||
float lxValue = readLightSensorValue();
|
||||
Serial.print("Light intensity: ");
|
||||
Serial.print(lxValue);
|
||||
Serial.println(" lx");
|
||||
sprintf(buffer, "%f", lxValue);
|
||||
publishMessage(MQTT_BRIGHTNESS, buffer);
|
||||
|
||||
int mstValue = readCapacitiveSoilMoistureSensor();
|
||||
Serial.print("Soil moisture: ");
|
||||
Serial.println(mstValue);
|
||||
sprintf(buffer, "%i", mstValue);
|
||||
publishMessage(MQTT_MOISTURE, buffer);
|
||||
|
||||
float humidityValue = readHumidity();
|
||||
Serial.print("Humidity: ");
|
||||
Serial.println(humidityValue);
|
||||
sprintf(buffer, "%f", humidityValue);
|
||||
publishMessage(MQTT_HUMIDITY, buffer);
|
||||
|
||||
float temperatureValue = readTemperature();
|
||||
Serial.print("Temperature: ");
|
||||
Serial.println(temperatureValue);
|
||||
sprintf(buffer, "%f", temperatureValue);
|
||||
publishMessage(MQTT_TEMPERATURE, buffer);
|
||||
Serial.print("\n");
|
||||
}
|
||||
|
||||
bool openValve() {
|
||||
digitalWrite(PIN_VALVE, HIGH);
|
||||
digitalWrite(PIN_LED_G, LOW);
|
||||
digitalWrite(PIN_LED_B, HIGH);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool closeValve() {
|
||||
digitalWrite(PIN_VALVE, LOW);
|
||||
digitalWrite(PIN_LED_G, HIGH);
|
||||
digitalWrite(PIN_LED_B, LOW);
|
||||
return false;
|
||||
}
|
||||
|
||||
void valveTask(void *parameter) {
|
||||
unsigned long valveTimeoutTimer = millis();
|
||||
bool valveOpen = openValve();
|
||||
|
||||
while (valveOpen) {
|
||||
delay(500);
|
||||
int mstValue = readCapacitiveSoilMoistureSensor();
|
||||
|
||||
if (millis() - valveTimeoutTimer >= MAX_VALVE_TIMEOUT) {
|
||||
valveOpen = closeValve();
|
||||
}
|
||||
// if (mstValue > 80) {
|
||||
// valveOpen = closeValve();
|
||||
// }
|
||||
}
|
||||
vTaskDelete(NULL);
|
||||
}
|
||||
|
||||
void toggleValve() {
|
||||
xTaskCreate(
|
||||
valveTask, /* Task function. */
|
||||
"valveTask", /* String with name of task. */
|
||||
10000, /* Stack size in bytes. */
|
||||
NULL, /* Parameter passed as input of the task */
|
||||
1, /* Priority of the task. */
|
||||
NULL); /* Task handle. */
|
||||
}
|
||||
|
||||
void setSoilProperties(int FC, int PWP, int SAT) {
|
||||
fieldCapacity = FC;
|
||||
permanentWiltingPoint = PWP;
|
||||
soilSaturation = SAT;
|
||||
Serial.print("fieldCapacity: ");
|
||||
Serial.println(fieldCapacity);
|
||||
Serial.print("permanentWiltingPoint: ");
|
||||
Serial.println(permanentWiltingPoint);
|
||||
Serial.print("soilSaturation: ");
|
||||
Serial.println(soilSaturation);
|
||||
// TODO save to nvs nonvolatile flash storage
|
||||
}
|
||||
@ -1,65 +0,0 @@
|
||||
#include <ArduinoJson.h>
|
||||
#include <capacitiveSoilMoistureSensor.h>
|
||||
#include <connections.h>
|
||||
#include <lightChecker.h>
|
||||
#include <lightSensor.h>
|
||||
#include <ntpManager.h>
|
||||
#include <sensors.h>
|
||||
#include <valve.h>
|
||||
#include <store.h>
|
||||
#include <temperatureSensor.h>
|
||||
#include <common.h>
|
||||
|
||||
char buffer[128];
|
||||
char MQTT_SENSOR_DATA_TOPIC[64];
|
||||
|
||||
void setupSensors() {
|
||||
setupLightSensor();
|
||||
setupPWM();
|
||||
setupTemperatureSensor();
|
||||
|
||||
// generates MQTT topics based on device ID
|
||||
strcpy(MQTT_SENSOR_DATA_TOPIC, MQTT_TOPIC_BASE_PUB "/");
|
||||
strcat(MQTT_SENSOR_DATA_TOPIC, getDeviceIDcharArr());
|
||||
strcat(MQTT_SENSOR_DATA_TOPIC, "/data");
|
||||
Serial.println("MQTT_SENSOR_DATA_TOPIC:");
|
||||
Serial.println(MQTT_SENSOR_DATA_TOPIC);
|
||||
}
|
||||
|
||||
// function to collect sensor data and delegate collected data as json to mqtt-task
|
||||
void readSensors() {
|
||||
Serial.println();
|
||||
StaticJsonDocument<128> doc;
|
||||
float lxValue = readLightSensorValue();
|
||||
Serial.print("Light intensity: ");
|
||||
Serial.print(lxValue);
|
||||
Serial.println(" lx");
|
||||
doc["brightness"] = lxValue;
|
||||
if (automaticLight && (lxValue < minimumLightValueLX && checkForDay())) {
|
||||
triggerLight();
|
||||
}
|
||||
|
||||
int mstValue = readCapacitiveSoilMoistureSensor();
|
||||
Serial.print("Soil moisture: ");
|
||||
Serial.println(mstValue);
|
||||
|
||||
if (automaticIrrigation) {
|
||||
toggleValve(true);
|
||||
}
|
||||
|
||||
doc["moisture"] = mstValue;
|
||||
|
||||
float humidityValue = readHumidity();
|
||||
Serial.print("Humidity: ");
|
||||
Serial.println(humidityValue);
|
||||
|
||||
doc["humidity"] = humidityValue;
|
||||
|
||||
float temperatureValue = readTemperature();
|
||||
Serial.print("Temperature: ");
|
||||
Serial.println(temperatureValue);
|
||||
|
||||
doc["temperature"] = temperatureValue;
|
||||
serializeJson(doc, buffer);
|
||||
publishMessage(MQTT_SENSOR_DATA_TOPIC, buffer);
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
void setupSensors();
|
||||
void readSensors();
|
||||
177
src/store.cpp
177
src/store.cpp
@ -1,177 +0,0 @@
|
||||
#include <ArduinoNvs.h>
|
||||
#include <ESPRandom.h>
|
||||
#include <common.h>
|
||||
#include <lightChecker.h>
|
||||
#include <store.h>
|
||||
|
||||
// Fieldcapacity of the Ground in Percentage: Standard is Humus
|
||||
int fieldCapacity = 44;
|
||||
// PWP of the Ground in Percentage: Standard is Humus
|
||||
int permanentWiltingPoint = 25;
|
||||
// Ground completely saturated by (Percentage): Standard is Humus
|
||||
int soilSaturation = 69;
|
||||
// Minimum light value before light turns on
|
||||
int minimumLightValueLX = 50;
|
||||
// Switches for automatic light and irrigation control
|
||||
bool automaticLight = false;
|
||||
bool automaticIrrigation = false;
|
||||
// Make sure device irrigates until fieldcapacity is reached
|
||||
bool irrigateUntilFC = false;
|
||||
|
||||
// stores properties to non-volatile-flash
|
||||
void persistSoilProps(int FC, int PWP, int SAT) {
|
||||
Serial.println("persistSoilProps");
|
||||
bool f = NVS.setInt("fieldCapacity", FC);
|
||||
bool p = NVS.setInt("permanentWilt", PWP);
|
||||
bool s = NVS.setInt("soilSaturation", SAT);
|
||||
if (f && p && s) {
|
||||
Serial.println("Soil properties sucessfully stored.");
|
||||
NVS.commit();
|
||||
}
|
||||
else {
|
||||
Serial.println("error occured while trying to persist soil properties");
|
||||
}
|
||||
}
|
||||
|
||||
// restores properties from nvs on boot
|
||||
void restoreSoilProps() {
|
||||
Serial.println("restoreSoilProps");
|
||||
int fc = NVS.getInt("fieldCapacity");
|
||||
int pwp = NVS.getInt("permanentWilt");
|
||||
int sat = NVS.getInt("soilSaturation");
|
||||
if (fc != 0) {
|
||||
fieldCapacity = fc;
|
||||
}
|
||||
if (pwp != 0) {
|
||||
permanentWiltingPoint = pwp;
|
||||
}
|
||||
if (sat != 0) {
|
||||
soilSaturation = sat;
|
||||
}
|
||||
Serial.print("fieldCapacity: ");
|
||||
Serial.println(fieldCapacity);
|
||||
Serial.print("permanentWiltingPoint: ");
|
||||
Serial.println(permanentWiltingPoint);
|
||||
Serial.print("soilSaturation: ");
|
||||
Serial.println(soilSaturation);
|
||||
}
|
||||
|
||||
// will be executed in setup process when booting µC
|
||||
void setupStore() {
|
||||
NVS.begin("store");
|
||||
initDeviceID();
|
||||
restoreSoilProps();
|
||||
restoreLightProps();
|
||||
restoreAutoProps();
|
||||
}
|
||||
|
||||
// sets soil properties and calls funtion to persist them
|
||||
void setSoilProperties(int FC, int PWP, int SAT) {
|
||||
fieldCapacity = FC;
|
||||
permanentWiltingPoint = PWP;
|
||||
soilSaturation = SAT;
|
||||
persistSoilProps(FC, PWP, SAT);
|
||||
Serial.print("new fieldCapacity: ");
|
||||
Serial.println(fieldCapacity);
|
||||
Serial.print("new permanentWiltingPoint: ");
|
||||
Serial.println(permanentWiltingPoint);
|
||||
Serial.print("new soilSaturation: ");
|
||||
Serial.println(soilSaturation);
|
||||
}
|
||||
|
||||
// Method to persist save the given lightning properties to NVS
|
||||
void persistLightProps(int NM, int minLX) {
|
||||
Serial.println("persistLightProps");
|
||||
bool n = NVS.setInt("nanoMeter", NM);
|
||||
bool m = NVS.setInt("minimumLux", minLX);
|
||||
if (n && m) {
|
||||
Serial.println("Light properties sucessfully stored.");
|
||||
NVS.commit();
|
||||
}
|
||||
else {
|
||||
Serial.println("error occured while trying to persist light properties");
|
||||
}
|
||||
}
|
||||
|
||||
// Method to restore light properties from Non-Volatile Storage (NVS)
|
||||
void restoreLightProps() {
|
||||
Serial.println("restoreLightProps");
|
||||
int nm = NVS.getInt("nanoMeter");
|
||||
int minLX = NVS.getInt("minimumLux");
|
||||
if (nm != 0) {
|
||||
setValueNM(nm);
|
||||
}
|
||||
if (minLX != 0) {
|
||||
minimumLightValueLX = minLX;
|
||||
}
|
||||
Serial.println(minimumLightValueLX);
|
||||
}
|
||||
|
||||
// Method to set given light properties
|
||||
void setLightProperties(int NM, int minLX) {
|
||||
setValueNM(NM);
|
||||
minimumLightValueLX = minLX;
|
||||
persistLightProps(NM, minLX);
|
||||
Serial.print("new minimum Light Value LX: ");
|
||||
Serial.println(minimumLightValueLX);
|
||||
}
|
||||
|
||||
void persistAutoProps(bool light, bool irrigation) {
|
||||
Serial.println("persistAutoProps");
|
||||
// Saved in NVS as Integer: 1 = true, 2 = false, 0 = not persisted, use standard settings
|
||||
bool n = NVS.setInt("automaticLight", (light ? 1 : 2));
|
||||
bool m = NVS.setInt("automaticIrrigation", (irrigation ? 1 : 2));
|
||||
if (n && m) {
|
||||
NVS.commit();
|
||||
Serial.println("Auto properties sucessfully stored.");
|
||||
} else {
|
||||
Serial.println("error occured while trying to persist auto properties");
|
||||
}
|
||||
}
|
||||
|
||||
// restores properties from nvs on boot
|
||||
void restoreAutoProps() {
|
||||
Serial.println("restoreLightProps");
|
||||
int li = NVS.getInt("automaticLight");
|
||||
int ir = NVS.getInt("automaticIrrigation");
|
||||
automaticLight = (bool) (li != 2);
|
||||
automaticIrrigation = (bool) (ir != 2);
|
||||
Serial.println(minimumLightValueLX);
|
||||
}
|
||||
|
||||
void setAutoProperties(bool light, bool irrigation) {
|
||||
automaticLight = light;
|
||||
automaticIrrigation = irrigation;
|
||||
persistAutoProps(light, irrigation);
|
||||
Serial.print("new auto settings: ");
|
||||
Serial.println(automaticLight);
|
||||
Serial.println(automaticIrrigation);
|
||||
}
|
||||
|
||||
String DEVICE_ID = "";
|
||||
|
||||
// generates device UUID on first boot and stores it to NVS. UUID will be restored from NVS after each subsequent boot
|
||||
void initDeviceID() {
|
||||
DEVICE_ID = NVS.getString("UUID");
|
||||
if (!DEVICE_ID.isEmpty()) {
|
||||
Serial.print("Fetched Device ID from NVS: ");
|
||||
Serial.println(DEVICE_ID);
|
||||
} else {
|
||||
uint8_t uuid[16];
|
||||
ESPRandom::uuid(uuid);
|
||||
DEVICE_ID = ESPRandom::uuidToString(uuid);
|
||||
NVS.setString("UUID", DEVICE_ID);
|
||||
NVS.commit();
|
||||
Serial.print("New Device ID: ");
|
||||
Serial.println(DEVICE_ID);
|
||||
}
|
||||
}
|
||||
|
||||
// Returns the device ID
|
||||
String getDeviceID() {
|
||||
return DEVICE_ID;
|
||||
}
|
||||
|
||||
const char* getDeviceIDcharArr() {
|
||||
return DEVICE_ID.c_str();
|
||||
}
|
||||
29
src/store.h
29
src/store.h
@ -1,29 +0,0 @@
|
||||
// Fieldcapacity of the Ground in Percentage: Standard is Humus
|
||||
extern int fieldCapacity;
|
||||
// PWP of the Ground in Percentage: Standard is Humus
|
||||
extern int permanentWiltingPoint;
|
||||
// Ground completely saturated by (Percentage): Standard is Humus
|
||||
extern int soilSaturation;
|
||||
// Minimum light value before light turns on
|
||||
extern int minimumLightValueLX;
|
||||
// switches for automatic light and irrigation control
|
||||
extern bool automaticLight;
|
||||
extern bool automaticIrrigation;
|
||||
// make sure device irrigates until fieldcapacity is reached
|
||||
extern bool irrigateUntilFC;
|
||||
// Device UUID will be set on first boot.
|
||||
extern String DEVICE_ID;
|
||||
|
||||
void persistSoilProps(int FC, int PWP, int SAT);
|
||||
void restoreSoilProps();
|
||||
void setupStore();
|
||||
void setSoilProperties(int FC, int PWP, int SAT);
|
||||
void persistLightProps(int NM, int minLX);
|
||||
void restoreLightProps();
|
||||
void setLightProperties(int NM, int minLX);
|
||||
void persistAutoProps(bool light, bool irrigation);
|
||||
void restoreAutoProps();
|
||||
void setAutoProperties(bool light, bool irrigation);
|
||||
void initDeviceID();
|
||||
String getDeviceID();
|
||||
const char* getDeviceIDcharArr();
|
||||
@ -1,24 +1,24 @@
|
||||
#include <DHT.h>
|
||||
#include <DHT_U.h>
|
||||
#include <common.h>
|
||||
#include <header.h>
|
||||
|
||||
#define DHTPIN PIN_DHT11
|
||||
|
||||
#define DHTTYPE DHT11
|
||||
|
||||
// set pin and type
|
||||
|
||||
DHT_Unified dht(DHTPIN, DHTTYPE);
|
||||
|
||||
// initialize temperature sensor
|
||||
void setupTemperatureSensor() {
|
||||
// Serial.begin(9600);
|
||||
dht.begin();
|
||||
Serial.println(F("DHT11 Unified Sensor Ready"));
|
||||
sensor_t sensor;
|
||||
dht.temperature().getSensor(&sensor);
|
||||
|
||||
}
|
||||
|
||||
// Get humidity event and its value.
|
||||
float readHumidity(){
|
||||
|
||||
sensors_event_t event;
|
||||
dht.humidity().getEvent(&event);
|
||||
return event.relative_humidity;
|
||||
|
||||
@ -1,3 +0,0 @@
|
||||
void setupTemperatureSensor();
|
||||
float readHumidity();
|
||||
float readTemperature();
|
||||
@ -1,71 +0,0 @@
|
||||
#include <capacitiveSoilMoistureSensor.h>
|
||||
#include <common.h>
|
||||
#include <store.h>
|
||||
|
||||
extern "C" {
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
}
|
||||
|
||||
#include <valve.h>
|
||||
|
||||
// open valve and set status led to blue while irrigating
|
||||
bool openValve() {
|
||||
digitalWrite(PIN_VALVE, HIGH);
|
||||
digitalWrite(PIN_LED_G, LOW);
|
||||
digitalWrite(PIN_LED_B, HIGH);
|
||||
return true;
|
||||
}
|
||||
|
||||
// close valve and set status back to green
|
||||
bool closeValve() {
|
||||
digitalWrite(PIN_VALVE, LOW);
|
||||
digitalWrite(PIN_LED_G, HIGH);
|
||||
digitalWrite(PIN_LED_B, LOW);
|
||||
return false;
|
||||
}
|
||||
|
||||
// function to handle valve control, see documentation for visual representation of control flow
|
||||
void valveTask(void *parameter) {
|
||||
// this parameter is used to determine if task was triggered manually by mqtt or by the sensor loop
|
||||
bool isAutomatic = (bool)parameter;
|
||||
Serial.print(isAutomatic);
|
||||
Serial.println(" Valve task triggered.");
|
||||
unsigned long valveTimeoutTimer = millis();
|
||||
bool valveOpen = false;
|
||||
int initialSoilMoisture = readCapacitiveSoilMoistureSensor();
|
||||
|
||||
if (initialSoilMoisture <= permanentWiltingPoint || irrigateUntilFC) {
|
||||
valveOpen = openValve();
|
||||
irrigateUntilFC = true;
|
||||
} else {
|
||||
Serial.println("Soil contains enough water. No irrigation needed. ");
|
||||
}
|
||||
|
||||
while (valveOpen) {
|
||||
delay(500);
|
||||
int mstValue = readCapacitiveSoilMoistureSensor();
|
||||
|
||||
if (mstValue > fieldCapacity) { // && isAutomatic
|
||||
Serial.println("Field capacity reached. No irrigation needed. ");
|
||||
valveOpen = closeValve();
|
||||
irrigateUntilFC = false;
|
||||
}
|
||||
if (millis() - valveTimeoutTimer >= MAX_VALVE_TIMEOUT) {
|
||||
Serial.println("Irrigation timeout reached. close valve. ");
|
||||
valveOpen = closeValve();
|
||||
}
|
||||
}
|
||||
vTaskDelete(NULL);
|
||||
}
|
||||
|
||||
// Creates a new task which handles valve control concurrently
|
||||
void toggleValve(bool automatic) {
|
||||
xTaskCreate(
|
||||
valveTask, /* Task function. */
|
||||
"valveTask", /* String with name of task. */
|
||||
2048, /* Stack size in bytes. */
|
||||
&automatic, /* Parameter passed as input of the task */
|
||||
3, /* Priority of the task. */
|
||||
NULL); /* Task handle. */
|
||||
}
|
||||
@ -1 +0,0 @@
|
||||
void toggleValve(bool automatic);
|
||||
Loading…
Reference in New Issue
Block a user