As a Water Quality professional working in the drinking water field, I know how important it is to accurately monitor the disinfectant levels in the drinking water that gets served to the public. Usually, that means taking weekly grab samples in the distribution system and measuring free chlorine or total chlorine residual via a DPD colorimetric test. Sometimes, however, it would be nice to know what’s going on with the disinfectant residual when you’re not out there to take a sample. It would be nice to log the residual over time. That’s why I wanted to put together an inexpensive data logger that would measure and log pH, oxidation-reduction potential (ORP), and temperature. From those three parameters, the disinfectant residual can be approximated, not to mention that they are interesting parameters to measure and log in their own right. In my research for this project, I also came across some other uses in which this device might come in handy. It seems that aquarists regularly measure these parameters to keep their aquariums healthy, and it can also be used to keep track of oxidant levels in apool or spa. These are three very commonly measured parameters in water system security devices that are being used more and more to make sure that a water system is not being tampered with. And, it can be used in the lab for testing oxidant dosing, or measuring reaction kinetics.

My criteria for the project were that it had to be fairly easy to make; relatively inexpensive; and pretty accurate. I think what I’ve created meets those criteria, and I hope you do, too!

Step 1: Parts and Supplies

Step 2: Construction - Electronics

I have attached a diagram of the Fritzing wiring diagram for this project as a pdf. It isn’t laid out exactly like it is in my project box – the diagram utilizes a large breadboard instead of a prototyping shield and a smaller breadboard; and the LCD shown isn’t the exact one I had, nor is the temperature sensor. Also, I couldn't find Fritzing library files for the Atlas Scientific pH and ORP circuits, so I had to make my own for illustrative purposes, as well as modify the BNC connectors I could find. But the diagram does show what wires I have hooked up to which pins on the Arduino, which is the important part to get it to all working right with the programming. I used an LCD with a keypad because that’s what I had lying around; the keypad isn't used, however, so you can just use any 16x2 LCD without the keypad.

I got everything to work together outside of the project box first, then disassembled it and put it back together inside the box. For the LCD, I took a 170 tie point breadboard, cut it in half along the middle spacer, and then used half for each side of the LCD. I mounted the pH and ORP circuits on another small breadboard and cut holes in the side of the plastic project box for the BNC connectors to stick through, connecting the BNC connectors to the breadboard with the pH and ORP circuits with jumper wires. I did the same for the USB and power connectors for the UNO, and for the temperature probe. I also drilled some small holes on the back of the box to put small nylon screws through to secure the UNO and the temperature circuit.

pH_ORP_temp monitor_bb.pdf
Download

Step 3: Construction - Sample Cell

The probes, of course, have to be in contact with the solution being sampled. If the unit is being used in the laboratory, you can just immerse them in the container, such as a beaker or an Erlenmeyer flask, or use a probe holder. If your doing work in the field, you may need a sample cell to put the probes in, and then run the water through that. The sample cell I built for this purpose is very simple. I used a 2" diameter piece of PVC pipe with caps on the end. In one end, which will be the bottom, I drilled a hole and inserted a barbed fitting for 1/4" ID hose. This will be the water inlet. On the other end, I drilled a small hole for the temperature probe, and two 1/2" diameter holes for the pH and ORP probes. On the side near the top, I drilled a hole for a barbed fitting for a 1/2" ID hose. This will be the outlet for the water being sampled. The small diameter hose is attached to the water source, which is turned on at a very low rate of flow. The water flows into the flow cell through the bottom and overflows through the larger fitting on the side near the top. The water level is sufficient to keep the probes continuously covered. I added a couple of eye screws and a length of chain at the top to help secure the sample cell in the field.

Step 4: Arduino Code and Data Manipulation

