Pendahuluan

Kit ini merupakan perangkat sensor oksigen terlarut yang kompatibel dengan Arduino Board. Produk ini digunakan untuk mengukur oksigen terlarut dalam air, untuk mengetahui kualitas air. Kit ini banyak diterapkan dalam banyak aplikasi kualitas air, seperti akuakultur, pemantauan lingkungan, dan sebagainya. Kualitas air yang baik sangat penting bagi organisme akuatik. Oksigen terlarut adalah salah satu parameter penting untuk mencerminkan kualitas air. Oksigen terlarut yang rendah dalam air akan menyebabkan organisme akuatik kesulitan bernafas, hal itu dapat mengancam kehidupan organisme tersebut. Oleh karena itu, dfrobot meluncurkan Analog Dissolved Oxygen Sensor Kit yang kompatibel dengan Arduino. Kit sensor ini membantu Anda dengan cepat membuat detektor oksigen terlarut sendiri.
Papan konverter sinyal plug and play, dan memiliki kompatibilitas yang baik, dapat dengan mudah diintegrasikan ke sistem kontrol. Kit ini menggunakan probe galvanic yang memakai konektor BNC, wadah pengisian dan tutup membran dapat di ganti. Kit ini sangat cocok untuk proyek Anda dalam mendeteksi konsentrasi oksigen terlarut dalam air.

Spesifikasi

Dissolved Oxygen Probe

• Type: Galvanic Probe
• Detection Range: 0~20 mg/L
• Temperature Range: 0~40 ℃
• Response Time: Up to 98% full response, within 90 seconds (25℃)
• Pressure Range: 0~50 PSI
• Electrode Service Life: 1 year (normal use)
• Maintenance Period:Membrane Cap Replacement Period:1~2 months (in muddy water);
• Maintenance Period:Membrane Cap Replacement Period:4~5 months (in clean water)
• Filling Solution Replacement Period: Once every month
• Cable Length: 2 meters
• Probe Connector: BNC

Signal Converter Board

• Supply Voltage: 3.3~5.5V
• Output Signal: 0~3.0V
• Cable Connector: BNC
• Signal Connector: Gravity Analog Interface (PH2.0-3P)
• Dimension: 42mm x 32mm

Gambar Papan Konverter Sinyal

No	Label	Deskripsi
1	A	Keluaran Sinyal Analog (0-3.0V)
2	+	VCC (3.3~5.5V)
3	–	GND
4	BNC	Probe Konektor Sensor

Tutorial

Tutorial ini akan menunjukkan cara menggunakan dissolved oxygen Sensor. Probe oksigen terlarut adalah memakai sensor precision electrochemical sensor. Mohon perhatikan detail penggunaannya.

Perhatian:

• Sebelum Menggunakan Kit ini, wadah membran harus diisi dengan cairan 0.5mol/L NaOH. NaOH merupakan larutan yang sangat korosif, palai sarung tangan sebelum mengisinya. Jika NaOH terjatuh dan mengenai kulit, cuci atau bersihkan kulit tersebut dengan air yang banyak sesegera mungkin. Membran oksigen pada wadah membran sangat sensitif dan juga rentan. Hati2 saat memegangnya. Selama proses pengkuran, probe sensor akan sedikit memakai oksigen. Kita perlu memutar air dengan perlahan dan biarkan oksigen didistribusikan secara merata di dalam air. Jangan mengaduk dengan air dengan cepat, hal ini mencegah oksigen di udara masuk dengan cepat ke dalam air.

Alat yang Dibutuhkan

• Dissolved Oxygen Probe (With Membrane Cap) x 1
• 0.5mol/L NaOH Solution x 1
• Arduino Board x 1
• Dissolved Oxygen Signal Converter Board x 1
• Analog Cable (3Pin) x 1
• Arduino IDE Software

Persiapan Probe Sensor

Probe Sensor yang baru dipakai harus di isi dengan 0.5 mol/L larutan NaOH ke dalam wadah membran sensor. Jika probe sudah pernah di pakai selama beberapa waktu dan error yang di hasilkan probe tersebut sangat besar, sudah waktunya untuk menggati lurutannya atau mengganti sensor probe oksigen.

