APAPHX2_ADS1115

Contents

What this library does

Hardware overview

Power domains

┌─────────────────────────────────────────────────────────────┐
│ MCU side (logic) │ Analog side (isolated) │
│ Connector P1 │ Connector CN2 │
│ │ │
│ Vcc-MC1: 3.3V or 5V │ +12V IN: external 12V DC │
│ GND-MC1: MCU ground │ 12V/GND: 12V ground │
│ SCL, SDA: I2C bus │ │
│ (same voltage as MCU) │ Powers all analog circuits │
│ │ behind ADUM1251 isolators │
└─────────────────────────────────────────────────────────────┘

Wiring

Connector P1 — IDC ×ばつ5 pin header (2.54mm pitch)

P1 Pin │ Signal │ Connect to
────────┼─────────────┼──────────────────────────────────────
 10 │ GND-MC1 │ MCU GND
 9 │ Vcc-MC1 │ MCU supply (3.3V or 5V — match MCU)
 8 │ SCL-MC1 │ MCU I2C SCL
 7 │ SDA-MC1 │ MCU I2C SDA
 6 │ RX-Alert │ MCU pin (optional — ALERT/RDY from ORP ADS1115)
 5 │ pH-Alert │ MCU pin (optional — ALERT/RDY from pH ADS1115)
 4 │ 12V GND │ 12V supply negative (tied to pin 2)
 3 │ 12V+ │ 12V supply positive (tied to pin 1)
 2 │ 12V GND │ 12V supply negative (tied to pin 4)
 1 │ 12V+ │ 12V supply positive (tied to pin 3)

Connector CN2 — KF2510 2-pin (alternative 12V connection)

CN2 Pin │ Signal │ Connect to
─────────┼──────────┼──────────────────
 1 │ 12V+ │ 12V supply positive
 2 │ 12V/GND │ 12V supply negative

I2C pullup jumper H3

Minimal wiring example (Arduino Uno)

Arduino Uno → PHX v2 P1
─────────────────────────
GND → Pin 10 (GND-MC1)
5V → Pin 9 (Vcc-MC1)
A5 (SCL) → Pin 8 (SCL-MC1)
A4 (SDA) → Pin 7 (SDA-MC1)
External PSU → PHX v2 CN2
─────────────────────────
12V+ → Pin 1
GND → Pin 2

Installation

Arduino IDE (Library Manager)

Arduino IDE (manual)

PlatformIO

; platformio.ini
lib_deps =
 https://github.com/apadevices/APAPHX2_ADS1115

Quick start

#include "APAPHX2_ADS1115.h"
ADS1115_PHX_PH phSensor(0x49); // pH — I2C address 0x49
ADS1115_PHX_RX rxSensor(0x48); // ORP — I2C address 0x48
void setup() {
 Serial.begin(115200);
 phSensor.begin();
 rxSensor.begin();
 if (!phSensor.isCalibrated()) {
 Serial.println("pH not calibrated — run calibration first");
 }
 if (!rxSensor.isCalibrated()) {
 Serial.println("ORP not calibrated — run calibration first");
 }
}
void loop() {
 // Non-blocking measurement
 static PHXConfig cfg;
 static bool cfgReady = false;
 if (!cfgReady) {
 cfg.samples = 10;
 cfg.delay_ms = 5;
 cfg.avg_buffer = 1;
 cfgReady = true;
 }
 phSensor.startReading(cfg);
 while (phSensor.getState() != PHXState::IDLE) {
 phSensor.updateReading();
 }
 rxSensor.startReading(cfg);
 while (rxSensor.getState() != PHXState::IDLE) {
 rxSensor.updateReading();
 }
 Serial.print("pH: ");
 Serial.print(phSensor.getLastReading(), 3);
 Serial.print(" ORP: ");
 Serial.print(rxSensor.getLastReading(), 1);
 Serial.println(" mV");
 delay(2000);
}

Calibration

Why calibration matters

What you need

Calibration process — guided API (recommended)

┌─────────────────────────────────────────────────────────────┐
│ Calibration timeline (per point) │
│ │
│ Place probe → Press enter → [200s soak] → [stable check] │
│ ↑ │
│ "Cal: wait 200s..." │ probe equilibrates │
│ ↓ │
│ "Calibration: stable!" │
│ Result stored in RAM │
└─────────────────────────────────────────────────────────────┘

#include "APAPHX2_ADS1115.h"
ADS1115_PHX_PH phSensor(0x49);
// Route library messages to Serial
void onMessage(const __FlashStringHelper* m) { Serial.println(m); }
void setup() {
 Serial.begin(115200);
 phSensor.begin();
 phSensor.setMessageCallback(onMessage);
 // ── STEP 1: First buffer solution ───────────────────────
 Serial.println("Rinse probe with distilled water.");
 Serial.println("Place probe in pH 4.0 buffer. Press ENTER when ready.");
 waitForEnter();
 float mV1 = phSensor.calibratePoint1(4.0f);
 Serial.print("Point 1 captured: "); Serial.print(mV1, 3);
 Serial.println(" mV");
 // ── STEP 2: Second buffer solution ──────────────────────
 Serial.println("Rinse probe with distilled water.");
 Serial.println("Place probe in pH 7.0 buffer. Press ENTER when ready.");
 waitForEnter();
 bool ok = phSensor.calibratePoint2(7.0f);
 if (ok) {
 phSensor.saveCalibration(); // persist to EEPROM
 Serial.println("Calibration saved.");
 } else {
 Serial.println("Calibration failed — check buffer solutions.");
 }
}
void waitForEnter() {
 while (Serial.available()) Serial.read();
 while (!Serial.available()) { ; }
 while (Serial.available()) Serial.read();
}
void loop() { }

Calibration process — advanced API

// Capture stable mV reading (blocking — ~200s minimum)
float mV = phSensor.calibratePHXReading();
// Build calibration struct manually
PHX_Calibration cal;
cal.ref1_mV = mV_at_buffer1;
cal.ref1_value = 4.0f;
cal.ref2_mV = mV_at_buffer2;
cal.ref2_value = 7.0f;
// Validate and store to RAM
bool ok = phSensor.calibratePHX(cal);
// Persist to EEPROM (call explicitly — not automatic)
if (ok) phSensor.saveCalibration();

Important calibration notes

Calibration status check

phSensor.begin();
if (phSensor.isCalibrated()) {
 PHX_Calibration cal = phSensor.getCalibration();
 Serial.print("ref1: "); Serial.print(cal.ref1_mV);
 Serial.print(" mV → "); Serial.println(cal.ref1_value);
 Serial.print("ref2: "); Serial.print(cal.ref2_mV);
 Serial.print(" mV → "); Serial.println(cal.ref2_value);
} else {
 Serial.println("No calibration found.");
}

EEPROM layout

API reference

Constructors

// pH sensor — default address 0x49, EEPROM base 128
ADS1115_PHX_PH phSensor(0x49);
// ORP/RX sensor — default address 0x48, EEPROM base 161
ADS1115_PHX_RX rxSensor(0x48);
// With ALERT pin
ADS1115_PHX_PH phSensor(0x49, A0);
// With custom EEPROM base (advanced — multiple boards)
ADS1115_PHX_PH phSensor(0x49, ADS1115_PHX::NO_ALERT, 200);

Initialisation

sensor.begin(); // init I2C, load calibration from EEPROM
sensor.begin(false); // skip Wire.begin() — if Wire already started

Non-blocking state machine

PHXConfig cfg;
cfg.samples = 10; // ADC samples per cycle (1–25)
cfg.delay_ms = 5; // pause between samples in ms (0 = immediate)
cfg.avg_buffer = 1; // rolling average window (1 = off, 2–10 = active)
sensor.startReading(cfg); // begin cycle
sensor.updateReading(); // call repeatedly in loop()
sensor.cancelReading(); // abort current cycle
PHXState s = sensor.getState(); // IDLE / COLLECTING / PROCESSING
bool done = sensor.isReadingComplete();
float val = sensor.getLastReading(); // calibrated pH or ORP mV
float raw = sensor.getLastRawMV(); // raw differential mV (pre-calibration)

