Continous HAB monitoring

This topic has 8 replies, 3 voices, and was last updated 2024-11-11 at 4:56 PM by Shannon Hicks.

Viewing 6 reply threads

Author

Posts

2024-07-05 at 5:51 PM #18562
nick
Participant
Hi,

Has anyone setup their Mayfly data logger to monitor HABs in ponds/lakes? Right now, we are manually collecting the samples and trying to see if doing continuous monitoring would be beneficial.

Thank you.
2024-07-12 at 3:53 PM #18573
Scott Ensign
Participant
Yes, the Stroud Center has a Campbell Scientific phycocyanin sensor deployed on a Mayfly Data Logger. @shicks might be able to share code with you.
2024-07-12 at 10:31 PM #18574
Shannon Hicks
Moderator
They are actually Turner Designs Cyclops-7F sensors that we use for measuring chlorophyll and phycocyanin (https://www.turnerdesigns.com/cyclops-7f-submersible-fluorometer). They are supported by the ModularSensors library and there’s more information about them here: https://envirodiy.github.io/ModularSensors/group__sensor__cyclops.html
2024-10-29 at 3:17 PM #18711
nick
Participant
Hi Shannon,

I ordered a C-FLOUR not realizing that the modular sensor library only has compatibility with the Cyclops-7F, even though you mentioned the Cyclops in your earlier post.

Based on what a rep has told me, Turner is starting to phase out their Cyclops-7F sensors and replacing them with the C-FLUOR sensors, since parts are getting harder to source. They said the C-FLUOR units are backwards compatible since the hardware is very similar. https://docs.turnerdesigns.com/t2/doc/comparison-guides/S-0245.pdf Based on that PDF it looks like C-FLOUR is more accurate (for Phycocyanin), faster, and calibrated.

Is there any chance the C-FLOUR can be added to the library? And possibly add an example code too?

Thank you!
- 2024-10-29 at 3:50 PM #18712
  Shannon Hicks
  Moderator
  The two sensor models perform exactly the same. We’ve used a couple in the field with existing loggers when replacing some old broken Cyclops 7f sensors. All we did was swap the sensors and redo the calibration and edit the appropriate 2 lines in the code for the voltage measured in the standard and the blank (nanopure water). The C-FLUOR sensors do come with a calibration voltage on a datasheet in the package, but we prefer to do our own, plus we recalibrate them in the field periodically once deployed. We use a rhodamine standard we purchased from Turner. So you can just use the existing ModularSensors Turner Cyclops library. Keep in mind that the sensors output a 0-5v analog signal, so you’ll need to use a resistor-divider to read them properly with a Mayfly logger. Our new multipurpose screw terminal board has that option if you add your own resistors and change the solder jumpers on the back of the board.
2024-11-05 at 8:52 AM #18719
nick
Participant
Shannon,

I attached a picture of how I am connecting the C-FLOUR to the multipurpose screw terminal board. Can you let me know if this is the correct wiring and resistor amount, type, and location?

Thank you.
Attachments:
1. CFLOUR-to-MP-Screw-terminal.png

2024-11-05 at 3:40 PM #18725

Moderator

That all looks correct. I usually put the Mayfly’s analog Grove jack voltage selector jumper to the 5v position because the old sensors required 5v for excitation, but supposedly these newer ones are happy with 3v to 15v, but we still use them at 5v and calibrate them with that excitation voltage. If you connect the 6-pin screw terminal board shown in your photo to the Mayfly’s upper aux analog jack (AA0-AA1), then your sensor will be connected to the A0 pin, so make sure that’s what you’ve entered on the line of your sketch that looks like this:

const int8_t cyclopsChloroADSChannel = 0; // ADS channel

We’ve only used the C-FLUOR sensors for phycocyanin but I would assume their operation and performance would be the same for the chlorophyll model. Which one are you using? The ModularSensors library for the Cyclops sensors assumes you’ll be entering the two voltages of the sensor output (blanking voltage and standard concentration voltage), and the concentration of the standard. So for my station, it looks like this:

// Cyclops calibration information
const float cyclopsChloroStdConc = 40.000; // Concentration of the standard used
                                          // for a 1-point sensor calibration.

const float cyclopsChloroStdVolt = 1.155488; // The voltage (in volts) measured for the conc_std.
const float cyclopsChloroBlankVolt = 0.020348; // The voltage (in volts) measured for a blank.

// Cyclops calibration information

const float cyclopsChloroStdConc = 40.000; // Concentration of the standard used

// for a 1-point sensor calibration.

const float cyclopsChloroStdVolt = 1.155488; // The voltage (in volts) measured for the conc_std.

const float cyclopsChloroBlankVolt = 0.020348; // The voltage (in volts) measured for a blank.

These voltages were obtained by placing the sensor (with power applied) in nanopure water (or distilled if that’s all you’ve got) in a large dark contained (a black opaque 1-liter bottle) and measuring the output voltage of the sensor. Then we repeat it with 1 liter of the standard (the Rhodamine standard purchased from Turner). If you’re measuring the voltage with an external voltmeter, remember that you’ll need to divide the voltmeter voltage by 2 because you’ve got that resistor-divider circuit on your screw terminal board. So if you put the sensor in the standard and get 2.2 volts, you would then enter 1.1 volts into the sketch. Same thing for the blanking voltage (although it’s usually a really small number closer to zero.) We usually measure the voltage out to 5 decimal places using the Mayfly to measure the analog voltage 100 times (20 milliseconds apart) and take an average, then do that at least 50 more times, and take an average of all those measurements.

If you’ll be entering the data from the sensor’s calibration sheet instead, you’ll need to enter blanking voltage from the sheet (again, dividing by 2 because of the res-div). So let’s pretend the datasheet says the blanking offset is 0.02 volts, so divide that by 2 and get 0.01. And then the sheet gives you the calibration coefficient as ppb per volt (parts per billion per volt). So pretend a sensor’s datasheet said 1035.4234 ppb/v. So you could enter that number in the concentration line and 0.5v for the voltage (because that’s half of one volt), like this:

const float cyclopsPhycoStdConc = 1035.4234; // Concentration of the standard used
                                         // for a 1-point sensor calibration.
const float cyclopsPhycoStdVolt =    0.5; // The voltage (in volts) measured for the conc_std.
const float cyclopsPhycoBlankVolt =    0.01; // The voltage (in volts) measured for a blank.

const float cyclopsPhycoStdConc = 1035.4234; // Concentration of the standard used

// for a 1-point sensor calibration.

const float cyclopsPhycoStdVolt = 0.5; // The voltage (in volts) measured for the conc_std.

const float cyclopsPhycoBlankVolt = 0.01; // The voltage (in volts) measured for a blank.

2024-11-08 at 6:26 PM #18732

nick

Participant

Shannon,

Thank you for the confirmation and write up for the sketch setup. I just have the phycocyanin C-FLUOR. This is my first time soldering, so I’m practicing on another board before I commit on the MP screw terminal board.

Have you notice big differences between the calibration sheet versus your manual calibration? And for the manual calibration on the mayfly, is there a specific sketch you use to get the voltages?

2024-11-11 at 4:56 PM #18737

Shannon Hicks

Moderator

The calibration sheet from Turner was very accurate for the new sensor, so if you don’t want to buy expensive rhodamine standard right now, you’re probably fine to use the data from the sheet. But we’ve found that the sensors tend to drift over time so we do quarterly recalibrations of the sensors to make sure they’re still accurate.

Here’s a simple sketch to take 100 analog readings quickly and average them, then constantly repeat that, and printing all data to the serial port. Then I just copy/paste the text from the serial port into Excel so I can do an analysis and overall average.

//Takes lots of readings from the EnviroDIY Mayfly's ADS1115 Aux Analog ADC and averages them, prints to screen

#include <SPI.h>           
#include <Wire.h>           
#include <Adafruit_ADS1015.h>

Adafruit_ADS1115 ads;     // The Mayfly's ADS1115 Aux ADC is 16-bit version

float average_volts;   //variable to hold the calculated average
int State8 = LOW;
int State9 = LOW;

int aux_channel = 0;  //channel number of whatever pin you've got your input connected to for the ADS1115 Aux Analog chip (AA0 = 0, AA1 = 1, AA2 = 2, AA3 = 3) 
int readcount = 100;  //the number of readings you want to take for each sample
int time_between_readings = 10;  //number of milliseconds between each reading in a sample

void setup()
{
  Serial.begin(57600);  //Start the serial connection with the computer
  ads.begin();       //begin adafruit ADS1015

  pinMode(8, OUTPUT);    // define the red and green LEDs as outputs
  pinMode(9, OUTPUT);    
  digitalWrite(8, HIGH);   //turn on one of the LEDs to start with 
  digitalWrite(9, LOW);  
  pinMode(22, OUTPUT);     //switched power pin declared as output
  digitalWrite(22, HIGH);  //turn on the Switched sensor voltage  
      
  Serial.println("EnviroDIY Mayfly Aux-Analog Averaging Sketch ");
  Serial.print("Aux ADC Channel: ");
  Serial.print(aux_channel); Serial.print("(AA"); Serial.print(aux_channel);
  Serial.print(")   Number of readings per sample: ");
  Serial.println(readcount);
  Serial.println("-------------------------------------------------------------");  
  delay(2000);  //wait 2 seconds
   
}
 
void loop()                   
{
     auxanalog_sample();     //go take a measurement with the ADS1115

    //blink the red and green LEDs in alternating fashion on each loop
    if (State8 == LOW) {
      State8 = HIGH;
    } else {
      State8 = LOW;
    }
    digitalWrite(8, State8);    
    State9 = !State8;
    digitalWrite(9, State9);
   
   // Serial.print("Averaged analog voltage (volts):  ");  //print the results to the serial monitor
    Serial.println(average_volts,5);  
 
    delay(100);  //wait a little bit between loops, adjust as you want

}   //end loop


void auxanalog_sample()     // function that takes reading from ADS1115 Aux Analog chip on Mayfly
{ 
 int16_t adc_bits = 0;       //int to hold the value of the bits that get read
 float bit_sum = 0.0;        //sum of all the bits read
 
  for (int i = 0; i < readcount; i++){
    adc_bits = ads.readADC_SingleEnded(aux_channel);   //take a single-ended reading with the ADS1115
    bit_sum += adc_bits;    //add the latest reading to the sum 
    delay(time_between_readings);   //wait x milliseconds between readings, adjust as you want
  }

  float average_bits = bit_sum / readcount;  //find the average by dividing the bit_sum by readcount
  //now convert bits into volts
  //average_volts = (average_bits * 3.3)/17585.0;   
  // use this next line instead of the previous line if you're using a voltage divider to reduce an external sensor's voltage
   average_volts = ((average_bits * 3.3)/17585.0) * 2.0;  //multiply by 2 if you used a 50/50 divider
  
}

//Takes lots of readings from the EnviroDIY Mayfly's ADS1115 Aux Analog ADC and averages them, prints to screen

#include <SPI.h>

#include <Wire.h>

#include <Adafruit_ADS1015.h>

Adafruit_ADS1115 ads; // The Mayfly's ADS1115 Aux ADC is 16-bit version

float average_volts; //variable to hold the calculated average

int State8 = LOW;

int State9 = LOW;

int aux_channel = 0; //channel number of whatever pin you've got your input connected to for the ADS1115 Aux Analog chip (AA0 = 0, AA1 = 1, AA2 = 2, AA3 = 3)

int readcount = 100; //the number of readings you want to take for each sample

int time_between_readings = 10; //number of milliseconds between each reading in a sample

void setup()

{

Serial.begin(57600); //Start the serial connection with the computer

ads.begin(); //begin adafruit ADS1015

pinMode(8, OUTPUT); // define the red and green LEDs as outputs

pinMode(9, OUTPUT);

digitalWrite(8, HIGH); //turn on one of the LEDs to start with

digitalWrite(9, LOW);

pinMode(22, OUTPUT); //switched power pin declared as output

digitalWrite(22, HIGH); //turn on the Switched sensor voltage

Serial.println("EnviroDIY Mayfly Aux-Analog Averaging Sketch ");

Serial.print("Aux ADC Channel: ");

Serial.print(aux_channel); Serial.print("(AA"); Serial.print(aux_channel);

Serial.print(") Number of readings per sample: ");

Serial.println(readcount);

Serial.println("-------------------------------------------------------------");

delay(2000); //wait 2 seconds

}

void loop()

{

auxanalog_sample(); //go take a measurement with the ADS1115

//blink the red and green LEDs in alternating fashion on each loop

if (State8 == LOW) {

State8 = HIGH;

} else {

State8 = LOW;

}

digitalWrite(8, State8);

State9 = !State8;

digitalWrite(9, State9);

// Serial.print("Averaged analog voltage (volts): "); //print the results to the serial monitor

Serial.println(average_volts,5);

delay(100); //wait a little bit between loops, adjust as you want

} //end loop

void auxanalog_sample() // function that takes reading from ADS1115 Aux Analog chip on Mayfly

{

int16_t adc_bits = 0; //int to hold the value of the bits that get read

float bit_sum = 0.0; //sum of all the bits read

for (int i = 0; i < readcount; i++){

adc_bits = ads.readADC_SingleEnded(aux_channel); //take a single-ended reading with the ADS1115

bit_sum += adc_bits; //add the latest reading to the sum

delay(time_between_readings); //wait x milliseconds between readings, adjust as you want

}

float average_bits = bit_sum / readcount; //find the average by dividing the bit_sum by readcount

//now convert bits into volts

//average_volts = (average_bits * 3.3)/17585.0;

// use this next line instead of the previous line if you're using a voltage divider to reduce an external sensor's voltage

average_volts = ((average_bits * 3.3)/17585.0) * 2.0; //multiply by 2 if you used a 50/50 divider

}

Author

Posts

Viewing 6 reply threads

You must be logged in to reply to this topic.

Attachments: