The Arduino package manager has a library called NTPClient, which provides, as you might guess, an NTP client. Using this with the system clock lets you keep reasonable time without a battery-backed RTC.

Once you know what time it is, scheduling events becomes trivial. This isn't a fully working example, but should give you the idea. The docs have more information. The NTPClient also works quite well with the AceTime library for time zone and other management.

#include <NTPClient.h>
#include <WiFiUdp.h>
#include <ESP8266WiFi.h>
#include <AceTime.h>
#include <ctime>

using namespace ace_time;
using namespace ace_time::clock;
using namespace std;

WiFiUDP ntpUDP;
const long utcOffsetInSeconds = 0;  
// Get UTC from NTP - let AceTime figure out the local time
NTPClient timeClient(ntpUDP, "pool.ntp.org", utcOffsetInSeconds, 3600);  
//3600s/h - sync time once per hour, this is sufficient.
// don't hammer pool.ntp.org!


static BasicZoneProcessor estProcessor;
static SystemClockLoop systemClock(nullptr /*reference*/, nullptr /*backup*/);

const char* ssid = // your SSID;
const char* password = // your wifi password;
 
void setup() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.println("Connecting to wifi...");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.println('.');
    delay(500);
  }
  systemClock.setup();
  timeClient.begin();
}

int clockUpdateCounter = 50000;  
void loop(){
  // Update the system clock from the NTP client periodically
  if (++clockUpdateCounter > 50000){  // can be more elegant than this... depends on your loop speed, can actually use the real time for this too, I'm just making this simple because I don't have a lot of time...
    clockUpdateCounter = 0;
    timeClient.update();
    // doesn't matter how often you call timeClient.update().
    // you can put this in the main loop() if you want.  
    // We supplied 3600s as the refresh interval in the constructor
    // and internally .update() checks whether enough time has passed 
    // before making a request to the NTP server itself
    auto estTz = TimeZone::forZoneInfo(&zonedb::kZoneAmerica_Toronto, &estProcessor);
    auto estTime = ZonedDateTime::forUnixSeconds(timeClient.getEpochTime(), estTz);
    // using the system clock is optional, but has a few 
    // conveniences.  Here we just make sure that the systemClock remains 
    // sync'd with the NTP server.  Doesn't matter how often you do this
    // but usually around once an hour is plenty
    systemClock.setNow(estTime.toEpochSeconds());
  }
  systemClock.loop();
  delay(30);
}

The above keeps the system clock in sync with the NTP server. You can then use the system clock to fetch the time and use it for all types of timing purposes. eg :

 // get Time
  acetime_t nowT = systemClock.getNow();
  auto estTz = TimeZone::forZoneInfo(&zonedb::kZoneAmerica_Toronto, &estProcessor);
  auto nowTime = ZonedDateTime::forEpochSeconds(nowT, estTz);

Checking the time is fast, so you can do it inside loop() and only trigger the action when whatever time has elapsed.

This is a particularly nice solution for database integration since you can record a real timestamp of the actual date and time when logging your data to the database.

I guess your problem is a stack overflow, because of too many recursions.

You should try doing it with loops. Something like

while (Serial.available() == 0) {

delay(100);

}

And

do {

....

} while (inputChar != 13);

Probably need a capacitor across the power and ground at the device to fill in the surge when it starts ip. Maybe a 220uf or bigger.

I am assuming after you start watering you want to set V10 to 0 after 3 seconds.

First, you will have to set waterNow to 0 after you start watring. Otherwise waterNowrun() will keep executing.

Second, you need to keep track of the 'watering' state so that you know that you have to start tracking the time.

Third, save the time when the watering started so that you can compare with the current time to see if your '3 seconds' has been passed.

Here is a simple example:

// Global variables
const long int MAX_TIME_THRESHOLD_MS = 3000;
bool WateringStarted = false;
long int WateringStartTime = 0;

... ... ...

void waterNowrun() 
{
  if (waterNow == 1) 
  {
    digitalWrite(14, HIGH);
    Blynk.virtualWrite(V5, 255);
    lcdI2C.selectLine(2);
    lcdI2C.print("Watering Now     ");
    
    waterNow = 0;
    WateringStarted = true;
    WateringStartTime = millis();

  } 
  else   // <------ Why do you even have else! You only call waterNowrun() when waterNow == 1
  {                   
    digitalWrite(14, LOW);
    Blynk.virtualWrite(V5, 0);
  }
}

... ... ...

void loop()
{
  ... ... ...
  
  if(WateringStarted && (millis() - WateringStartTime) > MAX_TIME_THRESHOLD_MS)
  {
    WateringStarted = false;
    Blynk.virtualWrite(V10, 0);
    Blynk.syncAll();
  }

  ... ... ...

}

I haven't run this code and don't have your setup to check it either. But it should give you some idea. Also, check the comments to your question for some more information about millis().

Delay (traditionally) has two functions that it performs:

1. Wait for a period
2. Yield processing to other threads through the yield() weak symbol.

By using a delay(0) the author thinks they are saying "I don't want to delay here, but if anything is using the yield() function it can run now."

However, that is not correct.

The code for delay() in the AVR core looks like this:

void delay(unsigned long ms) 
{
    uint32_t start = micros();

    while (ms > 0) {
        yield();
        while ( ms > 0 && (micros() - start) >= 1000) {
            ms--;
            start += 1000;
        }
    }   
}

You can see that, as well as delaying for a period, yield() is regularly called. However that only ever happens if ms is greater than 0. If you pass 0 as the delay length then the delay() function essentially does nothing at all.

Now it could be that an earlier version of the core had yield() always being called even with ms==0, but the current version doesn't. Maybe this is a hangup from an old coding style. But for the current core if you want to yield you must explicitly call yield() or delay for at least one millisecond.