De Programmeerbare Plantenkas: Een Anyleaf pH Sensor Module Aansluiten, Kalibreren En Programmeren Om De pH Te Bepalen

De Programmeerbare Plantenkas: Een Anyleaf pH Sensor Module Aansluiten, Kalibreren En Programmeren Om De pH Te Bepalen

In deze tutorial laten we zien hoe je een AnyLeaf module, voor het uitlezen van een pH, ORP of ion selective sensor, kunt aansluiten, kalibreren en programmeren om met een Arduino microcontroller of vergelijkbare microcontroller de pH waarde van een vloeistof kunt bepalen. De AnyLeaf module is op dit moment niet in Europa te koop, maar kan via de makers in de Verenigde Staten naar Nederland of België gestuurd worden. In dit voorbeeld gebruiken we een "budget" E201 pH sensor van het merk Bante.

Aansluiten

Het aansluiten van de AnyLeaf module is zeer eenvoudig. Eerst draai je de BNC aansluiting van de pH sensor vast aan de module. Daarna gebruik je vrouwelijke dupont stekkers om de aarde (GND), spanning (VCC), en I2C (SDA en SCL) op de microcontroller aan te sluiten. Daarnaast sluiten wij ook nog een DS18B20 temperatuursensor aan op de microcontroller, omdat we in dit voorbeeld de gemeten pH waarde corrigeren voor de temperatuur van de omgeving. Voor de kalibratie fase gebruiken we ook nog een Grove dual button module.

anyleaf, ph sensor
anyleaf, ph sensor

kalibratie programmeren

Het programma dat we gebruiken om de AnyLeaf module te kalibreren is vrijwel identiek aan het programma dat we gebruiken om de Grove pH module te programmeren. Daarom leggen we dit niet nogmaals uit op deze pagina. Op de pagina "De Programmeerbare Plantenkas: Een Grove pH Sensor Module Aansluiten, Kalibreren En Programmeren Om De pH Te Bepalen" kun je uitgebreid lezen hoe het kalibreren in zijn werk gaat. Het enige verschil is de manier waarop het signaal uit de module wordt gehaald. Hoe dit precies werkt bespreken we hier onder, onder het kopje "pH metingen programmeren".

ARDUINO IDE CODE - KALIBRATIE PH SENSOR


/*
   Voorbeeld code gemaakt door www.foodplanting.com
   voor de Programmeerbare Plantenkas serie.

   Deze code is gemaakt voor de kalibratie van een pH sensor,
   aangesloten op een AnyLeaf pH, ORP of ionselectieve
   sensor module en een DS18B20 temperatuursensor.

   Deze code maakt gebruikt van de DallasTemperature bibliotheek
   van SparkFun.
   Meer info over deze bibliotheek vindt je hier:
   https://github.com/milesburton/Arduino-Temperature-Control-Library
   Ook maakt deze code gebruik van de OneWire bibliotheek.
   Meer info over deze bibliotheek vindt je hier:
   https://github.com/PaulStoffregen/OneWire
   Als laatste maakt deze code gebruik van de Adafruit_ADS1X15 bibiliotheek.
   Meer info over deze bibliotheek vindt je hier:
   https://github.com/adafruit/Adafruit_ADS1X15
*/

