\/* See these links for more details *\/\r\n\/* https:\/\/node-red.blogspot.com\/2017\/12\/how-to-display-led-in-node-red-dashboard.html *\/\r\n\/* https:\/\/fontawesomeicons.com\/ *\/\r\n\/* https:\/\/randomnerdtutorials.com\/esp32-cam-ov2640-camera-settings\/ *\/\r\n\/* https:\/\/nerdytechy.com\/guide-for-arduino-ultrasonic-sensor-hc-sr04\/ *\/\r\n\/* https:\/\/www.elec-cafe.com\/esp32-cam-blynk-ultrasonic-sensor-hc-sr04-with-line-notify\/ *\/\r\n\r\n\r\n\/\/ Declarations and Variables\r\n\r\n#include \"src\/OV2640.h\"\r\n#include <WiFi.h>\r\n#include <WebServer.h>\r\n#include <WiFiClient.h>\r\n#include <PubSubClient.h>\r\n\r\n#define ENABLE_WEBSERVER\r\n\r\n#define CAMERA_MODEL_AI_THINKER\r\n\r\n#include \"camera_pins.h\" \/\/ Include in subfolder of code\r\n\r\nOV2640 cam;\r\n\r\nconst char* mqtt_server = \"<IP_Address_of_Broker>\"; \/\/ Put your MQTT Broker here\r\nconst char* ssid = \"<WiFi_SSID>\"; \/\/ Put your SSID here\r\nconst char* password = \"<WiFi_Password>\"; \/\/ Put your PASSWORD here\r\n\r\nWiFiClient espClient;\r\nPubSubClient client(espClient);\r\nlong lastMsg = 0;\r\nchar msg[50];\r\nint value = 0;\r\nint up = 1;\r\n\r\n\/\/ Data Pins for Ultrasonic sensor\r\nconst int TRIG_PIN = 3; \/\/GPIO 3 = U0RXD\r\nconst int ECHO_PIN = 1; \/\/GPIO 1 = U0TXD\r\n\r\n\/\/ establish variables for duration of the ping, and the distance result\r\n\/\/ in inches and centimeters:\r\nlong duration, cm;\r\n\r\n\/\/ Web Server Function\r\n\r\n#ifdef ENABLE_WEBSERVER\r\n\r\nWebServer server(80);\r\n\r\nvoid handle_jpg_stream(void)\r\n{\r\n WiFiClient client = server.client();\r\n String response = \"HTTP\/1.1 200 OK\\r\\n\";\r\n response += \"Content-Type: multipart\/x-mixed-replace; boundary=frame\\r\\n\\r\\n\";\r\n server.sendContent(response);\r\n\r\n while (1)\r\n {\r\n cam.run();\r\n if (!client.connected())\r\n break;\r\n response = \"--frame\\r\\n\";\r\n response += \"Content-Type: image\/jpeg\\r\\n\\r\\n\";\r\n server.sendContent(response);\r\n\r\n client.write((char *)cam.getfb(), cam.getSize());\r\n server.sendContent(\"\\r\\n\");\r\n if (!client.connected())\r\n break;\r\n }\r\n}\r\n\r\nvoid handle_jpg(void)\r\n{\r\n WiFiClient client = server.client();\r\n\r\n cam.run();\r\n if (!client.connected())\r\n {\r\n return;\r\n }\r\n String response = \"HTTP\/1.1 200 OK\\r\\n\";\r\n response += \"Content-disposition: inline; filename=capture.jpg\\r\\n\";\r\n response += \"Content-type: image\/jpeg\\r\\n\\r\\n\";\r\n server.sendContent(response);\r\n client.write((char *)cam.getfb(), cam.getSize());\r\n}\r\n\r\nvoid handleNotFound()\r\n{\r\n String message = \"Server is running!\\n\\n\";\r\n message += \"URI: \";\r\n message += server.uri();\r\n message += \"\\nMethod: \";\r\n message += (server.method() == HTTP_GET) ? \"GET\" : \"POST\";\r\n message += \"\\nArguments: \";\r\n message += server.args();\r\n message += \"\\n\";\r\n server.send(200, \"text\/plain\", message);\r\n}\r\n#endif\r\n\r\n\r\n\r\n\/\/ MQTT Functions\r\n\r\nvoid callback(char* topic, byte* message, unsigned int length) {\r\n String messageTemp;\r\n \r\n for (int i = 0; i < length; i++) {\r\n messageTemp += (char)message[i];\r\n }\r\n\r\n}\r\n\r\nvoid reconnect() {\r\n \/\/ Loop until we're reconnected\r\n while (!client.connected()) {\r\n \/\/ Attempt to connect\r\n if (client.connect(\"ESP32-Cam_WaterMonitor\")) {\r\n \/\/ Subscribe\r\n \/\/ Do you not subscribe to my methods?\r\n \/\/ # for everything, or ESP32-Cam_WaterMonitor\/Pump for just the pump\r\n client.subscribe(\"ESP32-Cam_WaterMonitor\/#\");\r\n } else {\r\n \/\/ Wait 5 seconds before retrying\r\n delay(5000);\r\n }\r\n }\r\n}\r\n\r\n\r\n\r\n\/\/ Setup Function\r\n\r\nvoid setup()\r\n{\r\n\r\n pinMode(TRIG_PIN,OUTPUT);\r\n pinMode(ECHO_PIN,INPUT);\r\n\r\n client.setServer(mqtt_server, 1883);\r\n client.setCallback(callback);\r\n\r\n camera_config_t config;\r\n config.ledc_channel = LEDC_CHANNEL_0;\r\n config.ledc_timer = LEDC_TIMER_0;\r\n config.pin_d0 = Y2_GPIO_NUM;\r\n config.pin_d1 = Y3_GPIO_NUM;\r\n config.pin_d2 = Y4_GPIO_NUM;\r\n config.pin_d3 = Y5_GPIO_NUM;\r\n config.pin_d4 = Y6_GPIO_NUM;\r\n config.pin_d5 = Y7_GPIO_NUM;\r\n config.pin_d6 = Y8_GPIO_NUM;\r\n config.pin_d7 = Y9_GPIO_NUM;\r\n config.pin_xclk = XCLK_GPIO_NUM;\r\n config.pin_pclk = PCLK_GPIO_NUM;\r\n config.pin_vsync = VSYNC_GPIO_NUM;\r\n config.pin_href = HREF_GPIO_NUM;\r\n config.pin_sscb_sda = SIOD_GPIO_NUM;\r\n config.pin_sscb_scl = SIOC_GPIO_NUM;\r\n config.pin_pwdn = PWDN_GPIO_NUM;\r\n config.pin_reset = RESET_GPIO_NUM;\r\n config.xclk_freq_hz = 20000000;\r\n config.pixel_format = PIXFORMAT_JPEG;\r\n config.frame_size = FRAMESIZE_SVGA;\r\n config.jpeg_quality = 10; \r\n config.fb_count = 1; \r\n \r\n cam.init(config);\r\n\r\n sensor_t * s = esp_camera_sensor_get();\r\n s->set_gain_ctrl(s, 1); \/\/ 0 = disable , 1 = enable\r\n s->set_agc_gain(s, 0); \/\/ 0 to 30\r\n s->set_brightness(s, 0); \/\/ -2 to 2\r\n s->set_contrast(s, 0); \/\/ -2 to 2\r\n s->set_saturation(s, 0); \/\/ -2 to 2\r\n\r\n\/* see https:\/\/randomnerdtutorials.com\/esp32-cam-ov2640-camera-settings\/\r\n\r\n\r\n*\/ \r\n IPAddress ip;\r\n\r\n WiFi.mode(WIFI_STA);\r\n WiFi.begin(ssid, password);\r\n while (WiFi.status() != WL_CONNECTED)\r\n {\r\n delay(500);\r\n }\r\n ip = WiFi.localIP();\r\n\r\n#ifdef ENABLE_WEBSERVER\r\n server.on(\"\/\", HTTP_GET, handle_jpg_stream);\r\n server.on(\"\/jpg\", HTTP_GET, handle_jpg);\r\n server.onNotFound(handleNotFound);\r\n server.begin();\r\n#endif\r\n\r\n}\r\n\r\n\r\n\r\n\/\/ Main Loop Function\r\n\r\nvoid loop()\r\n{\r\n \r\n if (!client.connected()) {\r\n reconnect();\r\n }\r\n client.loop();\r\n\r\n long now = millis();\r\n if (now - lastMsg > 5000) {\r\n lastMsg = now;\r\n\r\n client.publish(\"ESP32-Cam_WaterMonitor\/Firmware\", \"ESP32-Cam_WaterMonitor_Ver_1\"); \r\n String StringUptime = String(millis());\r\n client.publish(\"ESP32-Cam_WaterMonitor\/Uptime\", StringUptime.c_str());\r\n String StringHWAddress = String(WiFi.macAddress());\r\n client.publish(\"ESP32-Cam_WaterMonitor\/HWAddress\", StringHWAddress.c_str()); \r\n String StringWifiSignal = String(WiFi.RSSI());\r\n client.publish(\"ESP32-Cam_WaterMonitor\/WifiSignal\",StringWifiSignal.c_str()); \r\n\r\n MeasureLevel(); \r\n\r\n }\r\n \r\n server.handleClient();\r\n\r\n}\r\n\r\n\r\n\r\nvoid MeasureLevel()\r\n{\r\n\r\n \/\/ The HC-SR04 is triggered by a HIGH pulse of 2 or more microseconds.\r\n \/\/ Give a short LOW pulse beforehand to ensure a clean HIGH pulse:\r\n \r\n digitalWrite(TRIG_PIN, LOW);\r\n delayMicroseconds(2);\r\n digitalWrite(TRIG_PIN, HIGH);\r\n delayMicroseconds(10);\r\n digitalWrite(TRIG_PIN, LOW);\r\n\r\n duration = pulseIn(ECHO_PIN, HIGH);\r\n\r\n \/\/ convert the time into a distance\r\n cm = microsecondsToCentimeters(duration);\r\n\r\n String MeasureLevelCM = String(cm); \r\n client.publish(\"ESP32-Cam_WaterMonitor\/Level\", MeasureLevelCM.c_str()); \r\n\r\n}\r\n\r\n\r\n\r\nlong microsecondsToCentimeters(long microseconds) {\r\n \/\/ The speed of sound is 340 m\/s or 29 microseconds per centimeter.\r\n \/\/ The ping travels out and back, so to find the distance of the object we\r\n \/\/ take half of the distance traveled.\r\n return microseconds \/ 29 \/ 2;\r\n}<\/pre>\n <\/p>\n
With the ESP32-Cam module code installed, the next step was assembling the hardware. The ESP32-Cam module was attached to its serial interface board which would be used to power the entire project. The OV2640 camera module was installed and double sided tape was used to fix it to the microSD slot enclosure. To prevent brownouts, a 1000uF capacitor was soldered between the 5 volt VCC pin and ground. In addition to this, a momentary switch was attached between ground and the reset ground. The ground reset pin is located next to GPIO 1. This is poorly documented and took continuity testing to locate it. The HC-SR04 ultrasonic ranging module TRIG pin was attached to GPIO 3 (U0RXD) and the ECHO pin was attached to GPIO 1 (U0TXD). The 5 volt VCC pin and ground pin completed the connections for the HC-SR04. A 3″x2″x1″ plastic project box was used to house all of the components. It was simple to tool out the openings with a small utility blade.<\/p>\n
![\"\"](\"https:\/\/www.cloudacm.com\/wp-content\/uploads\/2023\/02\/ESP32-Cam_HC-SR04_Enclosure.png\")
<\/a><\/p>\nThe completed project box was installed in its location, along with an external LED light source and a wireless 433Mhz temperature and humidity sensor. The light source would be reflected off any water accumulating and be visible with camera.<\/p>\n
Originally the design was going to use moisture sensors at set levels to determine flood levels. However this design was flawed because the moisture sensors have a short service life and require frequent replacement. The ultrasonic sensor reduces servicing and offers reliability and higher accuracy.<\/p>\n
Next is the MQTT broker and Node-Red. There isn’t much other than installing a MQTT broker service for that portion. I won’t get into security or access controls here. Suffice it to say, once a broker is up and running, not much else needs to be done.<\/p>\n
In contrast, Node-Red is the heavy lifter for this project. It presents the video feed from the ESP32-Cam on the Node-Red web interface using FFMpeg. It subscribes to the ESP32-Cam modules published feeds and displays that on the web UI. The HC-SR04 readings are published and Node-Red processes those values to display water depth. Those readings are also evaluated by Node-Red and it then publishes actions based on user input and defined thresholds. Besides external monitors to verify all is online and working, Node-Red also monitors the online status of the ESP32-Cam module. Here is a closer look at each flow in Node-Red.<\/p>\n
![\"\"](\"https:\/\/www.cloudacm.com\/wp-content\/uploads\/2023\/02\/ESP32-Cam_HC-SR04_FFMpegFLow.png\")
<\/a><\/p>\nLets start with the video feed flow. The first node is an inject node that triggers at an interval every 10 seconds. The flow then goes to a change node that changes the msg.payload to a string that contains the path and name of an image file “\/usr\/share\/node-red-static\/ESP32-Cam_WaterMonitor.jpg”. This then feeds into an exec node that contains the following command.<\/p>\n
ffmpeg -y -i http:\/\/<IP_Address_of_ESP32-Cam_WaterMonitor> -vf \"pp=al, drawtext=fontfile=\/usr\/share\/fonts\/dejavu\/DejaVuSans-Bold.ttf: text='%{localtime\\}': fontcolor=white@0.8: fontsize=18: bordercolor=black@0.8: borderw=2: x=608: y=7\" -vframes 1 -f image2pipe -vcodec png -<\/pre>\nThat command runs FFMpeg and uses the ESP32-Cam as the source. The command also applies a video filter to draw text using a defined font, size, and weight at a designated position of the image. The text contains a timestamp that is overlayed on the image. The exec node then branches to 2 other nodes. Both of these are function nodes, one checks that the msg.payload.buffer is not empty, not in a fault, the other checks if the msg.payload.code value equals “1”, in a fault. If the flow payload is in a fault, then a read file node references a file and its path “\/usr\/share\/node-red-static\/ColorBars.jpg”. It’s output is set as “a single utf8 string” with encoding set as base64. If the flow payload is not in a fault, then a base64 node is used with an action of Encode as Base64 for the msg.payload. Both of theses nodes feed into a function template node where the msg.payload is fed into the following template.<\/p>\n
<img width=\"360px\" height=\"240px\" src=\"data:image\/jpg;base64,{{{payload}}}\"><\/pre>\nThe final node in the flow is a dashboard template node. This places the msg.payload inside the template for displaying on the WebUI with this template code.<\/p>\n
<div ng-bind-html=\"msg.payload\"><\/div><\/pre>\nAs you can see, providing video feeds in the Node-Red WebUI is rather involving. Fortunately, processing the MQTT feed from the ESP32-Cam isn’t as much trouble. The Arduino code above had these lines that directs the ESP32-Cam to publish its uptime, wifi signal strength, firmware version, and wifi network mac address.<\/p>\n
client.publish(\"ESP32-Cam_WaterMonitor\/Firmware\", \"ESP32-Cam_WaterMonitor_Ver_1\"); \r\nString StringUptime = String(millis());\r\nclient.publish(\"ESP32-Cam_WaterMonitor\/Uptime\", StringUptime.c_str());\r\nString StringHWAddress = String(WiFi.macAddress());\r\nclient.publish(\"ESP32-Cam_WaterMonitor\/HWAddress\", StringHWAddress.c_str()); \r\nString StringWifiSignal = String(WiFi.RSSI());\r\nclient.publish(\"ESP32-Cam_WaterMonitor\/WifiSignal\",StringWifiSignal.c_str());<\/pre>\nThe firmware topic is statically set text, whereas the other values are read during run time and published. Node red uses a mqtt in node to subscribe to the specific topic of each. Here is a list of them.<\/p>\n
\n- ESP32-Cam_WaterMonitor\/Firmware<\/li>\n
- ESP32-Cam_WaterMonitor\/HWAddress<\/li>\n
- ESP32-Cam_WaterMonitor\/WifiSignal<\/li>\n
- ESP32-Cam_WaterMonitor\/Uptime<\/li>\n<\/ul>\n
![\"\"](\"https:\/\/www.cloudacm.com\/wp-content\/uploads\/2023\/02\/ESP32-Cam_HC-SR04_MQTTFLow.png\")
<\/a><\/p>\nThe top 3 flow directly into individual dashboard text nodes containing the label and value format {{msg.payload}}. The bottom uptime node flows into a function node to convert millis into seconds. Here is the code for that function.<\/p>\n
var millis = msg.payload;\r\nvar S = millis \/ 1000;\r\nvar seconds = Math.floor(S);\r\nmsg.payload = seconds;\r\nreturn msg;<\/pre>\nThe payload then flows to another function node that converts the seconds tally into a DD:HH:MM:SS readable format. Here is the code for that function.<\/p>\n
var totalNumberOfSeconds = msg.payload;\r\nvar days = parseInt( totalNumberOfSeconds \/ 86400 );\r\nvar hours = parseInt (( totalNumberOfSeconds - ( days * 86400 )) \/ 3600 );\r\nvar minutes = parseInt ((totalNumberOfSeconds - ((hours * 3600)+( days * 86400 ))) \/ 60 );\r\nvar seconds = parseInt(totalNumberOfSeconds - ((hours * 3600) + (minutes * 60)+( days * 86400 )));\r\nvar result = (days < 10 ? \"0\" + days : days) + \" Days \" + (hours < 10 ? \"0\" + hours : hours) + \":\" + (minutes < 10 ? \"0\" + minutes : minutes) + \":\" + (seconds < 10 ? \"0\" + seconds : seconds);\r\nmsg.payload=result;\r\nreturn msg;<\/pre>\nThis then flows into its dashboard text node in similar fashion as the above 3 mentioned earlier. The use of MQTT feeds on the ESP32-Cam module and in Node-Red is powerful and it has great potential beyond the scope of this project.<\/p>\n
![\"\"](\"https:\/\/www.cloudacm.com\/wp-content\/uploads\/2023\/02\/ESP32-Cam_HC-SR04_WebUIStats.png\")
<\/a><\/p>\nThe next flow is a system status monitor of the ESP32-Cam module network connection. This flow starts with a ping node that has an interval of every 15 seconds. It then flows into a change node that replaces the msg.payload false or true values to string values of On or Off respectively. The flow then branches out in 2 directions with the first flow feeding a function node with the following code.<\/p>\n
msg.color = (msg.payload === \"On\")?\"red\":\"lime\";\r\nreturn msg;<\/pre>\n![\"\"](\"https:\/\/www.cloudacm.com\/wp-content\/uploads\/2023\/02\/ESP32-Cam_HC-SR04_PingFLow.png\")
<\/a><\/p>\nThis then flows into a dashboard text node with the value format set with these parameters.<\/p>\n
<font color={{msg.color}} ><i class=\"fa fa-circle\" style=\"font-size:24px;\"><\/i><\/font><\/pre>\nThe label in this node is also defined. The final results are a LED like indicator on the WebUI next to the label. The other branch from the change node mentioned earlier is sent to a separate flow that sends alerts to staff.<\/p>\n
The Arduino code above also had a line that defined the mqtt published reading from the HC-SR04 ultrasonic ranging module.<\/p>\n
client.publish(\"ESP32-Cam_WaterMonitor\/Level\", MeasureLevelCM.c_str());<\/pre>\n![\"\"](\"https:\/\/www.cloudacm.com\/wp-content\/uploads\/2023\/02\/ESP32-Cam_HC-SR04_WaterLevelFLow.png\")
<\/a><\/p>\nThe Node-Red flow here start with a mqtt in node and it subscribes to the topic “ESP32-Cam_WaterMonitor\/Level”. This then flows into a change node converting the msg.payload into an expression $number(payload), thus converting the string into an integer. The flow branches in 2 directions. The second branch will be covered later in the action flow. The first continues to a function node where a formula is applied to convert distance to a baseline of zero, here is the code in that function.<\/p>\n
msg.payload = (msg.payload*(-1))+41;\r\nreturn msg;<\/pre>\nThe next node is a dashboard artless-guage node that displays the reading as a linear bar. The minimum and maximum range values are set here.<\/p>\n
![\"\"](\"https:\/\/www.cloudacm.com\/wp-content\/uploads\/2023\/02\/ESP32-Cam_HC-SR04_WaterLevelWebUI.png\")
<\/a><\/p>\nThe last flow used in Node-Red will make use of context based variables. This will be the most complex flow thus far. Context based variables are an extremely powerful tool that can leverage the potential of Node-Red. Earlier on the HC-SR04 ultrasonic ranging module reading was converted to an integer. Here that value flows into a function node that processes the value with a formula and stores the reading as a variable. Here is the instruction in the node.<\/p>\n
msg.payload = (msg.payload*(-1))+41;\r\n\r\nvar reading=context.get(\"reading\");\r\n\r\nreading=msg.payload;\r\ncontext.set(\"reading\",reading);\r\n\r\nglobal.set(\"globalreading\",reading);\r\nreturn msg;<\/pre>\nAs the readings are updated on the ESP32-Cam module and published to the MQTT broker, Node-Red will receive those updated readings and store the new values into the variable defined. This will be useful because a separate flow will reference that variable.<\/p>\n
That separate flow will start with an inject node that is set to repeat at an interval every 3 seconds. It will then flow into a function node that gathers a host of variables and sets the msg.payload based on the variable values. Here is the function code.<\/p>\n
var bypass=global.get(\"globalbypass\");\r\nvar action=global.get(\"globalaction\");\r\nvar reading=global.get(\"globalreading\");\r\n\/\/ var pump=0;\r\n\r\nif (bypass==\"Auto\" && reading<=0)\r\n pump=0;\r\nif (bypass==\"Auto\" && reading>=2)\r\n pump=1;\r\n \r\nif (bypass==\"Manual\" && action==\"Off\")\r\n pump=0;\r\nif (bypass==\"Manual\" && action==\"On\")\r\n pump=1;\r\n\r\nmsg.payload=pump;\r\nreturn msg;<\/pre>\nThis then flows into 2 separate function nodes that have the following code.<\/p>\n
\/\/ Pump On Operator \r\nvar pump=msg.payload;\r\n\r\nif (pump==1)\r\n msg.payload=pump;\r\nelse { return }\r\n\r\nreturn msg;\r\n\r\n\/\/ Pump Off Operator \r\nvar pump=msg.payload;\r\n\r\nif (pump==0)\r\n msg.payload=pump;\r\nelse { return }\r\n\r\nreturn msg;<\/pre>\n![\"\"](\"https:\/\/www.cloudacm.com\/wp-content\/uploads\/2023\/02\/ESP32-Cam_HC-SR04_LogicFLow.png\")
<\/a><\/p>\nThe results of these nodes are passed to the mqtt broker. Parallel to this there are 2 dashboard button nodes, each of which publish a topic value to the mqtt broker. The end result is turn the water pump on or off.<\/p>\n
It was mentioned earlier that Node-Red was the heavy lifter and that was no exaggeration. The key takeaway is how context variables can be dynamically changed and referenced at any point in flows. Having that available is what makes controlling a water pump under any number of circumstances possible. Although it can be a difficult topic for some to grasp initially, it takes the burden off of the ESP32-Cam module and for that it’s invaluable. For more details, reference these links.<\/p>\n
https:\/\/techexplorations.com\/guides\/esp32\/node-red-esp32-project\/node-red-messages-variables\/<\/a>
\nhttps:\/\/nodered.org\/docs\/user-guide\/environment-variables<\/a><\/p>\n