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

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

In deze tutorial laten we zien hoe je een Grove pH sensor module kunt aansluiten, kalibreren en programmeren om met een Arduino microcontroller of vergelijkbare microcontroller de pH waarde van een vloeistof kunt bepalen. In dit voorbeeld gebruiken we een "budget" E201 pH sensor van het merk Bante.

Aansluiten

Het aansluiten van de pH sensor op het module is zeer eenvoudig. Je draait de mannelijke BNC-connector van de pH sensor simpelweg vast in de vrouwelijke BNC-connector van de Grove module. Vervolgens plug je de ene kant van de Grove aansluitkabel in de Grove module en de andere kant in een analoge poort van de Grove Base Shield, die op een micro-controller bevestigd is.

BNC sensor, pH sensor, Grove pH sensor kit
Het aansluitbord van de Grove pH sensor kit bevat een BNC connector waarin de pH sensor vast gedraaid kan worden.

De pH van een vloeistof wordt beïnvloed door de temperatuur die de vloeistof heeft. Daarom kun je het beste ook een waterdichte temperatuursensor aansluiten op de microcontroller. Wij gebruiken hiervoor een DS18B20 temperatuursensor. Meer over deze temperatuursensor kun je lezen in het artikel "De Programmeerbare Plantenkas: De DS18B20 Temperatuursensor Aansluiten En Programmeren Om De Temperatuur Te Meten". Mocht je geen temperatuursensor hebben, dan kun je deze eventueel ook weg halen, maar dit is niet aan te raden, omdat het de accuratie van de meting kan verstoren.

Voor de kalibratie van de pH sensor maken wij gebruik van de dual button module van de Grove lijn van Seeed Studio. Wanneer je een Arduino UNO of een Arduino MEGA gebruikt voor de kalibratie van de pH sensor, dan moet je deze aansluiten op digitale poort 2 en digitale poort 3. Deze poorten zijn namelijk geschikt om de functie “attachinterrupt” op aan te sluiten.

dual button
De dual button module van Grove gebruiken we alleen tijdens de kalibratie in dit voorbeeld.

Kalibratie Programmeren

Een pH sensor werkt op basis van een elektrode, gemaakt van zilver(chloride) die omringd is met een laagje pH gevoelig glas. Binnenin het glas zit een referentievloeistof die uit kaliumchloride en buffer bestaat, waardoor deze vloeistof een pH-waarde van 7,0 pH heeft. Zowel tijdens het gebruik als tijdens de opslag van de pH sensor, kunnen de eigenschappen van het glas, de elektrode en/of de referentievloeistof veranderen. Hierdoor kan het zijn dat er niet iets meer of juist net iets minder stroom wordt gegenereerd dan verwacht. Door de pH sensor bij het eerste gebruik en daarna in ieder geval elke zes maanden te kalibreren, kun je de uitslag van een pH meting hier voor compenseren.

pH sensor, kristallen
Onder de microscoop zie je soms dat er kristallen in het glas rondom de elektrode in de pH sensor vormen die de metingen kunnen verstoren.

Om een pH sensor te kalibreren, moet je een aantal stappen doorlopen. Allereerst spoel je de onderkant van de pH sensor af met gedestilleerd water en dep je de sensor voorzichtig droog. Wanneer de pH sensor niet gebruikt wordt, moet de punt van de sensor in een kaliumchloride-oplossing met een pH van 4,0 pH bewaard worden. Het afspoelen van de sensor met gedestilleerd water zorgt ervoor dat er geen restjes kaliumchloride op de sensor zitten, die de metingen kunnen verstoren.

kalibratie, ph sensor
Voor, tijdens en na de kalibratie moet de pH sensor en de temperatuursensor eerst afgespoeld worden in gedestilleerd water.
ph sensor, kalibreren
Na het afspoelen met gedestilleerd water wordt de pH sensor en de temperatuursensor voorzichtig droog gedept.

Na het afspoelen stop je de punt van de pH sensor in een bakje met kalibratievloeistof. Wij hebben in dit voorbeeld een kalibratievloeistof van 4,0 pH gebruikt. Om te voorkomen dat je veel kalibratievloeistof nodig hebt, is het handig om een bakje te gebruiken dat niet te breed is. Ook is het belangrijk om er voor te zorgen dat het bakje stevig staat.

ph sensor, kalibreren
Om onze pH sensor te kalibreren, hebben we eerst een kalibratievloeistof met een pH van 4,0 pH gebruikt.
kalibratie, ph sensor
Vul bij #define kalpH1 en #define kalpH2 in wat de pH waarde is van de kalibratievloeistof die je gebruikt.

Zodra de onderkant van de pH sensor in de eerste kalibratievloeistof zit, dan druk je op de knop die je gekoppeld hebt aan de functie “drukKnop1”. Het programma zal dan eerst een pauze van vijf minuten (300.000 milliseconden) in lassen. Dit is de tijd die de sensor nodig heeft om aan de kalibratievloeistof te wennen. Wanneer je meteen begint met het doen van metingen, dan zitten er vaak een paar afwijkende waardes tussen. Hoe langer de pH sensor de tijd heeft om aan de kalibratievloeistof te wennen en hoe dichter de temperatuur van de kalibratievloeistof rond de 25 graden Celsius ligt, hoe beter de resultaten.

Wanneer de sensor een tijdje heeft kunnen wennen aan de kalibratievloeistof, dan kijkt het programma 200 keer hoeveel volt er vanuit de Grove pH module de microcontroller binnen komt. De uitkomsten van deze metingen worden opgeslagen. Vervolgens wordt het gemiddelde van deze metingen bepaald, door de metingen op te tellen en door het aantal metingen, in dit voorbeeld 200, te delen.

Zodra de metingen in de eerste kalibratie vloeistof zijn voltooid, geeft het programma via de Serial Monitor een seintje dat het tijd is om de sensor gereed te maken voor de metingen in de tweede kalibratievloeistof. Ook nu moet je de sensor eerst weer afspoelen met gedestilleerd water en de sensor een beetje droog deppen voordat je de sensor in de tweede kalibratievloeistof, in ons geval met een pH van 10,0 pH, plaatst.

ph sensor, kalibreren
Voor het kalibreren van een pH sensor heb je altijd twee verschillende soorten kalibratievloeistof nodig. Wij hebben een kalibratievloeistof met pH 4,0 en 10,0 gebruikt, maar je kunt ook 4,0 en 7,0 of 7,0 en 10,0 gebruiken.

Wanneer je de sensor in een nieuw bakje met een andere kalibratievloeistof hebt geplaatst, kun je op de knop drukken die gekoppeld is aan de functie “drukKnop2”. Ook nu zal het programma eerst weer een pauze van vijf minuten nemen en daarna 200 metingen verzamelen om een gemiddelde meting te bepalen.

Als het programma voor kalibratievloeistof 1 en kalibratievloeistof 2 heeft bepaald hoeveel volt er via de pH sensor en de Grove module de microcontroller binnen komt, wordt de helling, ofwel het richtingscoëfficiënt, en de asafsnede automatisch bepaald. Deze waardes worden op de Serial Monitor getoond en kunnen worden ingevoerd in het programma dat gebruikt kan worden om de pH-waarde van andere vloeistoffen te bepalen.

ph sensor, kalibreren
Aan het einde van de kalibratie verteld de Serial Monitor wat de helling en de asafsnede voor de gebruikte pH sensor zijn.

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 Grove pH 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
   
*/

// 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.
#define pHsensorPin A2 // Dit geeft aan op welke analoge input de sensor is aangesloten, in dit geval A2.
#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.

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.
  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(300000); // 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] = analogRead(pHsensorPin); // 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 * 5 / 1023;
    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 * 5 / 1023;
    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;
}

Afwijkende volt metingen

