// LM - November 2022 - Compiled for NodeMCU ESP-12F
//      Experiment in auto-ranging

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

const boolean TEST_MODE = false;
const boolean DBM_UNITS = true;                  // True to convert ultra low power to dBm
/*
#define WIFI_SSID "WiFi network name here"       // Comment-out or remove if not implementing
#define WIFI_PASS "WiFi password here"           // UDP interface over WiFi
*/

// Application
#define PB_1 D4                                  // Measurement pushbutton
#define RELAY_1 D7
#define RELAY_2 D8
#define BAUD 115200                              // USB Serial monitor (not software serial)

#ifdef WIFI_SSID
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
IPAddress targetIP = {192, 168, 1, 175};         // Match to listener
#define targetPort 22200                         // Ditto
WiFiUDP Udp;                                     // Instantiate
const int UDP_BUFFER_DIM = 256;                  // Message buffers
char udpTxBuffer[UDP_BUFFER_DIM];
#endif

// OLED
#define OLED_I2C_ADDRESS 0x3C
#define DSPL_WIDTH 128
#define DSPL_HEIGHT 64
#define DSPL_RESET  -1

// Instantiate display
Adafruit_SSD1306 display(DSPL_WIDTH, DSPL_HEIGHT, &Wire, DSPL_RESET);

const int MIN_AD = 12;                           // Readings at or below this A/D value may be noise
const float SQRT2_DIV4 = 0.3535533905932737623;  // For convenience

// Ultra-Low interpolation array - A/D to RF millivolts P-P
const int NON_LINEAR_REGION = 80;

// Time constants
const unsigned long JIFFY = 100;                 // Normally 100 milliseconds (may be modified for testing)
const unsigned long HALFSEC = 500;
const unsigned long ONESEC = 1000;
const unsigned long TWOSEC = 2000;
const unsigned long DISPLAY_TIMEOUT = 10000;

byte relayStatus = 0;                            // 0=both off, 1=relay 1 on, 2=relay 2 on, 3=both on
const int RANGE_CHANGE_THRESHOLD = 75;           // When A/D < value switch to 10x
const int AREADS_PER_MEASURE = 10;               // Experimental
unsigned long lastDisplayTime = 0;

// Formatted display values
String sRaw = "";
String sVpp = "";
String sVrms = "";
String sPower = "";

void setup() {
  Serial.begin(BAUD);
  pinMode(PB_1, INPUT);
  pinMode(RELAY_1, OUTPUT);
  pinMode(RELAY_2, OUTPUT);

  if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_I2C_ADDRESS)) {
    Serial.println(F("OLED initialization failed"));
    while (true)
      ; // Do not proceed
  }
  
  Serial.println ("OLED initialized.");
  display.display();                             // Adafruit logo
  delay(ONESEC);
  myClearDisplay();
  displaySplash();
  delay(TWOSEC);
  
#ifdef WIFI_SSID
  Serial.println();
  Serial.println("Attempting to initialize WiFi");
  initWiFi();                                    // On failure, does not return
  Serial.println("WiFi connected!");
  Serial.print("Local IP: ");
  Serial.println(WiFi.localIP());
  delay(TWOSEC);
#endif 
   
  myClearDisplay();
  Serial.println();
  Serial.println("Startup complete!");
}

void loop() {
  if (buttonPress()) {
    myClearDisplay();
    if (TEST_MODE)  {
      testAutorange();
    }
    else                                         // Measure voltage
      autoRange();
  }

  if (millis() - lastDisplayTime > DISPLAY_TIMEOUT)  {
    myClearDisplay();
    lastDisplayTime = millis();
  }
}

void relayOn(int k) {
  // k = relay number 1 or 2
  if (k == 1)
    digitalWrite(RELAY_1, HIGH);
  else if (k == 2)
    digitalWrite(RELAY_2, HIGH);
}

void relayOff(int k) {
  // k = relay number 1 or 2
  if (k == 1)
    digitalWrite(RELAY_1, LOW);
  else if (k == 2)
    digitalWrite(RELAY_2, LOW);
}

boolean buttonPress() {
  if (digitalRead(PB_1) == HIGH)
    return false;
  delay(JIFFY);
  while (digitalRead(PB_1) == LOW)
    ;                                            // Debounce
  return true;
}

int avgAnalog(int n) {
  // Return average of n analogRead values
  // No validity checking (assumes n>0)
  unsigned int sum = 0;
  for (int i=0; i<n; i++)
    sum += analogRead(A0);
  return sum / n;
}

float fAvgAnalog(int n) {
  // Return floating average of n analogRead values
  // No validity checking (assumes n>0)
  unsigned int sum = 0;
  for (int i=0; i<n; i++)
    sum += analogRead(A0);
  return (float) sum / (float) n;
}

void autoRange() {
  int range = -1;                                // Enum 0 = Low, 1 = Medium, 2 = High
  float vPP;
  relayOff(1);
  relayOff(2);
  int iRaw = avgAnalog(AREADS_PER_MEASURE);
  if (iRaw < RANGE_CHANGE_THRESHOLD) {
    relayOn(1);
    delay(JIFFY);
    iRaw = avgAnalog(AREADS_PER_MEASURE);
    if (iRaw < RANGE_CHANGE_THRESHOLD) {
      relayOn(2);
      delay(JIFFY);      
      iRaw = avgAnalog(AREADS_PER_MEASURE);
      range = 0;                  
    }
    else {
      range = 1;      
    }
  }
  else {
    range = 2;    
  }
  relayOff(1);
  relayOff(2);

  if (range == 0) {                              // Process display for LOW range measures
    if (iRaw < NON_LINEAR_REGION) {              // Artificially enhance resolution
      float fRaw = fAvgAnalog(AREADS_PER_MEASURE);
      if (fRaw < NON_LINEAR_REGION)              // If consistent with first sampling
        vPP = .3656 * log(fRaw) - 0.7127;        // use the floating average,
      else                                       // else discard the resample (simplest).     
        vPP = .3656 * log((float) iRaw) - 0.7127;
      if (vPP < 0.)                              // Function may go negative below A/D noise level
        vPP = 0.;      
    }
    else
      vPP = .0072 * (float) iRaw + .3782;        // Revised 12/1/2022 y = 0.0072x + 0.3782 
    completeAutoRange(iRaw, vPP);
    }
  else if (range == 1) {
    vPP = .0877 * (float) iRaw - .3029;          // Revised 12/2/2022 y = 0.0877x - 0.3029        
    completeAutoRange(iRaw, vPP);
    }
  else {                                         // High range calibration bypasses RF rectifier   
    vPP = .634 * (float) iRaw - 4.237;           // y = 2 * high-range VDC linear regression    
    completeAutoRange(iRaw, vPP);                // Alternatively, y (Vpp) = 2.217x (A/D) + 0.5988
  }                                              // (composition of VDC and Vpp functions)
}

void completeAutoRange(int iRaw, float vPP) {
  float vRMS = toRMS(vPP);
  float pRMS = stdPwr(vPP);
      
  if (vPP < 1)
    sVpp = sResult(vPP, 0, true) + "V";
  else
    sVpp = sResult(vPP, 1, false) + " V";

  if (vRMS < 1)
    sVrms = sResult(vRMS, 0, true) + "V";
  else
    sVrms = sResult(vRMS, 1, false) + " V";
    
  if (DBM_UNITS && ((0. < pRMS) && (pRMS < .05))) {
    // Optional display units for ultra low range
    sPower = sDB(dBm(pRMS, true)) + "m";
  }
  else if (pRMS < 1)
    sPower = sResult(pRMS, 0, true) + "W";
  else
    sPower = sResult(pRMS, 1, false) + " W";
    
  sRaw = String(iRaw);
  displayGlobalMeasurements();

  if (iRaw <= MIN_AD) {                          // Handle out-of-range
    // Status out-of-range
    displayMessage("Warning: Low A/D " + sRaw);
    }
  else
    displayMessage("   Info: Raw A/D " + sRaw);  
}

float toRMS(float pp) {                          // Returns RMS voltage given peak to peak
    return pp * SQRT2_DIV4;
}

float dBm(float pwr) {                           // Convert power in milliwatts to dBm
  return 10. * log10(pwr);
}

float dBm(float pwr, boolean units) {            // Convert power to dBm - If units true, pwr in watts
  if (units)
    return dBm(pwr * 1000.);                     // watts to milliwatts to dBm
  else
    return dBm(pwr);
}

float stdPwr(float pp) {                         // Returns 50-ohm load power, given peak-to-peak voltage
  float rms = toRMS(pp);
  return rms * rms / 50;
}

// Display formatting

String sResult(float x, int dPlaces, boolean suffix) {
  // Return float as string, dPlaces (decimal places), optionally with milli or micro suffix  
  if (suffix) {
    if (x < .001)
      return String(x*1000000., dPlaces) + " u";
    else if (x < 1)
      return String(x*1000., dPlaces) + " m";
    else
      return String(x, dPlaces) + " ";            
  }
  // Fall through if NO suffix requested
  return String(x, dPlaces);
}

