This repository contains a series of arduino sketches created while exploring the use of an ESP32 board to manage plant watering based on windshield washer pumps and capacitive soil moisture sensors. Each sketch, with supporting files, is stored in its own folder, so that the complete folder can be downloaded directly to an Arduino sketchbook folder, then opened with the IDE. The irrigation repo folder can be treated like an Arduino sketchbook. This is a bit different than the usual git repository, in that "versions" are new folders. Previous versions are still visible in their own folders. This is done to make it easy to browse through the progression, and look at intermediate research.

The initial sketches loaded here are around reading the sensors and controlling the pump motor. Other exploration sketches exist, but are not uploaded here yet. For connecting to WiFi, setting the ESP32 RTC from internet time, and sending email notifications. SMS notifications work as well, as long as an email to SMS gate is available. Some telephone service providers have an Internet portal available for that, to send SMS to their own customers phones.

Some code blocks «will» also have examples and additional backround information in the esduino repository.

• send text
• capacitive soil moisture sensor
• capacitive soil moisture sensor with pump
• mcpwm explore
• capacitive soil moisture sensor with pump2
• capacitive soil moisture sensor with pump3
• capacitive soil moisture sensor with pump4
• capacitive soil moisture sensor with pump5
• project pin assignments
• pump5
• analog test
• watering
• pump6
• pump7
• pump8
• pump9
• analog mapping
• devkit v1 30 pinout
• adafruit huzzah32 feather pinout
• notes and constraints

• Features to be implemented, tested, merged
  • reservoir water level sensor
  • configuration profiles in static memory
  • wifi provisioning
  • ntp updating (and repeating)
  • sending email/sms notifications
  • «secure access» web site
    • certificate
    • authentication
    • authorization by function
    • configuration
    • status
    • history¦log

ADC2 can not be used while wi-fi is active. One or the other. Need to shutdown wifi while using analog read from ADC2. ADC1 does not conflict. With the current pin mapping, this affects (at least) the water level sensors.

Exploration of sample code to connect to a local wifi access point, set the time from an NTP server, and send notification reports to email and sms targets. This code is an extension and refactoring of the mobizt ESP Mail Client send text example code, combined with code from the getting data & time from NTP server with esp32 tutorial.

• secrets.h plus template_secrets.h
  • see esduino for information about creating and hiding secrets, template, and .gitignore
• refactored to external .cpp and .h files
• access ntp time server
• send email to multiple targets (including SMS)
• gmail key with 'less secure' setting

Reading values from the capacitive soil moisture sensor. This sketch is for a standard 5V UNO class Arduino board. It is used to test access to the sensor. The sensor calibration values are based on 0 to 1023 analog values, and the code from Capacitive Soil Moisture Sensor. That is different part than being used in the project (different voltage), but the same connection and features.

PWM speed control of the pump motor, triggered by low moisture levels. This sketch is for a standard 5V UNO class Arduino board. It is used to test the hardware motor control driver (a FET) circuit.

Explore configuration and usage of mcpwm library for motor speed control, without using an H bridge. Espressif esp idf api mcpwm reference and brushed dc motor control example.

Change to using an ESP32 DevKit board. This uses 3.3 volts, while the sensor works with 5V. An op-amp with gain locked to 1 is being used to buffer (condition) the signal, and a voltage divider is added (after the op-amp) to reduce the range to match to what the esp32 DevKit board can handle.

Use information from Espressif esp idf api adc and Espressif esp idf api mcpwm references to setup initial analog sensor reading, plus pwm speed control for a pump motor. Initial testing found the adc values to be varying considerably, so multiple readings are used and averaged.

• adc library
• mcpwm library

Refactor to move detail code to descriptive named functions.

• Same basic code logic as pump2, just structured a bit to move details into functions, keeping the top level flow easier to follow
• More hard-coded literal values moved to global constants
• rename some variables to match conventions

Convert sensor and control code to a basic state machine that does not use delay. This is preparation for handling multiple sensor and pump pairs.

Initial handling of multiple sensors and pumps.

• Expanded data structures to handle multiple sensors and water pumps
• Each sensor plus pump pair is handled by a separate state machine
• data structure ideas for using multiple factors to determine timing and amount of water to supply
  • Implementing is well beyond the scope of the current project
• move transition handling code to a callable function that takes a data structure for the specific state machine
• move individual state processing code to separate functions
• add shared resource for pump power
• add minimal logging for pump power resource hogging

Implement a shell that will later properly handle time of day and relative time references across system time adjustments from NTP updates, and system time counters wrapping from maximum values to zero.