// Voorbereiding:
#include <OneWire.h> // Dit laadt de bibliotheek die nodig is om met de temperatuursensor te communiceren
#include <DallasTemperature.h> // Dit laadt de bibliotheek die nodig is om de temperatuursensor te lezen.
#define ONE_WIRE_BUS 4 // Dit geeft aan op welke digitale input de sensor is aangesloten, in dit geval D4.
OneWire oneWire(ONE_WIRE_BUS); // Vertel de bibliotheek op welke input de sensor aangesloten is.
DallasTemperature ds18b20(&oneWire); // Dit geeft aan hoe we de sensor noemen in de code en laat de OneWire en DallasTemperature bibliotheek met elkaar communiceren.
float DS18B20gradenC; // Dit creëert een globale variabele waarin de gemeten temperatuur wordt opgeslagen.
#include <Adafruit_ADS1X15.h> // Dit laadt de bibliotheek die nodig is om met de pH module te communiceren.
Adafruit_ADS1015 pHsensor; // Dit geeft aan hoe we de pH module noemen.
float constante = 0.015625F; // Constante om input van pH module om te zetten in milliovolt signaal.
#define pHsensorNrSamples 200 // Het aantal metingen dat gebruikt wordt om een pH te bepalen, hoe meer hoe exacter en langzamer.
uint8_t pHsensori; // Een variabele om in bij te houden hoeveel metingen er genomen zijn.
int pHsensorMetingen[pHsensorNrSamples]; // Variabele om de individuele metingen in op te slaan.
float pHsensorGemiddelde; // Een variabele om het gemiddelde van de metingen tijdelijk in op te slaan.
float helling = 0; // Een variabele waarin de waarde van de helling in opgeslagen wordt.
float asafsnede = 0; // Een variabele waarin de waarde van de asafsnede in opgeslagen wordt.
float kalTemp = 0; // Een variabele waarin de kalibratietemperatuur opgeslagen wordt.
float pHsensorVoltKal1 = 0; // Een variabele waarin het gemiddelde aanatal volt voor kalibratievloeistof 1 in opgeslagen wordt.
float pHsensorVoltKal2 = 0; // Een variabele waarin het gemiddelde aanatal volt voor kalibratievloeistof 2 in opgeslagen wordt.
#define knop1 2 // Dit geeft aan op welke digitale input de eerste knop is aangesloten, in dit geval D2.
#define knop2 3 // Dit geeft aan op welke digitale input de tweede knop is aangesloten, in dit geval D3.
#define kalpH1 4.0 // Dit geeft aan wat de pH waarde van de eerste kalibratievloeistof is.
#define kalpH2 10.0 // Dit geeft aan wat de pH waarde van de tweede kalibratievloeistof is.
bool kal1check = LOW; // Een variabele om bij te houden of de eerste kalibratie is voltooid.
bool kal2check = LOW; // Een variabele om bij te houden of de tweede kalibratie is voltooid.
bool kalibratie1 = LOW; // Een variable om aan te geven dat de eerste kalibratie moet beginnen.
bool kalibratie2 = LOW; // Een variable om aan te geven dat de tweede kalibratie moet beginnen.
bool resetten = LOW; // Een variable die aan geeft het programma te resetten als de berekeningen zijn uit gevoerd.
volatile byte bepaling1 = LOW; // Een variabele die na een druk op knop 1 aan gaat en de eerste kalibratie meting start.
volatile byte bepaling2 = LOW; // Een variabele die na een druk op knop 2 aan gaat en de tweede kalibratie meting start.
#define wacht 2000 // Tijd om de pH sensor te laten stabilizeren.

void setup() {
  Serial.begin(9600); // Zet de Serial Monitor aan.
  pinMode(knop1, INPUT_PULLUP); // Geef aan dat knop1 een input is.
  pinMode(knop2, INPUT_PULLUP); // Geef aan dat knop2 een input is.
  ds18b20.begin(); // Zet de communicatie tussen de microcontroller en de sensor aan.
  pHsensor.setGain(GAIN_EIGHT); // Gebruik de GAIN_TWO setting om de input van de pH module om te zetten in een millivolt signaal.
  pHsensor.begin(); // Zet de comminicatie tussen de microcontroller en de pH module.
  attachInterrupt(digitalPinToInterrupt(knop1), drukKnop1, CHANGE); // Zorgt ervoor dat de functie "drukKnop1" aan gaat als er op knop1 gedrukt wordt.
  attachInterrupt(digitalPinToInterrupt(knop2), drukKnop2, CHANGE); // Zorgt ervoor dat de functie "drukKnop2" aan gaat als er op knop2 gedrukt wordt.
  delay(500); // Korte delay om print fout te voorkomen.
  Serial.println("--------------------------");
  Serial.println("Spoel de pH sensor eerst af met gedistilleerd water en dep de sensor droog.");
  Serial.println("Plaats de pH meter in kalibratie vloeistof 1 en druk op de blauwe knop.");
  Serial.println("--------------------------");
}