Buka tutup wadah membran dari probe dan isi sekitar 2/3 volume wadah dengan 0,5 mol / L larutan NaOH. Saat melakukan pengisian, pastikan probe dalam posisi vertikal. Pasang kembali wadah membran ke dalam probe dengan hati-hati. Alangkah baiknya pada saat di pasang kembali larutan NaOH meluap keluar dari tutupnya/wadah membran untuk memastikan probe terisi penuh dengan larutan NaOH. Setelah digunakan, segera tutup botol larutan NaOH untuk mencegah CO2 di udara memengaruhi larutan tersebut. Gambar proses pengisian NaOH dapat di lihat pada gambar dibawah ini.

Diagram Koneksi

Ketika probe sudah diisi dengan larutan NaOH, kit sensor memerlukan kalibrasi. Sebelum melakukan kalibrasi, hubungkan probe dengan arduino seperti gambar dibawah ini.

Proses Kalibrasi

Dalam melakukan kalibrasi sensor ini, terdapat 2 metode, yaitu metode single point calibration dan metode double point calibration. Single point calibration yaitu proses kalibrasi dengan cara mencari nilai saturasi dari oksigen yang terlarut dalam air. Double point calibration yaitu proses kalibrasi dengan cara mencari nilai saturasi dari oksigen yang terlarut dalam air dan nilai 0 (Tidak ada oksigen) pada oksigen yang terlarut dalam air. Tetapi dalam banyak kasus, single point calibration paling banyak digunakan. Tutorial kali ini akan menggunakan single point calibration.

Tutorial Single Point Calibration

1. Upload program sample code ke arduino board dan buka serial monitor. Nilai dari oksigen yang terlarut akan muncul setiap 1 detik.
2. Celupkan probe ke dalam air oksigen terlarut jenuh dan aduk perlahan. Tunggu sampai pembacaan dalam serial monitor stabil. Biasanya pembacaan akan stabil setelah lebih dari 1 menit, hal ini karena reaksi elektrokimia di dalam probe butuh waktu yang tidak sebentar. Jika air oksigen yang terlarut jenuh tidak ada, udara dapat menjadi penggantinya. Celupkan probe kedalam air dan aduk wair beberapa kali unutk membasahi membran pada wadah. Paparkan probe ke udara selama lebih dari 1 menit.
3. Tunggu sampai pembacaan nilai oksigen terlarut stabil. Setelah itu kita dapat melakukan proses kalibrasi. Langkah-langkah adalah sebagai berikut:

• Ketik “Calibration” di serial monitor untuk masuk kedalam mode kalibrasi

• Ketik “SATCAL” untuk melakukan kalibrasi. Program akan memberitahukan

• Setelah melakukan kalibrasi, ketik “EXIT”untuk keluar dari mode kalibrasi

• Setelah proses diatas diselesaikan, kit sudah siap dipakai untuk melakukan pengukuran.

Sample Code

/***************************************************
 DFRobot Gravity: Analog Dissolved Oxygen Sensor / Meter Kit for Arduino
 <https://www.dfrobot.com/wiki/index.php/Gravity:_Analog_Dissolved_Oxygen_Sensor_SKU:SEN0237>

 ***************************************************
 This example reads the concentration of dissolved oxygen in water.
 The saturated oxygen calibration is available by UART commends with NL & CR:
 calibration  ----  enter the calibration mode
 satcal       ----  calibrate the parameters with saturated oxygen value
 exit         ----  exit the calibration mode

 Created 2017-5-22
 By Jason <jason.ling@dfrobot.com@dfrobot.com>

 GNU Lesser General Public License.
 See <http://www.gnu.org/licenses/> for details.
 All above must be included in any redistribution
 ****************************************************/

 /***********Notice and Trouble shooting***************
 1. This code is tested on Arduino Uno and Leonardo with Arduino IDE 1.0.5 r2 and 1.8.2.
 2. More details, please click this link: <https://www.dfrobot.com/wiki/index.php/Gravity:_Analog_Dissolved_Oxygen_Sensor_SKU:SEN0237>
 ****************************************************/

#include <avr/pgmspace.h>
#include <EEPROM.h>

#define DoSensorPin  A1    //dissolved oxygen sensor analog output pin to arduino mainboard
#define VREF 5000    //for arduino uno, the ADC reference is the AVCC, that is 5000mV(TYP)
float doValue;      //current dissolved oxygen value, unit; mg/L
float temperature = 25;    //default temperature is 25^C, you can use a temperature sensor to read it

