Arduino/ESP8266 Using interrupts to take samples

So, got this answered myself.

For the time resolution: you can get a much more exact time by using ESP.getCycleCount() which counts processor cycles - on my 80 MHz NodeMCU board that's 12.5 ns per cycle or 80 cycles per microsecond. I should have mentioned that in the first part.

Interrupts: this is something I misunderstood. Now I solved it by having the main function wait in a loop until a timeout is reached (set to 1 millisecond, normal expected times are in the 1-100 microseconds range), or until a global variable is set by the interrupt function. So now I'm measuring in the 12.5 nanosecond resolution!

One thing that's missing from this sketch is a correction for program time taken to deal with the timing: the time it takes from dropping the value on the EC pin to starting to count, and the time it takes from receiving the interrupt to stopping the count. If that overhead is say 100 cycles, that would be 1.25 microseconds, which is well within my measurement time.

// capacitor based TDS measurement

// pin D5 C+ - 330 ohm resistor----------|------------|       
//                                       |            |
//                                        cap        EC probe or
//                                       |           resistor (for simulation)
// pin D6 C- ----------------------------|            |
//                                                    |
// pin A0 EC -----------------------------------------|

#include <Average.h>

int capPos = D5;  //C+
int capNeg = D6;  //C-
int EC = D7;      //EC
unsigned long startCycle;
unsigned long endCycle;
#define CYCLETIME 12.5 // the time it takes in nanoseconds to complete one CPU cycle (12.5 ns on a 80 MHz processor)

float CAP = 47; // capacity in nF
#define calibration 150 // a calibration factor to link time with EC.

void setup() {
  Serial.begin(9600);
}

void loop () {
  float EC = getEC(); // get the EC as mS/cm.
  Serial.println (", EC: " + String(EC) + " mS/cm");
  delay(500);
}

float getEC() {

  int samples = 100;              // number of EC samples to take and average.
  unsigned long startTime;        // the time stamp (in microseconds) the measurement starts.
  unsigned long endTime;          // the time stamp (in microseconds) the measurement is finished.
  unsigned int dischargeTime;    // the time it took for the capacitor to discharge.
  Average<unsigned int> discharge(samples); // The sampling results.
  unsigned int chargeDelay = 500;         // The time (in microseconds) given to the cap to fully charge/discharge - about 10x RC is a good value.
  unsigned int timeout = 1;  // discharge timeout in milliseconds - if not triggered within this time, the EC probe is probably not there.

  int startLevel; // analog level of the pin.
  int endLevel;
  pinMode(A0, INPUT);

  for(int i=0; i<samples; i++) { // take <samples> measurements of the EC.

    // Stage 1: fully charge capacitor for positive cycle.
    // C+ high, C- low, EC disconnected.
    pinMode (EC, INPUT);
    pinMode (capPos,OUTPUT);
    digitalWrite (capPos, HIGH);
    pinMode (capNeg, OUTPUT);
    digitalWrite (capNeg, LOW);
    delayMicroseconds(chargeDelay);

    // Stage 2: positive side discharge; measure time it takes.
    // C+ disconnected, C- low, EC low.
    startCycle = ESP.getCycleCount();
    pinMode (capPos,INPUT); //set C+ to input to keep voltage from grounding a discharging thru this output pin
    pinMode (EC, OUTPUT); 
    digitalWrite (EC, LOW);

    // Use cycle counts and an interrupt to get a much more precise time measurement, especially for high-EC situations.
    endCycle = 0;
    startTime = millis();
    attachInterrupt(digitalPinToInterrupt(capPos), capDischarged, FALLING);
    while (endCycle == 0) {
      if (millis() > (startTime + timeout)) break;
    }
    detachInterrupt(digitalPinToInterrupt(capPos));
    if (endCycle == 0) dischargeTime = 0;
    else {

      // Handle potential overflow of micros() just as we measure, this happens about every 54 seconds
      // on a 80-MHz board.
      if (endCycle < startCycle) dischargeTime = (4294967295 - startCycle + endCycle) * CYCLETIME;
      else dischargeTime = (endCycle - startCycle) * CYCLETIME;
      discharge.push(dischargeTime);
    }

    // Stage 3: fully charge capacitor for negative cycle. C+ low, C- high, EC disconnected.
    pinMode (EC, INPUT); 
    pinMode (capPos,OUTPUT);
    digitalWrite (capPos, LOW);
    pinMode (capNeg, OUTPUT);
    digitalWrite (capNeg, HIGH);
    delayMicroseconds(chargeDelay);

    // Stage 4: negative side charge; don't measure as we just want to balance it the directions.
    // C+ disconnected, C- high, EC high.
    pinMode (capPos,INPUT); //set C+ to input to keep voltage from grounding a discharging thru this output pin
    pinMode (EC, OUTPUT); 
    digitalWrite (EC, HIGH);
    delayMicroseconds(dischargeTime/1000);

  }
  float dischargeAverage = discharge.mean();
  Serial.print("Discharge time: ");
  Serial.print(dischargeAverage);

  // Calculate EC from the discharge time.

  return dischargeAverage;
}

// Upon interrupt: register the cycle count of when the cap has discharged.
void capDischarged() {
  endCycle = ESP.getCycleCount();
  detachInterrupt(digitalPinToInterrupt(capPos));
}