// Loop fase:
void loop() {

  // Als knop1 ingedrukt is, dan worden er metingen verzameld voor kalibratievloeistof 1:
  if (bepaling1 == HIGH) {
    Serial.println("De eerste fase van de kalibratie met kalibratievloeistof 1 is begonnen.");
    kalibratie1 = HIGH;
    pHSensorKalMetingen();
    bepaling1 = LOW;
  }

  // Als knop2 ingedrukt is, dan worden er metingen verzameld voor kalibratievloeistof 2:
  if (bepaling2 == HIGH) {
    Serial.println("De eerste fase van de kalibratie met kalibratievloeistof 2 is begonnen.");
    kalibratie2 = HIGH;
    pHSensorKalMetingen();
    bepaling2 = LOW;
  }

  // Als er voor kalibratievloeistof 1 en 2 metingen zijn verzameld, dan wordt de helling en asafsnede bepaald:
  if (kal1check == HIGH && kal2check == HIGH) {
    pHSensorKalBepalingen();
    resetten = HIGH;
  }

  // Als de berekening van de helling en asafsnede voltooiod is, dan wordt het programma klaar gemaakt voor een nieuwe kalibratie:
  if (resetten == HIGH) {
    bepaling1 = LOW;
    bepaling2 = LOW;
    helling = 0;
    asafsnede = 0;
    kalTemp = 0;
    pHsensorVoltKal1 = 0;
    pHsensorVoltKal2 = 0;
    resetten = LOW;
  }
}

// Functie die ervoor zorgt dat de kalibratie van kalibratievloeistof 1 begint als knop1 ingedrukt wordt:
void drukKnop1() {
  bepaling1 = HIGH;
}

// Functie die ervoor zorgt dat de kalibratie van kalibratievloeistof 2 begint als knop2 ingedrukt wordt:
void drukKnop2() {
  bepaling2 = HIGH;
}

// Functie voor pH sensor met temperatuur correctie:
void pHSensorKalMetingen() {

  Serial.println("Stabilistatie fase gestart.");
  delay(wacht); // Tijd om de pH sensor te stabiliseren, meestal 5 minuten (300000ms).
  Serial.println("Metingen worden uitgevoerd.");

  // Meet de temperatuur van de kalibratie vloeistof:
  kalTemp = GROVEDS18B20(); // Haal de temperatuur van de kalibratie vloeistof op.

  // Neem het aantal samples dat bij pHsensorNrSamples is aangegeven per pH meting:
  for (pHsensori = 0; pHsensori < pHsensorNrSamples; pHsensori++) {
    pHsensorMetingen[pHsensori] = (pHsensor.readADC_Differential_0_1() * constante); // Verzamel het aantal metingen dat bij pHsensorNrSamples aangegeven is.
    delay(2); // Hou 2 miliseconden tussen metingen.
  }

  // Tel de metingen uit de analoge pin op in variabele pHsensorGemiddelde:
  pHsensorGemiddelde = 0; // Reset de pHsensorGemiddelde variabele.
  for (pHsensori = 0; pHsensori < pHsensorNrSamples; pHsensori++) {
    pHsensorGemiddelde += pHsensorMetingen[pHsensori]; // Tel de metingen bij elkaar op.
  }
  pHsensorGemiddelde /= pHsensorNrSamples; // Deel het opgeteld aantal metingen door het aantal metingen om het gemiddelde te krijgen.

  // Sla de gegevens voor kalibratievloeistof 1 op als knop1 is gebruikt:
  if (kalibratie1 == HIGH && kalibratie2 == LOW) {
    kalibratie1 = LOW;
    Serial.println("--------------------------");
    pHsensorVoltKal1 = pHsensorGemiddelde;
    Serial.print("De gemiddelde sensor meting in kalibratievloeistof 1 is: ");
    Serial.print(pHsensorVoltKal1);
    Serial.println(" volt.");
    Serial.println("--------------------------");
    Serial.println("Spoel de pH sensor opnieuw af met gedistilleerd water en dep de sensor droog.");
    Serial.println("Plaats de pH meter in kalibratie vloeistof 2 en druk op de witte knop.");
    Serial.println("--------------------------");
    kal1check = HIGH;
  }

  // Sla de gegevens voor kalibratievloeistof 2 op als knop2 is gebruikt:
  else if (kalibratie2 == HIGH && kalibratie1 == LOW) {
    kalibratie2 = LOW;
    Serial.println("--------------------------");
    pHsensorVoltKal2 = pHsensorGemiddelde;
    Serial.print("De gemiddelde sensor meting in kalibratievloeistof 2 is: ");
    Serial.print(pHsensorVoltKal2);
    Serial.println(" volt.");
    Serial.println("--------------------------");
    kal2check = HIGH;
  }
}