Calibration

// Guided — recommended
float mV = sensor.calibratePoint1(4.0f); // step 1: first buffer
bool ok = sensor.calibratePoint2(7.0f); // step 2: second buffer + finalise
// Low-level
float mV = sensor.calibratePHXReading(); // blocking stable reading
bool ok = sensor.calibratePHX(cal); // validate + store to RAM
bool ok = sensor.saveCalibration(); // write to EEPROM
bool ok = sensor.loadCalibration(); // read from EEPROM
// Status
bool cal = sensor.isCalibrated();
PHX_Calibration cal = sensor.getCalibration();

Temperature compensation (pH only)

sensor.enableTemperatureCompensation(true);
sensor.setTemperature(25.0f); // °C, valid range 0–50°C
float t = sensor.getCurrentTemperature();
bool e = sensor.isTemperatureCompensationEnabled();

Rolling average

sensor.setRollingAverage(5); // window size 2–10 (1 = off)
sensor.clearRollingAverage(); // reset ring, keep window
bool ready = sensor.isRollingAverageReady(); // true once ring is full

ADC configuration

sensor.setGain(ADS1115_GAIN_1); // default: GAIN_2 for pH, GAIN_1 for ORP
sensor.setDataRate(ADS1115_DR_128); // default: 128 SPS (~7.8ms/conversion)
int16_t raw = sensor.readADC(); // single blocking read
float range = sensor.getVoltageRange(); // ±V for current gain

Errors

PHXError e = sensor.getLastError();
// PHXError::NONE / PH_LOW / PH_HIGH / RX_LOW / RX_HIGH
// TEMP_INVALID / CALIB_INVALID

Debug system

Enable debug output

// In APAPHX2_ADS1115.h:
#define ADS1115_DEBUG // <-- uncomment to enable debug output

phSensor.enableDebug(true);
phSensor.setDebugStream(Serial); // default — any Stream works
 // e.g. Serial1, SoftwareSerial

Message callback

Serial example

void onMessage(const __FlashStringHelper* m) {
 Serial.println(m);
}
phSensor.setMessageCallback(onMessage);
rxSensor.setMessageCallback(onMessage);

LCD example (LiquidCrystal_I2C)

LiquidCrystal_I2C lcd(0x27, 20, 4);
void onMessage(const __FlashStringHelper* m) {
 lcd.setCursor(0, 3); // bottom row
 lcd.print(F(" ")); // clear row
 lcd.setCursor(0, 3);
 lcd.print(m);
}
phSensor.setMessageCallback(onMessage);

Important notes

Platform notes

AVR (Arduino Uno, Nano, Mega)

#include <Wire.h>
#include "APAPHX2_ADS1115.h"
// Wire runs at 100kHz by default on AVR — no changes needed

ESP8266 / ESP32

#include <Wire.h>
#include "APAPHX2_ADS1115.h"
// Wire.begin(SDA_PIN, SCL_PIN) if using non-default pins

STM32 (STM32duino core)

#include <Wire.h>
#include "APAPHX2_ADS1115.h"
// Wire.setSDA(PB7); Wire.setSCL(PB6); // if needed for your board
// Wire.begin();

I2C speed

Wire.begin();
Wire.setClock(400000);
phSensor.begin(false); // false = skip Wire.begin() inside library
rxSensor.begin(false);

Examples

examples/
 simple/
 01_BasicReading/
 02_StateMachine/
 03_DualSensor/
 middle/
 04_Calibration/
 05_TemperatureComp/
 06_RollingAverage/
 advanced/
 07_DebugOutput/
 08_LCDDisplay/
 09_PoolMonitor/

Board quick spec

License