• implement shell for expanded time handling
• move struct and enum definitions into an include file
• move default state machine data initialization to functions

ESP32 AnalogWrite polyfill library encountered while exploring ESP32 example code and tutorials. Reviewing the hardware level functionality of the existing code found no reason that the expanded features of the idf library calls were needed. This sketch verifies that, with the polyfill, standard Arduino IDE code has the capabilities needed.

• ESP32 AnalogWrite polyfill library
• no IDF / ESP32 specific library references, beyond the polyfill, and what is 'builtin' to the ESP32 boards definitions.
• test analogRead() and analogWrite() functionality
• analogReadResolution() to configure for full 12 bits ADC

ISSUES:

Issues were found with the underlying library code, but the scenarios that trigger problems are not needed for the code in this project.

• polyfill library
• analogRead

This sketch starts from capacitive soil moisture sensor with pump3, adds the analogWrite() pollyfill, then re-implements the hardware level sensing and control logic using 'standard' Arduino IDE functions.

• ESP32 AnalogWrite polyfill library
• no IDF / ESP32 specific library references, beyond the polyfill, and what is 'builtin' to the ESP32 boards definitions.
• refactor to move control data for a sensor+pump pair into a struct that is passed to functions
  • allow generic code, without a complex set of parameters, to be used for multiple pairs

Incorporate analogWrite() pollyfill test code from watering into a simplified non state machine version of the irrigation code.

• ESP32 AnalogWrite polyfill library
• no IDF / ESP32 specific library references, beyond the polyfill, and what is 'builtin' to the ESP32 boards definitions.
• typedefs to add type information for common irrigation specific data usage
• named watering zone struct instance
• array of watering zones, although it contains only a single entry

Re-implement state machine logic on top of the polyfill code.

• analogWrite() polyfill
• loop over array of irrigation zone state machines
• refactor data structures
• move structure and enum definitions into include file
• expand state machine states
• extended state debug reporting
• expand doxygen function documentation
• shell for smart time handling

refactor time, hardware watering access, most irrigation state machine code to separate .cpp and .h files.

• shell smart time handling in smart_time.cpp and .h
• hardware accessing watering related code moved to watering_management.cpp and .h
• irrigation state transition code moved to irrigation_state.cpp and .h
• implement state transition logging shell

Adjust state transition processing logic to remove unneeded transient states. Simplify the state machine.

• remove most transient states
• refactor to more generic 'resource' wait, instead of power wait.
• implement emergency shutdown. use when code detects inconsistent state.

Figure out which GPIO (digital) pin numbers are associated with each of the analog (A«n») pins used for the standard Arduino analogRead() function. The sketch maps analog A«n» references to the normal GPIO pin numbers. This mapping is based on the Arduino 'board' definition file being used. It is considerably different for the various DevKit flavours and the Adafruit HUZZAH32 Feature board.

• DevKit
  • 36=A0 39=A3 32=A4 33=A5 34=A6 35=A7 4=A10 0=A11 2=A12 15=A13 13=A14 12=A15 14=A16 27=A17 25=A18 26=A19
  • The sketch shows that A11 maps to GPIO0, which is not available on the DevKit board pins. The data sheet shows that GPIO0 is also ADC2_CH1, RTC_GPIO11, TOUCH1, EMACK_TX_CLI, CLK_OUT1.
• HUZZAH32
  • 26=A0 25=A1 34=A2 39=A3 36=A4 4=A5 14=A6 32=A7 15=A8 33=A9 27=A10 12=A11 13=A12 35=A13

• ESP32 Pin description «functions»

Create an extended svg version of pinout diagrams found for the 30 pin ESP32 DevKit V1 board. That is often (incorrectly) labeled as the 30 GPIO version. It is really 25 GPIO plus power, ground, and enable pins.

For extended information, see "2 Pin Definitions" in the ESP-WROOM-32 datasheet. That is the esp32 module used with the DevKit and HUZZAH32 Feather boards.

More information resources.

• ESP32 Series datasheet
  • A.1. Notes on ESP32 Pin Lists includes (11) for Ethernet_MAC. No information seen about using it, but gives a bit of description.
• ESP32 Technical Reference Manual
  • 10 Ethernet Media Access Controller (MAC)
• ESP32 Resources links to all available ESP32 documents, SDK and tools
  • Actually, seems to be document titles, not links. Need to do web search to find the documents themselves.

• ESP32 Series datasheet
  • 2.2 Pin Description
  • A.4. IO_MUX ¦ pin to function multiplexing