//Functie voor temperatuursensor:
float GROVEDS18B20() {
  ds18b20.requestTemperatures(); // Dit activeert de bibliotheek om de temperatuur uit de sensor te halen.
  DS18B20gradenC = ds18b20.getTempCByIndex(0); // Dit slaat de temperatuur op in de globale variabele.
  return DS18B20gradenC;
}

// Functie voor berekenen helling en asafsmede:
void pHSensorKalBepalingen() {
  Serial.println("");
  Serial.println("");
  Serial.println("|---KALIBRATIE UITSLAG---|");
  helling = (kalpH1 - kalpH2) / (pHsensorVoltKal1 - pHsensorVoltKal2); // Bereken de helling.
  Serial.print("Het richtingscoëfficiënt voor deze pH sensor is: ");
  Serial.println(helling);
  asafsnede = ((kalpH1 + kalpH2) - helling * (pHsensorVoltKal1 + pHsensorVoltKal2)) / 2; // Bereken de asafsnede.
  Serial.print("De asafsenede voor deze pH sensor is: ");
  Serial.println(asafsnede);
  Serial.print("De kalibratietempeatuur voor deze sensor is: ");
  Serial.print(kalTemp);
  Serial.println(" graden Celsius");
  Serial.println("|---KALIBRATIE UITSLAG---|");
  Serial.println("");
  Serial.println("");
  kal1check = LOW;
  kal2check = LOW;
}

PH METINGEN PROGRAMMEREN

Wanneer je in de Arduino IDE zoekt naar AnyLeaf zul je zien dat zij een eigen bibliotheek hebben. Helaas lijkt deze bibliotheek wat verouderd, waardoor wij hem niet aan de praat kregen. Daarom hebben we besloten om zelf een voorbeeld code te maken om de AnyLeaf module, waar een pH sensor op aan gesloten is, te gebruiken om de pH van een vloeistof te bepalen.

Het belangrijkste component van de AnyLeaf module is de ADS1115 analoog-naar-digitaal omzetter. Deze omzetter kan het zwakke signaal van de pH sensor versterken en vervolgens via een I2C verbinding doorgeven aan de microcontroller. Om dit voor elkaar te krijgen, gebruiken we drie bibliotheken. Als eerste gebruiken we de DallasTemperature bibliotheek en de One Wire bibliotheek, omdat we voor een optimaal resultaat de pH waarde corrigeren voor de omgevingstemperatuur met de DS18B20 temperatuur sensor. Hoe deze sensor aangesloten en geprogrammeerd moet worden, kun je in het artikel "De Programmeerbare Plantenkas: De DS18B20 temperatuursensor aansluiten en programmeren om de temperatuur te meten" lezen. Om te veel herhaling te voorkomen gaan we daar op deze pagina dan ook niet verder op in. Verder gebruiken we de Adafruit_ADS1X15 bibliotheek, die speciaal voor de ADS1115 analoog-naar-digitaal omzetter gemaakt is.

In de voorbereidingsfase zijn er een aantal punten om op te letten. Allereerst is het belangrijk om aan te geven wat het exacte type nummer is van de omzetter die we gaan gebruiken. In het geval van de AnyLeaf module gebruiken we de ADS1115, daarom geven we in de voorbereiding het commando Adafruit_ADS1115 pHsensor;. Dit verteld de bibliotheek dat we met type ADS1115 werken en dat we deze sensor in dit programma "pHsensor" noemen.

Verder zijn er nog een aantal gegevens die je moet aanpassen op basis van de uitslag van de kalibratie van de pH sensor. Allereerst kun je de gegevens over de helling aanpassen. De helling geeft aan hoeveel millivolt het signaal omhoog of omlaag gaat als de pH van de oplossing 1,0 pH hoger of lager is. Bij een "perfecte" pH sensor zou er ongeveer 59 millivolt bij komen als de pH waarde met één punt omhoog of omlaag gaat. Aangezien de meeste pH sensoren niet perfect zijn, is het belangrijk om de kalibratie regelmatig uit te voeren, zodat je weet wat de helling van jouw specifieke pH sensor is. Het kalibratieprogramma hierboven vertelt je wat de helling van jouw pH sensor is. Om ervoor te zorgen dat de microcontroller de pH aan de hand van de juiste helling berekend, wijzig je het nummer "59" in het commando #define helling 59 naar de helling die bij jouw sensor hoort volgens de kalibratie.  

Vervolgens is het de beurt aan de asafsnede. De asafsnede is het punt waarop de pH sensor 0 millivolt naar de module stuurt. Bij een perfecte pH sensor ligt dit punt bij een pH waarde van 7,0 pH, maar zoals altijd bij sensoren ligt dit punt in de praktijk vaak iets hoger of lager. Het kalibratieprogramma zal ook aangeven wat de asafsnede van jouw specifieke pH sensor is. Dit getal zet je vervolgens in de plaats van de "7" in het commando #define asafsnede 7

Als laatste kun je nog de kalibratie temperatuur in voeren in het programma, mits je de kalibratie gedaan hebt met behulp van een temperatuursensor. Om de kalibratie temperatuur aan te passen wijzig je de "24" in het commando #define kalTemp 24 naar de juiste temperatuur. 

In de setup fase van het programma wordt eerst aangegeven welke versterking er nodig is voor het signaal van de pH sensor. Deze versterking wordt in de AnyLeaf module uitgevoerd, en dus niet in het programma van de microcontroller. Het signaal van de meeste pH sensoren loopt tussen de -300 millivolt en +300 millivolt, zeker wanneer je geen extreme vloeistoffen gaat testen. Dit pas goed bij de GAIN_EIGHT instelling van de module. Deze instelling is namelijk bedoeld voor sensoren die een spanning tussen de -512 millivolt en +512 millivolt produceren. Het signaal van de pH sensor wordt dan zo versterkt dat elke bit 0.015625 millivolt waard is. Met het commando pHsensor.setGain(GAIN_EIGHT); vertellen we de module welke versterking we willen gebruiken. Vervolgens geven we ook nog het commando pHsensor.begin(); om de communicatie tussen de AnyLeaf module en de microcontroller aan te zetten. 

Om er voor te zorgen dat de code voor de AnyLeaf module makkelijk gebruikt kan worden met andere stukjes code hebben we er voor gekozen om een aparte functie te maken die de pH waarde berekend op basis van het aantal millivolt dat de pH sensor genereert. Deze functie beginnen we door het commando float pHSensor() {} te geven. 

Het eerste wat er gebeurt als de functie voor het verkrijgen van een pH meting wordt geactiveerd, is het activeren van een wachttijd met het commando delay(wacht);. De meeste pH sensoren hebben even de tijd nodig om te reageren op de hoeveelheid waterstofionen in de testvloeistof. Daarom hebben wij een wachttijd van 300000 milliseconden, ofwel 5 minuten ingesteld. Wanneer je de pH sensor constant in een vloeistof hebt zitten, bijvoorbeeld in een hydroponisch systeem, dan is deze wachttijd niet nodig en kun je dit weg laten. Ook kan het zijn dat je een hele goede pH sensor hebt die heel snel reageert op het aantal waterstofionen in de vloeistof. In dat geval kun je de tijd aanpassen in de voorbereidingsfase in het commando #define wacht 300000.  