I am definitely not a very experienced coder. The attached pdf of the code, also pasted below, was developed using Atlas Scientific code for both their pH and ORP circuits; one-wire temperature sensor code from Hacktronics (http://www.hacktronics.com/Tutorials/arduino-1-wire-tutorial.html); and other bits and pieces gleaned from a myriad of chat boards and other internet posts. Thank goodness for the open source community! Please feel free to comment on how best to clean it up and make it more functional. It will be important to go to the Hacktronics tutorial on finding the address for your particular temperature sensor, and then go in to the code and replace the address I have there with the one for your sensor to get it to work correctly. That tutorial can be found here - http://www.hacktronics.com/Tutorials/arduino-1-wire-address-finder.html .

As written, the instrument will take a ph, ORP, and temperature reading every 12 seconds; that time interval is easily adjusted by changing the delay in the program on line 95. It will display the readings on the LCD screen, and it will log the data to the SD card in a text file named datalog. When I am finished logging data, I open the file in Word, and it looks like the picture. I then do a search and replace for “^p,” (that’s a paragraph mark and a comma) and replace with a “^t” (that’s a tab character) to get tab delimited data. I then save the file and open it with Excel as a tab delimited text file. This gives me a spreadsheet with the elapsed time since the program began, in milliseconds, in the first column; the pH in the second column; the ORP in the third column; and the temperature in degrees Celsius in the fourth column. If you keep track of the time the program began, you can then calculate using Excel the time each reading was taken. Instructions to manipulate the data file are given in more detail in the attached file.

Code:
//Libraries
#include <LiquidCrystal.h>        //LCD library
#include <SoftwareSerial.h>       //SoftwareSerial library
#include <OneWire.h>
#include <DallasTemperature.h>
#include <SPI.h>                  //SPI library for SD card
#include <SD.h>                   //SD card library

//Serial ports
#define orprx 2                         //define what pin orp rx is going to be
#define orptx 3                         //define what pin orp Tx is going to be
SoftwareSerial orpserial(orprx, orptx); //define the ORP soft serial port
#define phrx 14                         //define what pin pH rx is going to be
#define phtx 15                         //define what pin pH Tx is going to be
SoftwareSerial phserial(phrx, phtx);    //define the pH soft serial port

//Temperature probe setup
#define ONE_WIRE_BUS 19                  // Data wire is plugged into pin 19 on the Arduino
OneWire oneWire(ONE_WIRE_BUS);           // Setup a oneWire instance to communicate with any OneWire devices
DallasTemperature sensors(&oneWire);     // Pass our oneWire reference to Dallas Temperature.
DeviceAddress insideThermometer = { 0x28, 0xB4, 0x6B, 0xC8, 0x04, 0x00, 0x00, 0x1F };     // Assign the addresses of your 1-Wire temp sensors.

//define ORP variables
char orp_data[20];                    //20 byte character array to hold ORP data
char orp_computerdata[20];            //20 byte character array to hold incoming data from a pc
byte orp_received_from_computer=0;    //we need to know how many character have been received.
byte orp_received_from_sensor=0;      //we need to know how many character have been received.
byte orp_startup=0;                   //used to make sure the arduino takes over control of the ORP Circuit properly.
float ORP=0;                          //used to hold a floating point number that is the ORP
byte orp_string_received=0;           //used to identify when we have received a string from the ORP circuit

//define pH variables
char ph_data[20];                    //20 byte character array to hold incoming pH
char ph_computerdata[20];            //20 byte character array to hold incoming data from a pc
//byte pc_debug=0;                   //if you would like to debug the pH Circuit through the serial monitor(pc/mac/other). if not set this to 0.
byte ph_received_from_computer=0;    //we need to know how many characters have been received from computer
byte ph_received_from_sensor=0;      //we need to know how many characters have been received from pH sensor
byte ph_startup=0;                   //used to make sure the arduino takes over control of the pH Circuit properly.
float ph=0;                          //used to hold a floating point number that is the pH.
byte ph_string_received=0;           //used to identify when we have received a string from the pH circuit.

//LCD set up
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); // select the pins used on the LCD panel

void setup(){
     Serial.begin(38400);        //enable the hardware serial port
     orpserial.begin(38400);     //enable the software serial port
     phserial.begin(38400);      //enable the software serial port
     sensors.begin();            //start up temp probe library
     sensors.setResolution(insideThermometer, 10);       // set the temp probe resolution to 10 bit
     lcd.begin(16, 2);           // start the lcd library
     SD.begin(16);
     pinMode(10, OUTPUT);
     }