#define EEPROM_write(address, p) {int i = 0; byte *pp = (byte*)&(p);for(; i < sizeof(p); i++) EEPROM.write(address+i, pp[i]);}
#define EEPROM_read(address, p)  {int i = 0; byte *pp = (byte*)&(p);for(; i < sizeof(p); i++) pp[i]=EEPROM.read(address+i);}

#define ReceivedBufferLength 20
char receivedBuffer[ReceivedBufferLength+1];    // store the serial command
byte receivedBufferIndex = 0;

#define SCOUNT  30           // sum of sample point
int analogBuffer[SCOUNT];    //store the analog value in the array, readed from ADC
int analogBufferTemp[SCOUNT];
int analogBufferIndex = 0,copyIndex = 0;

#define SaturationDoVoltageAddress 12          //the address of the Saturation Oxygen voltage stored in the EEPROM
#define SaturationDoTemperatureAddress 16      //the address of the Saturation Oxygen temperature stored in the EEPROM
float SaturationDoVoltage,SaturationDoTemperature;
float averageVoltage;

const float SaturationValueTab[41] PROGMEM = {      //saturation dissolved oxygen concentrations at various temperatures
14.46, 14.22, 13.82, 13.44, 13.09,
12.74, 12.42, 12.11, 11.81, 11.53,
11.26, 11.01, 10.77, 10.53, 10.30,
10.08, 9.86,  9.66,  9.46,  9.27,
9.08,  8.90,  8.73,  8.57,  8.41,
8.25,  8.11,  7.96,  7.82,  7.69,
7.56,  7.43,  7.30,  7.18,  7.07,
6.95,  6.84,  6.73,  6.63,  6.53,
6.41,
};

void setup()
{
    Serial.begin(115200);
    pinMode(DoSensorPin,INPUT);
    readDoCharacteristicValues();      //read Characteristic Values calibrated from the EEPROM
}

void loop()
{
   static unsigned long analogSampleTimepoint = millis();
   if(millis()-analogSampleTimepoint > 30U)     //every 30 milliseconds,read the analog value from the ADC
   {
     analogSampleTimepoint = millis();
     analogBuffer[analogBufferIndex] = analogRead(DoSensorPin);    //read the analog value and store into the buffer
     analogBufferIndex++;
     if(analogBufferIndex == SCOUNT)
         analogBufferIndex = 0;
   }

   static unsigned long tempSampleTimepoint = millis();
   if(millis()-tempSampleTimepoint > 500U)  // every 500 milliseconds, read the temperature
   {
      tempSampleTimepoint = millis();
      //temperature = readTemperature();  // add your temperature codes here to read the temperature, unit:^C
   }

   static unsigned long printTimepoint = millis();
   if(millis()-printTimepoint > 1000U)
   {
      printTimepoint = millis();
      for(copyIndex=0;copyIndex<SCOUNT;copyIndex++)
      {
        analogBufferTemp[copyIndex]= analogBuffer[copyIndex];
      }
      averageVoltage = getMedianNum(analogBufferTemp,SCOUNT) * (float)VREF / 1024.0; // read the value more stable by the median filtering algorithm
      Serial.print(F("Temperature:"));
      Serial.print(temperature,1);
      Serial.print(F("^C"));
      doValue = pgm_read_float_near( &SaturationValueTab[0] + (int)(SaturationDoTemperature+0.5) ) * averageVoltage / SaturationDoVoltage;  //calculate the do value, doValue = Voltage / SaturationDoVoltage * SaturationDoValue(with temperature compensation)
      Serial.print(F(",  DO Value:"));
      Serial.print(doValue,2);
      Serial.println(F("mg/L"));
   }

   if(serialDataAvailable() > 0)
   {
      byte modeIndex = uartParse();  //parse the uart command received
      doCalibration(modeIndex);    // If the correct calibration command is received, the calibration function should be called.
   }

}

boolean serialDataAvailable(void)
{
  char receivedChar;
  static unsigned long receivedTimeOut = millis();
  while ( Serial.available() > 0 )
  {
    if (millis() - receivedTimeOut > 500U)
    {
      receivedBufferIndex = 0;
      memset(receivedBuffer,0,(ReceivedBufferLength+1));
    }
    receivedTimeOut = millis();
    receivedChar = Serial.read();
    if (receivedChar == '\n' || receivedBufferIndex == ReceivedBufferLength)
    {
    receivedBufferIndex = 0;
    strupr(receivedBuffer);
    return true;
    }else{
        receivedBuffer[receivedBufferIndex] = receivedChar;
        receivedBufferIndex++;
    }
  }
  return false;
}