Na de wachttijd gaat het programma metingen verzamelen. Om een goed beeld te krijgen van de pH waarde van de vloeistof die je aan het testen bent, kiezen we ervoor om niet één meting maar 200 metingen te nemen om de pH waarde te bepalen. Een gemiddelde meting van een groot aantal metingen geeft over het algemeen namelijk een beter beeld dan een enkele meting. Om de 200 metingen te verzamelen gebruiken we de volgende commando's: Allereerst geven we het commando for (pHsensori = 0; pHsensori < pHsensorNrSamples; pHsensori++) {. Dit commando bevat de variabele "pHsensori" die bijhoudt hoeveel metingen we al genomen hebben. Als het tellen begint, wordt de variable eerst op 0 gezet, met stukje pHsensori = 0;. Vervolgens zegt het commando zolang pHsensori een waarde van minder dan de variable "pHsensorNrSamples" heeft, dan voeren we het onderstaande uit. De variabele pHsensorNrSamples staat in dit voorbeeld op 200, maar als je een ander aantal samples wilt verzamelen dan kun je in de voorbereidingsfase het commando #define pHsensorNrSamples 200 veranderen in het aantal dat je graag wilt hebben. Het laatste stukje van dit programma, pHsensori++ zegt dat er elke keer 1 bijgeteld wordt bij pHsensori. 

Zolang pHsensori een waarde onder de 200 heeft, dan wordt het commando pHsensorMetingen[pHsensori] = pHsensor.readADC_Differential_0_1(); uitgevoerd. Dit command obestaat uit twee delen. Allereerst is er het deel pHsensorMetingen[pHsensori] =. Dit zegt dat er een lijst is die pHsensorMetingen heet en pHsensori lang is, en dus in dit voorbeeld 200 rijen heeft. Elke rij krijgt de waarde die uit de AnyLeaf module komt. Om de waarde van de pH sensor uit de AnyLeaf module te halen, wordt het commando pHsensor.readADC_Differential_0_1(); gegeven. Dit is een commando die uit de Adafruit_ADS1X15 bibliotheek komt. In het kort bekijkt dit stukje code wat het verschil is tussen de interne elektrode van de pH sensor en de referentie elektrode. Volgens de beschrijving van AnyLeaf zit de BNC connector van de module aangesloten op de A0 en A1 kanalen van de ADS1115 omzetter. Vandaar dat we readADC_Differential_0_1 gebruiken, omdat dit commando speciaal is gemaakt voor sensoren die op de A0 en A1 kanalen zijn aangesloten.

Zodra er 200 metingen zijn verzameld, dan worden de metingen bij elkaar opgeteld. Hiervoor gebruiken we een zelfde structuur als voor het verzamelen van de metingen. Het enige verschil is dat we zolang pHsensori een waarde van minder dan 200 heeft de metingen in de lijst optellen. Dit doen we met het commando pHsensorGemiddelde += ( pHsensorMetingen[pHsensori] * constante);. Zoals je kunt zien worden de metingen in de lijst eerst nog met een constante vermenigvuldigd voordat het wordt opgeteld. Deze constante is het aantal millivolt dat één bit waard is. Zoals eerder verteld is bij de instelling GAIN_EIGHT elke bit 0.015625 millivolt waard. Vandaar dat de variabele "constante" in de voorbereidingsfase de waarde 0.015625 heeft gekregen, met het commando float constante = 0.015625F;.  Als de 200 metingen eenmaal zijn opgeteld, dan wordt dit aantal nog door 200 gedeeld om het gemiddeld aantal millivolt te krijgen. Hiervoor gebruiken we het commando pHsensorGemiddelde /= pHsensorNrSamples;

Om de pH waarde te berekenen wordt er eerst aan de functie die bij de temperatuursensor hoort gevraagd om de temperatuur te bepalen. Vervolgens wordt de helling gecorrigeerd voor de temperatuur die de huidige te testen vloeistof heeft. Dit wordt gedaan met het commando hellingTemp = helling * (DS18B20gradenC + 273.15) / (kalTemp + 273.15);. De helling, die tijdens de kalibratie is bepaald, wordt eerst vermenigvuldig met de huidige temperatuur waarbij 273,15 is opgeteld. Dit wordt daarna gedeeld door de kalibratie temperatuur waarbij ook 273,15 is opgeteld.