String sResult(float x, boolean suffix) {        // Overload the preceding - default zero decimal places
  return sResult(x, 0, suffix);
}

String sDB(float x) {                            // Returns decibels to 1 decimal place with suffix
  return String(x, 1) + " dB";
}

void myClearDisplay() {
  display.clearDisplay();
  display.display();
}

void displaySplash() {
  myClearDisplay();
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(20, 0);
  display.cp437(true);
  display.print("www.lloydm.net");
  display.display();
  lastDisplayTime = millis();
}

void displayGlobalMeasurements() {               // Display formatted voltages and computed power
  myClearDisplay;
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.print("    Measurements");
  display.setCursor(0,16);
  display.print("V p-p: ");
  display.print(sVpp);
  display.setCursor(0,28);
  display.print("V rms: ");
  display.print(sVrms);
  display.setCursor(0,40);
  display.print("50-ohm pwr: ");
  display.print(sPower);
  display.display();
  lastDisplayTime = millis();
#ifdef WIFI_SSID
  transmitGlobalMeasurements();
#endif
}

void displayMessage(String msg) {                // Status line at bottom
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0, 56);
  display.print(msg);
  display.display();
  lastDisplayTime = millis();
}

// WiFi

#ifdef WIFI_SSID
void initWiFi() {                                // Initialize WiFi
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  myClearDisplay;
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,16);
  display.print("    Connecting to:");
  display.setCursor(0,28);
  display.print(WIFI_SSID);
  display.display();
  // Wait for connection
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(JIFFY);
    Serial.print(".");
  }
  display.setCursor(0,45);
  display.print("IP: ");
  display.print(WiFi.localIP());
  display.display();
  return;
}  

void flushXmtBuffer() {
  for (int i = 0; i < UDP_BUFFER_DIM; i++)
    udpTxBuffer[i] = (byte) 0;
}

void sendUDP(String s) {
  flushXmtBuffer();
  for (int i=0; i<s.length(); i++)
    udpTxBuffer[i] = s.charAt(i);
  Udp.beginPacket(targetIP, targetPort);
  Udp.write(udpTxBuffer);
  Udp.endPacket();
}

void transmitGlobalMeasurements() {              // Transmit measurements to UDP listener
  String t = "Measurements:";                    // with minimum formatting for demo only
  t.concat(" V p-p: ");
  t.concat(sVpp);
  t.concat(", V rms: ");
  t.concat(sVrms);
  t.concat(", 50-ohm pwr: ");
  t.concat(sPower);
  sendUDP(t);
}

#endif

// Miscellaneous test / debug

void testRelays() {
  relayOff(1);
  relayOff(2);
  while (true) {
    relayOn(1);
    delay(HALFSEC);
    relayOff(1);
    relayOn(2);
    delay(HALFSEC);
    relayOff(2);
  }
}

void testRelays(int cycles) {
  relayOff(1);
  relayOff(2);
  for (int i=0; i<cycles; i++) {
    relayOn(1);
    delay(HALFSEC);
    relayOff(1);
    relayOn(2);
    delay(HALFSEC);
    relayOff(2);
  }
}

void testAnalogReads(int cycles) {
  relayOff(1);
  relayOff(2);
  for (int i=0; i<cycles; i++) {
    displayTestValue(avgAnalog(AREADS_PER_MEASURE));
    delay(HALFSEC);
    relayOn(1);
    displayTestValue(avgAnalog(AREADS_PER_MEASURE));
    delay(HALFSEC);
    relayOff(1);
    relayOn(2);
    displayTestValue(avgAnalog(AREADS_PER_MEASURE));
    delay(HALFSEC);
    relayOff(2);
    myClearDisplay();
  }
}

void testAutorange() {
  relayOff(1);
  relayOff(2);
  int iRaw = avgAnalog(AREADS_PER_MEASURE);
  if (iRaw < RANGE_CHANGE_THRESHOLD) {
    relayOn(1);
    delay(JIFFY);
    iRaw = avgAnalog(AREADS_PER_MEASURE);
    if (iRaw < RANGE_CHANGE_THRESHOLD) {
      relayOn(2);
      delay(JIFFY);      
      iRaw = avgAnalog(AREADS_PER_MEASURE);
      displayMessage("Range = Low");                  
    }
    else {
      displayMessage("Range = Medium");      
    }
  }
  else {
    displayMessage("Range = High");    
  }
  displayTestValue(iRaw);
  relayOff(1);
  relayOff(2);  
}

void displayTestValue(int value) {
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(15,30);
  display.print("Value: ");
  display.print(value);
  display.display();
  lastDisplayTime = millis();
}