Unihiker K10 Ph Github

#include <Arduino.h>
#include <Wire.h>
#include <math.h>
#include <Adafruit_ADS1X15.h>
#include "unihiker_k10.h"

// Hardware wiring:
// SEN0161-V2 AOUT -> ADS1115 AIN0; ADS1115 SDA/SCL -> K10 GPIO47/GPIO48.
// K10 P1/GPIO2 -> DFR0523 SIG.

uint32_t pulseToDuty(uint16_t pulseUs);
void setPumpPulse(uint16_t pulseUs);
void stopPump();
float readFilteredMillivolts();
void updateCalibration();
float convertMillivoltsToPh(float millivolts);
String padded(const String &text);
void renderIfChanged();
void captureCalibrationPoint();
void requestDose();

constexpr uint8_t PUMP_PIN = 2;
constexpr uint8_t I2C_SDA_PIN = 47;
constexpr uint8_t I2C_SCL_PIN = 48;
constexpr uint8_t PH_ADC_CHANNEL = 0;
constexpr uint8_t PUMP_PWM_CHANNEL = 0;
constexpr uint8_t PUMP_PWM_BITS = 16;
constexpr uint32_t PUMP_PWM_HZ = 50;
constexpr uint16_t PUMP_PERIOD_US = 20000;

// ADS1115 GAIN_ONE has a +/-4.096 V full-scale range, or 0.125 mV/bit.
// The pH transmitter is powered from 3.3 V and specified to output 0-3.0 V.
constexpr float ADS1115_MV_PER_COUNT = 0.125f;
constexpr uint8_t ADS1115_ADDRESS = 0x48;

// DFRobot DFR0523 PPM protocol: 500-1400 us CW, 1400-1600 us stop,
// 1600-2500 us CCW. Orient tubing so CW moves reagent to the sample.
constexpr uint16_t PUMP_CW_US = 500;
constexpr uint16_t PUMP_STOP_US = 1500;
constexpr uint32_t DOSE_PULSE_MS = 100;
constexpr float TARGET_PH = 7.00f;
constexpr float ENDPOINT_BAND = 0.05f;
constexpr uint8_t SAMPLE_COUNT = 21;
constexpr uint32_t SAMPLE_INTERVAL_MS = 500;

UNIHIKER_K10 k10;
Adafruit_ADS1115 phAdc;

float lastMillivolts = NAN;
float ph7Millivolts = NAN;
float ph4Millivolts = NAN;
float measuredPh = NAN;
bool adcOnline = false;
bool calibrated = false;
bool doseActive = false;
uint32_t doseStartedMs = 0;
uint32_t lastSampleMs = 0;
bool previousButtonA = false;
bool previousButtonB = false;
String statusLine = "Starting ADS1115...";
String previousScreen = "";

uint32_t pulseToDuty(uint16_t pulseUs) {
  const uint32_t maxDuty = (1UL << PUMP_PWM_BITS) - 1UL;
  return (static_cast<uint32_t>(pulseUs) * maxDuty) / PUMP_PERIOD_US;
}

void setPumpPulse(uint16_t pulseUs) {
  ledcWrite(PUMP_PWM_CHANNEL, pulseToDuty(pulseUs));
}

void stopPump() {
  setPumpPulse(PUMP_STOP_US);
  doseActive = false;
}

float readFilteredMillivolts() {
  if (!adcOnline) {
    return NAN;
  }

  int16_t samples[SAMPLE_COUNT];
  for (uint8_t i = 0; i < SAMPLE_COUNT; ++i) {
    samples[i] = phAdc.readADC_SingleEnded(PH_ADC_CHANNEL);
  }

  // Sort then discard the three highest and three lowest samples.
  for (uint8_t i = 0; i < SAMPLE_COUNT - 1; ++i) {
    for (uint8_t j = i + 1; j < SAMPLE_COUNT; ++j) {
      if (samples[j] < samples[i]) {
        const int16_t temp = samples[i];
        samples[i] = samples[j];
        samples[j] = temp;
      }
    }
  }

  int32_t total = 0;
  for (uint8_t i = 3; i < SAMPLE_COUNT - 3; ++i) {
    total += samples[i];
  }
  const float averageCounts = static_cast<float>(total) / static_cast<float>(SAMPLE_COUNT - 6);
  return averageCounts * ADS1115_MV_PER_COUNT;
}

void updateCalibration() {
  calibrated = isfinite(ph7Millivolts) && isfinite(ph4Millivolts) &&
               fabsf(ph4Millivolts - ph7Millivolts) >= 20.0f;
}

float convertMillivoltsToPh(float millivolts) {
  if (!calibrated || !isfinite(millivolts)) {
    return NAN;
  }
  const float slope = (4.00f - 7.00f) / (ph4Millivolts - ph7Millivolts);
  return 7.00f + slope * (millivolts - ph7Millivolts);
}

String padded(const String &text) {
  String result = text;
  while (result.length() < 31) {
    result += ' ';
  }
  return result;
}

void renderIfChanged() {
  const String phText = calibrated && isfinite(measuredPh) ? String(measuredPh, 2) : "--.--";
  const String adcText = isfinite(lastMillivolts) ? String(lastMillivolts, 1) : "--.-";
  const String adcState = adcOnline ? "ADS1115 OK" : "ADS1115 NOT FOUND";
  const String screen = "pH TITRATOR\n"
                        "pH: " + phText + " target: " + String(TARGET_PH, 2) + "\n"
                        "ADC: " + adcText + " mV " + adcState + "\n"
                        "7.00: " + (isfinite(ph7Millivolts) ? String(ph7Millivolts, 1) : String("not saved")) + " mV\n"
                        "4.00: " + (isfinite(ph4Millivolts) ? String(ph4Millivolts, 1) : String("not saved")) + " mV\n"
                        "Pump: " + String(doseActive ? "DOSING" : "STOPPED") + "\n" + statusLine;
  if (screen == previousScreen) {
    return;
  }
  previousScreen = screen;

  k10.canvas->canvasText(padded("pH TITRATOR"), 1, 0x0000FF);
  k10.canvas->canvasText(padded("pH: " + phText + " Target: " + String(TARGET_PH, 2)), 2, 0x000000);
  k10.canvas->canvasText(padded("ADC: " + adcText + " mV " + adcState), 3, adcOnline ? 0x000000 : 0xFF0000);
  k10.canvas->canvasText(padded("7.00: " + (isfinite(ph7Millivolts) ? String(ph7Millivolts, 1) : String("not saved")) + " mV"), 4, 0x000000);
  k10.canvas->canvasText(padded("4.00: " + (isfinite(ph4Millivolts) ? String(ph4Millivolts, 1) : String("not saved")) + " mV"), 5, 0x000000);
  k10.canvas->canvasText(padded("Pump: " + String(doseActive ? "DOSING" : "STOPPED")), 6, doseActive ? 0xFF0000 : 0x008000);
  k10.canvas->canvasText(padded(statusLine), 7, 0x000000);
  k10.canvas->canvasText(padded("A=calibrate  B=100ms dose"), 8, 0x666666);
  k10.canvas->updateCanvas();
}

void captureCalibrationPoint() {
  if (!adcOnline || !isfinite(lastMillivolts)) {
    statusLine = "ADS1115 unavailable; check I2C wiring";
    return;
  }
  if (!isfinite(ph7Millivolts)) {
    ph7Millivolts = lastMillivolts;
    statusLine = "pH 7.00 saved; rinse, then pH 4.00";
  } else {
    ph4Millivolts = lastMillivolts;
    updateCalibration();
    statusLine = calibrated ? "Calibrated: B doses 100 ms" : "Calibration failed; repeat pH 7 then pH 4";
    if (!calibrated) {
      ph7Millivolts = NAN;
      ph4Millivolts = NAN;
    }
  }
}

void requestDose() {
  if (!adcOnline) {
    statusLine = "ADS1115 unavailable; pump locked";
    return;
  }
  if (!calibrated) {
    statusLine = "Calibrate pH 7 then pH 4 first";
    return;
  }
  if (isfinite(measuredPh) && fabsf(measuredPh - TARGET_PH) <= ENDPOINT_BAND) {
    statusLine = "Endpoint band reached; pump locked";
    return;
  }
  setPumpPulse(PUMP_CW_US);
  doseStartedMs = millis();
  doseActive = true;
  statusLine = "Dosing 100 ms; mix before next dose";
}

void setup() {
  Serial.begin(115200);
  k10.begin();
  k10.initScreen(2);
  k10.creatCanvas();
  k10.setScreenBackground(0xFFFFFF);

  Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);
  adcOnline = phAdc.begin(ADS1115_ADDRESS, &Wire);
  if (adcOnline) {
    phAdc.setGain(GAIN_ONE);
    statusLine = "ADS1115 ready; A captures pH 7";
    lastMillivolts = readFilteredMillivolts();
  } else {
    statusLine = "ADS1115 missing: check SDA/SCL";
  }

  ledcSetup(PUMP_PWM_CHANNEL, PUMP_PWM_HZ, PUMP_PWM_BITS);
  ledcAttachPin(PUMP_PIN, PUMP_PWM_CHANNEL);
  stopPump();
  renderIfChanged();
}

void loop() {
  const uint32_t now = millis();
  if (doseActive && (now - doseStartedMs >= DOSE_PULSE_MS)) {
    stopPump();
  }
  if (adcOnline && now - lastSampleMs >= SAMPLE_INTERVAL_MS) {
    lastSampleMs = now;
    lastMillivolts = readFilteredMillivolts();
    measuredPh = convertMillivoltsToPh(lastMillivolts);
  }

  const bool buttonA = k10.buttonA->isPressed();
  const bool buttonB = k10.buttonB->isPressed();
  if (buttonA && !previousButtonA && !doseActive) {
    captureCalibrationPoint();
  }
  if (buttonB && !previousButtonB) {
    if (doseActive) {
      stopPump();
      statusLine = "Dose cancelled";
    } else {
      requestDose();
    }
  }
  previousButtonA = buttonA;
  previousButtonB = buttonB;
  renderIfChanged();
  delay(10);
}