Als laatste kan eindelijk de pH waarde van de test vloeistof bepaald worden. Dit wordt gedaan met het commando pHsensorPHTemp = asafsnede - (pHsensorGemiddelde/hellingTemp);. Hierbij wordt dus het gemiddeld aantal millivolt dat over 200 metingen uit de pH sensor gekomen is gedeeld door de voor temperatuur gecorrigeerde helling. Dit getal wordt afgetrokken van de asafsnede, die meestal rond de 7 ligt. Zoals je misschien nog weet van de wiskundeles is een negatief getal aftrekken hetzelfde als plus. Hierdoor krijg je een pH waarde onder de asafsnede als er een positief aantal millivolt gemeten is, in het geval van een zure oplossing, en een pH waarde die boven de asafsnede ligt als er een negatief aantal millivolt gemeten is, in het geval van een basische oplossing.

Op dit moment wordt er nog niets met de gemeten pH waarde gedaan, zodat de code makkelijk te combineren is met andere stukjes code. Er zijn natuurlijk tal van uitbreidingen denkbaar, zoals het weergeven van de pH waarde op een display of het toevoegen van een vloeistof die de pH waarde verhoogd of verlaagd als de pH onder of boven een bepaald punt komt.

ARDUINO IDE CODE - PH METINGEN


/*
   Voorbeeld code gemaakt door www.foodplanting.com
   voor de Programmeerbare Plantenkas serie.

   Deze code is gemaakt voor de kalibratie van een pH sensor,
   aangesloten op een AnyLeaf pH, ORP of ionselectieve
   sensor module en een DS18B20 temperatuursensor.

   Deze code maakt gebruikt van de DallasTemperature bibliotheek
   van SparkFun.
   Meer info over deze bibliotheek vindt je hier:
   https://github.com/milesburton/Arduino-Temperature-Control-Library
   Ook maakt deze code gebruik van de OneWire bibliotheek.
   Meer info over deze bibliotheek vindt je hier:
   https://github.com/PaulStoffregen/OneWire
   Als laatste maakt deze code gebruik van de Adafruit_ADS1X15 bibiliotheek.
   Meer info over deze bibliotheek vindt je hier:
   https://github.com/adafruit/Adafruit_ADS1X15

   Deze code is zeer minimalistisch, omdat het idee is
   dat deze code gecombineerd wordt met codes voor andere
   modules. Zo wordt de pH en de temperatuur bijvoorbeeld niet in de
   loop fase, maar in een aparte functie op geroepen en
   wordt de gemeten pH en temperatuur niet in de Serial Monitor
   af geprint.
*/

// Voorbereiding:
#include <OneWire.h> // Dit laadt de bibliotheek die nodig is om met de temperatuursensor te communiceren.
#include <DallasTemperature.h> // Dit laadt de bibliotheek die nodig is om de temperatuursensor te lezen.
#define ONE_WIRE_BUS 4 // Dit geeft aan op welke digitale input de sensor is aangesloten, in dit geval D4.
OneWire oneWire(ONE_WIRE_BUS); // Vertel de bibliotheek op welke input de sensor aangesloten is.
DallasTemperature ds18b20(&oneWire); // Dit geeft aan hoe we de sensor noemen in de code en laat de OneWire en DallasTemperature bibliotheek met elkaar communiceren.
float DS18B20gradenC; // Dit creëert een globale variabele waarin de gemeten temperatuur wordt opgeslagen.
#include <Adafruit_ADS1X15.h> // Dit laadt de bibliotheek die nodig is om met de pH module te communiceren.
Adafruit_ADS1115 pHsensor; // Dit geeft aan hoe we de pH module noemen.
float constante = 0.015625F; // Constante om input van pH module om te zetten in milliovolt signaal.
uint8_t pHsensori; // Een variabele om in bij te houden hoeveel metingen er genomen zijn.
#define pHsensorNrSamples 200 // Het aantal metingen dat gebruikt wordt om een pH te bepalen, hoe meer hoe exacter en langzamer.
int16_t pHsensorMetingen[pHsensorNrSamples]; // Variabele om de individuele metingen in op te slaan.
float pHsensorGemiddelde; // Een variabele om het gemiddelde van de metingen tijdelijk in op te slaan.
float hellingTemp; // Een variabele om de temperatauur gecorrigeerde helling in op te slaan.
float pHsensorPHTemp; // Dit creëert een globale variabele waarin de gemeten pH wordt opgeslagen.
#define helling 59  // ((volt meting 1) - (volt meting 2))/((pH kalibratievloeistof 1)-(pH kalibratievloeistof 2))
#define asafsnede 7 // ((pH kalibratievloeistof 1)-(pH kalibratievloeistof 2) - helling * (volt meting 1 + volt meting 2)) / 2
#define kalTemp 24 // Temperatuur tijdens kalibratie.
#define wacht 300000 // Tijd om de pH sensor te laten stabilizeren.