byte uartParse()
{
    byte modeIndex = 0;
    if(strstr(receivedBuffer, "CALIBRATION") != NULL)
        modeIndex = 1;
    else if(strstr(receivedBuffer, "EXIT") != NULL)
        modeIndex = 3;
    else if(strstr(receivedBuffer, "SATCAL") != NULL)
        modeIndex = 2;
    return modeIndex;
}

void doCalibration(byte mode)
{
    char *receivedBufferPtr;
    static boolean doCalibrationFinishFlag = 0,enterCalibrationFlag = 0;
    float voltageValueStore;
    switch(mode)
    {
      case 0:
      if(enterCalibrationFlag)
         Serial.println(F("Command Error"));
      break;

      case 1:
      enterCalibrationFlag = 1;
      doCalibrationFinishFlag = 0;
      Serial.println();
      Serial.println(F(">>>Enter Calibration Mode<<<"));
      Serial.println(F(">>>Please put the probe into the saturation oxygen water! <<<"));
      Serial.println();
      break;

     case 2:
      if(enterCalibrationFlag)
      {
         Serial.println();
         Serial.println(F(">>>Saturation Calibration Finish!<<<"));
         Serial.println();
         EEPROM_write(SaturationDoVoltageAddress, averageVoltage);
         EEPROM_write(SaturationDoTemperatureAddress, temperature);
         SaturationDoVoltage = averageVoltage;
         SaturationDoTemperature = temperature;
         doCalibrationFinishFlag = 1;
      }
      break;

        case 3:
        if(enterCalibrationFlag)
        {
            Serial.println();
            if(doCalibrationFinishFlag)
               Serial.print(F(">>>Calibration Successful"));
            else
              Serial.print(F(">>>Calibration Failed"));
            Serial.println(F(",Exit Calibration Mode<<<"));
            Serial.println();
            doCalibrationFinishFlag = 0;
            enterCalibrationFlag = 0;
        }
        break;
    }
}

int getMedianNum(int bArray[], int iFilterLen)
{
      int bTab[iFilterLen];
      for (byte i = 0; i<iFilterLen; i++)
      {
      bTab[i] = bArray[i];
      }
      int i, j, bTemp;
      for (j = 0; j < iFilterLen - 1; j++)
      {
      for (i = 0; i < iFilterLen - j - 1; i++)
          {
        if (bTab[i] > bTab[i + 1])
            {
        bTemp = bTab[i];
            bTab[i] = bTab[i + 1];
        bTab[i + 1] = bTemp;
         }
      }
      }
      if ((iFilterLen & 1) > 0)
    bTemp = bTab[(iFilterLen - 1) / 2];
      else
    bTemp = (bTab[iFilterLen / 2] + bTab[iFilterLen / 2 - 1]) / 2;
      return bTemp;
}

void readDoCharacteristicValues(void)
{
    EEPROM_read(SaturationDoVoltageAddress, SaturationDoVoltage);
    EEPROM_read(SaturationDoTemperatureAddress, SaturationDoTemperature);
    if(EEPROM.read(SaturationDoVoltageAddress)==0xFF && EEPROM.read(SaturationDoVoltageAddress+1)==0xFF && EEPROM.read(SaturationDoVoltageAddress+2)==0xFF && EEPROM.read(SaturationDoVoltageAddress+3)==0xFF)
    {
      SaturationDoVoltage = 1127.6;   //default voltage:1127.6mv
      EEPROM_write(SaturationDoVoltageAddress, SaturationDoVoltage);
    }
    if(EEPROM.read(SaturationDoTemperatureAddress)==0xFF && EEPROM.read(SaturationDoTemperatureAddress+1)==0xFF && EEPROM.read(SaturationDoTemperatureAddress+2)==0xFF && EEPROM.read(SaturationDoTemperatureAddress+3)==0xFF)
    {
      SaturationDoTemperature = 25.0;   //default temperature is 25^C
      EEPROM_write(SaturationDoTemperatureAddress, SaturationDoTemperature);
    }
}