Als je de metingen van de Grove module uit de pH sensor kit vergelijkt met de waardes die de pH sensor volgens de fabrikant bij een bepaalde pH zou moeten meten, dan lijkt het in eerste instantie alsof er iets mis is met de sensor of het programma. Dit komt, omdat de Grove module een soort versterker bevat, waardoor er altijd 1,8 Volt de microcontroller binnen komt. Fabrikanten geven vaak een tabel waarin staat hoeveel volt of microvolt er bij een bepaalde pH gemeten zou moeten worden. Als je de waardes van dit  programma met de waardes uit zo’n tabel wilt vergelijken, dan moet je dus 1,8 volt van de meting af trekken. Zo zegt de fabrikant van de pH sensor die we in dit voorbeeld gebruiken dat er bij een pH van 4,0 174,78 millivolt, ofwel 0,17478 volt gemeten zou moeten worden zonder versterker. Wanneer je deze pH sensor gebruikt met een Grove module, dan verwacht je dus dat er rond de 1.97478 Volt wordt gemeten.

pH metingen programmeren

Wanneer je de kalibratie hebt uitgevoerd, dan kun je de richtingscoëfficiënt (#define helling), de asafsnede (#define asafsnede#define kalTemp) in het programma hieronder invullen in de voorbereiding van het programma. Het cijfer voor de helling voer je in achter #define helling en de asafsnede achter #define asafsnede.

Verder zijn er nog een aantal andere gegevens die we in de voorbereiding invullen. Achter #define pHsensorpin zetten we op welke analoge pin de Grove pH sensor module is aangesloten. In dit voorbeeld zit de sensor op analoge pin 2. Verder vertellen we het programma op basis van hoeveel metingen we de gemiddelde meting willen bepalen met #define pHsensorNrSamples. In dit geval hebben we voor 200 metingen gekozen. Hoe meer metingen, hoe accurater de uitslag, maar wel hoe langer het programma bezig is. Als laatste maken we nog een aantal variabelen aan die het programma gaat gebruiken om de pH waarde te berekenen.

In de voorbereiding van het programma bereiden we ook het gebruik van de DS18B20 temperatuursensor voor. In het artikel "De Programmeerbare Plantenkas: De DS18B20 Temperatuursensor Aansluiten En Programmeren Om De Temperatuur Te Meten" leggen we uitgebreidt uit hoe deze temperatuur sensor werkt, en hoe deze geprogrammeerd kan worden.

In de setup fase en de loop fase van het programma hoeven we weinig te doen. In de setup fase wordt alleen de DS18B20 temperatuursensor aangezet en in de loop fase wordt de functie pHSensor(); opgeroepen.

De functie pHSensor(); zorgt ervoor dat het gemeten aantal volt uit de pH sensor, dat afhankelijk is van de hoeveelheid waterstofionen in vloeistof die gemeten wordt, omgezet wordt in een pH waarde. Deze functie begint met het commando delay(wacht);. Wanneer de functie wordt geactiveerd, kan wordt er eerst een tijd, in dit geval 300000 milliseconden, ofwel 5 minuten, gewacht. De meeste pH sensoren hebben een tijdje nodig voordat het aantal gemeten volt overeenkomt met de pH waarde. In de handleiding van de specifieke pH sensor die je gebruikt kun je meestal terug vinden hoeveel tijd er minimaal tussen het moment dat de pH sensor in de vloeistof wordt geplaatst en de tijd dat er een goede meting uitgevoerd kan worden moet zitten.

Na het wachten tot de pH sensor gestabiliseerd is, wordt eerst de temperatuur gemeten. De werking van een pH sensor is afhankelijk van de temperatuur van de vloeistof, dus het is aan te raden om een pH sensor altijd in combinatie met een temperatuursensor te gebruiken.

In de volgende stap worden de metingen uit de pH sensor verzameld. In het geval van dit voorbeeld verzamelen we 200 metingen, die elke 20 milliseconden worden genomen. De metingen worden één voor één in de array pHsensorMetingen geplaatst.

Als de metingen zijn voltooid wordt het volgende stukje van de functie geactiveerd. Hierin worden de 200 individuele metingen eerst opgeteld en daarna door het aantal metingen, dus 200, gedeeld om het gemiddelde te krijgen. De analogue pin van onze Arduino microcontroller zet het analoge signaal, dat tussen de 0 en 5 volt ligt, dat binnenkomt om in een cijfer tussen de 0 en de 1023. Om dit cijfer terug te zetten in volt vermenigvuldigen we de gemiddelde meting en delen we het daarna met 1023.

Als laatste worden de berekeningen uitgevoerd die het aantal gemeten volt omzet in een pH waarde. De eerste stap is om de temperatuurcompensatie op het richtingscoëfficiënt uit te voeren. Hiervoor wordt de waarde van de helling, die tijdens de kalibratie bepaald is, eerst vermenigvuldigd met de huidige temperatuur plus 273,15, het absolute nulpunt, en daarna gedeeld door de kalibratie temperatuur plus 273,15. Dit voor de temperatuur gecorrigeerde richtingscoëfficiënt wordt vervolgens gebruikt om de pH waarde te berekenen. Hiervoor wordt het aantal gemeten millivolt gedeeld door de temperatuur gecorrigeerde richtingscoëfficiënt afgetrokken van de asafsnede.

Dit voorbeeld is een heel simplistische code, waarbij de pH waarde constant wordt bepaald en de pH waarde nergens getoont wordt. Afhankelijk van hoe je de pH sensor wilt gaan gebruiken, kun je bijvoorbeeld een timer of een drukknop gebruiken om de pH meting te activeren. Ook kun je de gemeten pH waarde tonen op de Serial Monitor of op een display.

Arduino IDE code - pH metingen


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

   Deze code is gemaakt voor pH sensor aangesloten op
   een Grove pH 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
   
   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>
#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 D2.
OneWire oneWire(ONE_WIRE_BUS);
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.
#define pHsensorPin A2 // Dit geeft aan op welke analoge input de sensor is aangesloten, in dit geval A2.
#define pHsensorNrSamples 200 // Het aantal metingen dat gebruikt wordt om een pH te bepalen, hoe meer hoe exacter en langzamer.
#define helling -17.37 // ((volt meting 1) - (volt meting 2))/((pH kalibratievloeistof 1)-(pH kalibratievloeistof 2))
#define asafsnede 38.84 // ((pH kalibratievloeistof 1)-(pH kalibratievloeistof 2) - helling * (volt meting 1 + volt meting 2)) / 2
#define kalTemp 22.50 // Temperatuur tijdens kalibratie.
#define wacht 300000 // Tijd om de pH sensor te laten stabilizeren.
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 pHsensorVolt; // Een variabele om de gemeten volt van de pH sensor 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.

void setup() {
  ds18b20.begin(); // Zet de communicatie tussen de microcontroller en de sensor aan.
}

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

//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; // De functie zal de waarde van variabele AHT20gradenC updaten met de gemeten temperatuur.
}

// Functie voor pH sensor met temperatuur correctie:
float pHSensor() {

  delay(wacht); // Tijd om de pH sensor te stabiliseren, meestal 5 minuten (300000ms).

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

  // Neem het aantal samples dat bij pHsensorNrSamples is aangegeven per pH meting.
  for (pHsensori = 0; pHsensori < pHsensorNrSamples; pHsensori++) {
    pHsensorMetingen[pHsensori] = analogRead(pHsensorPin); // 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]; // Tel de metingen bij elkaar op.
  }

  pHsensorGemiddelde /= pHsensorNrSamples; // Deel het opgeteld aantal metingen door het aantal metingen om het gemiddelde te krijgen.
  pHsensorVolt = pHsensorGemiddelde * 5 / 1023; // Vermenigvuldig het gemiddelde met 5 en deel het door 1023 om de digitale representatie van het aantal gemeten volt om te zetten in echte volts.
  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;
}

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.