void setup() {
  pHsensor.setGain(GAIN_EIGHT); // Gebruik de GAIN_EIGHT setting om de input van de pH module om te zetten in een millivolt signaal.
  pHsensor.begin(); // Zet de comminicatie tussen de microcontroller en de pH module.
  ds18b20.begin(); // Zet de communicatie tussen de microcontroller en de temperatuursensor aan.
}

void loop() {
  pHSensor(); // Vraag de microcontroller om de functie die de pH uit de sensor ophaalt uit te voeren.
}

//Functie voor pH sensor module met temperatuur correctie:
float pHSensor() {
  
  delay(wacht); // Tijd om de pH sensor te stabiliseren, meestal 5 minuten (300000ms).

  // Neem het aantal samples dat bij pHsensorNrSamples is aangegeven per pH meting.
  for (pHsensori = 0; pHsensori < pHsensorNrSamples; pHsensori++) {
    pHsensorMetingen[pHsensori] = pHsensor.readADC_Differential_0_1(); // Verzamel het aantal metingen dat bij pHsensorNrSamples aangegeven is.
    delay(20); // Hou 20 milliseconden tussen metingen.
  }

  // Tel de metingen uit de analoge pin op in variabele pHsensorGemiddelde.
  pHsensorGemiddelde = 0; // Reset de pHsensorGemiddelde variabele.
  for (pHsensori = 0; pHsensori < pHsensorNrSamples; pHsensori++) {
    pHsensorGemiddelde += ( pHsensorMetingen[pHsensori] * constante); // Tel de metingen bij elkaar op.
  }

  pHsensorGemiddelde /= pHsensorNrSamples; // Deel het opgeteld aantal metingen door het aantal metingen om het gemiddelde te krijgen.

  // Vraag de temperatuur op uit de temperatuur sensor:
  GROVEDS18B20();

  hellingTemp = helling * (DS18B20gradenC + 273.15) / (kalTemp + 273.15); // helling * (temperatuur test + 273,15) / (temperatuur kalibratie + 273,15)
  pHsensorPHTemp = asafsnede - (pHsensorGemiddelde/hellingTemp); // asafsnede - (millivolt / temperatuur gecorrigeerde helling)

  return pHsensorPHTemp;
}

//Functie voor temperatuursensor:
float GROVEDS18B20() {
  ds18b20.requestTemperatures();
  DS18B20gradenC = ds18b20.getTempCByIndex(0);
  return DS18B20gradenC;
}

Vragen en opmerkingen

We proberen de serie "De Programmeerbare Plantenkas" zo toegankelijk mogelijk te maken voor iedereen. Toch zijn sommige concepten best wel ingewikkeld, omdat er kennis van heel veel verschillende domeinen, zoals natuurkunde, elektrotechniek en computerwetenschappen, samen komen. Het kan daarom best zijn dat we iets niet goed uitgelegd hebben. Mocht er iets niet duidelijk zijn of iets niet zo werken zoals we het in deze tutorial uitgelegd hebben, stuur dan gerust een berichtje via de Disqus op deze pagina. Je kunt de Disqus vinden door naar beneden te scrollen, tot onder de advertenties.