void loop() {
sensors.requestTemperatures();         //read Temp probe
printTemperature(insideThermometer);

orpserial.listen();
delay(100);
if(orpserial.available() > 0){           //if we see that the ORP Circuit has sent a character.
     orp_received_from_sensor=orpserial.readBytesUntil(13,orp_data,20); //we read the data sent from ORP Circuit untill we see a <CR>. We also count how many character have been recived.
     orp_data[orp_received_from_sensor]=0; //we add a 0 to the spot in the array just after the last character we recived. This will stop us from transmiting incorrect data that may have been left in the buffer.
     orp_string_received=1;                //a flag used when the arduino is controlling the ORP Circuit to let us know that a complete string has been received.
}
phserial.listen();
delay(100);
if(phserial.available() > 0){          //if we see that the pH Circuit has sent a character.
     ph_received_from_sensor=phserial.readBytesUntil(13,ph_data,20); //we read the data sent from ph Circuit untill we see a <CR>. We also count how many character have been recived.
     ph_data[ph_received_from_sensor]=0; //we add a 0 to the spot in the array just after the last character we recived. This will stop us from transmiting incorrect data that may have been left in the buffer.
     ph_string_received=1;               //a flag used when the arduino is controlling the pH Circuit to let us know that a complete string has been received.
}
}
void printTemperature(DeviceAddress deviceAddress)
{
    int decPlaces = 0;     // set temp decimal places to 0
float tempC = sensors.getTempC(deviceAddress);
if (tempC == -127.00) {
    lcd.print("Error getting temperature");
} else {
     lcd.setCursor(0,0);   //set position on lcd for pH
     lcd.print("pH:");
     lcd.print(ph, 1);     //send pH to lcd
     lcd.setCursor(7,0);   //set position on lcd for ORP
     lcd.print("ORP:");
     lcd.print(ORP, 0);    //send ORP to lcd
     lcd.setCursor(0,1);   //set position on lcd for Temp
     lcd.print("Temp:");
     lcd.print("C ");
     lcd.print(tempC,decPlaces);     //display Temp in celsius
     lcd.print(" F ");
     lcd.print(DallasTemperature::toFahrenheit(tempC),decPlaces); //convert celsius to farenheit
     delay(10000);          //we will take a reading ever 10000ms

orpserial.print("R\r");                     //send it the command to take a single reading.
   if(orp_string_received==1){              //did we get data back from the ORP Circuit?
     ORP=atof(orp_data);                    //convert orp_data string to ORP float
     if(ORP>800){Serial.println("high\r");} //This is the proof that it has been converted into a string.
     if(ORP<800){Serial.println("low\r");} //This is the proof that it has been converted into a string.
     orp_string_received=0;}                //reset the string received flag.

phserial.print("R\r");                      //send it the command to take a single reading.
   if(ph_string_received==1){               //did we get data back from the ph Circuit?
     ph=atof(ph_data);                      //convert ph_data string to ph float
     if(ph>=7.5){Serial.println("high\r");} //This is the proof that it has been converted into a string.
     if(ph<7.5){Serial.println("low\r");}   //This is the proof that it has been converted into a string.
     ph_string_received=0;}                 //reset the string received flag.
}

long currentTime = millis();                                // Get the current time in ms (time since program start)
File dataFile = SD.open("datalog.txt", FILE_WRITE);         //open the file
if (dataFile) {                                            // if the file is available, write to it:
      dataFile.println(currentTime);                         // logs the time in milliseconds since the program started
      dataFile.print(",");                                   //inserts a comma
      dataFile.println(ph);                                  //logs the pH
      dataFile.print(",");                                   //inserts a comma
      dataFile.println(ORP);                                 //logs the ORP
      dataFile.print(",");                                   //inserts a comma
      dataFile.println(tempC);                               //logs the temperature in degrees C
      dataFile.print("\r");                                  //inserts a return character
      dataFile.close();
}
}

Step 5:

And that's it! Now it's all ready to go into the field and start collecting data, or get used in the lab for something like reaction kinetics monitoring. I hope I've presented my idea in a fairly organized fashion that didn't leave you with too many questions, but if you have any, please be sure to ask. And I would love any comments on how to improve things as well. Thanks, and please vote for my project if you find it interesting.