We maken een apparaat waarmee de temperatuur en de luchtvochtigheid gemeten kunnen worden. De gemeten waarden worden weergegeven op een kleurendisplay, waarbij de kleur verandert naarmate de temperatuur stijgt of daalt. Dit project wordt uitgevoerd met een Arduino Uno microcontroller-board en het uitbreidingssysteem Grove.
Geschikt voor: beginners met enige programmeerkennis
Benodigde tijd: circa 1,5 uur
Budget: circa 70 euro
Wat hebt u nodig: 1x Arduino Uno Rev. 3, 1x Arduino Shield – Base Shield V2 (Grove Base-Shield), 1x Grove lcd met RGB-Backlight, 1x Arduino – Grove temperatuur- en vochtigheidssensor Pro (precies), 1x USB-kabel 2.0, Hi-Speed A-St naar B-St , 1m
Andere benodigdheden: internetverbinding, computer met browser, stroomvoorziening voor de Arduino
De hardware
1. De Arduino Uno Rev. 3
Het Arduino Uno microcontroller-board heeft alles wat nodig is voor een microcontroller-project, terwijl uitgebreide elektronicakennis geen absolute noodzaak is. Tegelijkertijd zijn er talloze mogelijkheden voor veeleisende projecten.Het programmeren vindt plaats via een USB-interface die ook dient als seriële interface voor het verstrekken van gegevens. De stroomvoorziening verloopt via een stopcontact of met batterijen van 9-12 V (let op de polen van de stekker: plus aan de binnenzijde, min aan de buitenzijde) of via de USB-aansluiting.
2. Het Grove Base Shield
De sensor voor de temperatuur en de luchtvochtigheid, evenals het display, maken deel uit van het Grove-uitbreidingssysteem, dat eenvoudige en snelle ontwikkeling mogelijk maakt. Het Grove Base Shield kan eenvoudig op de Arduino worden aangesloten en beschikt over vier analoge, acht digitale en vier I²C-aansluitingen in een uniform stekkersysteem.
De status-led en de reset-knop van het Arduino-board worden hierdoor verborgen en deze bevinden zich derhalve ook op het Base Shield.
Belangrijk: de spanningsschakelaar op het Grove Base Shield moet voor een Arduino op 5V zijn ingesteld!
3. De temperatuur- en luchtvochtigheidssensor
De ‘Grove temperatuur- luchtvochtigheidssensor Pro’ die hier wordt gebruikt, is gebaseerd op een DHT22 temperatuur- en luchtvochtigheidssensor; deze meet de temperatuur tot ± 0,5 °C en de relatieve luchtvochtigheid tot ± 2% nauwkeurig.
De sensor moet worden aangesloten op een willekeurige analoge aansluiting. In dit project gebruiken we A0.
4. Het display
Het display dat hier wordt gebruikt, het ‘Grove LCD met RGB-Backlight’, heeft twee regels van elk 16 tekens. Er kunnen eigen tekens voor worden gedefinieerd. De achtergrondkleur is instelbaar.
Voor het display is een willekeurige I²C-aansluiting nodig. Aangezien het bij I²C om een bus-systeem gaat, maakt het niet uit welke I²C-aansluiting wordt gebruikt.
De software
Arduino Studio is de ontwikkelomgeving voor de Arduino. Hierin worden de programma’s gemaakt (zogeheten ‘sketches’) en op de Arduino geladen. Bovendien kan gebruik worden gemaakt van de seriële interface die via de USB-aansluiting beschikbaar is.
Arduino Studio kan gratis worden gedownload van de website van Arduino:
https://www.arduino.cc/en/Main/Software
Voor een goed werkende verbinding met de Arduino moet, als de Arduino met de pc verbonden is, in het menu ‘Tools’ → ‘Poort’ de optie ‘Arduino/Genuino’ geselecteerd zijn.
De bibliotheken
Om de verschillende shields en Grove-bouwstenen te kunnen gebruiken, zijn de bijbehorende bibliotheken nodig die met programma-interfaces beschikbaar zijn. De bibliotheek voor het SD-shield is al standaard beschikbaar, voor de beide Grove-bouwstenen moet deze nog worden geïnstalleerd.
Grove temperatuur- en luchtvochtigheidssensor Pro
Download: https://github.com/Seeed-Studio/Grove_Temperature_And_Humidity_Sensor/archive/master.zip
Documentatie: http://wiki.seeed.cc/Grove-Temperature_and_Humidity_Sensor_Pro/
Grove LCD RGB display
Download: https://github.com/Seeed-Studio/Grove_LCD_RGB_Backlight/archive/master.zip
Documentatie: http://wiki.seeed.cc/Grove-LCD_RGB_Backlight/
Download de bibliotheken en installeer deze vervolgens via het menu ‘Sketch’ → ‘Bibliotheek koppelen’ → ‘ZIP-bibliotheken toevoegen…’.
In het menu ‘Bestand’ → ‘Voorbeelden’ zijn voor alle bibliotheken voorbeeldprogramma’s beschikbaar.
Het eerste programma: De waarden van de sensor uitlezen
Laten we beginnen met een programma waarmee alleen de waarden van de temperatuursensor op de seriële interface worden weergegeven:#include <SPI.h> // Bibliotheek voor de seriële interface laden
#include <DHT.h> // Bibliotheek voor de sensor laden
// Instance van de sensorinterface genereren.
// A0 is de aansluiting op het Grove Base Shield, DHT22 het sensortype
DHT dht(A0, DHT22);
void setup() { // Wordt eenmaal uitgevoerd bij de start
Serial.begin(9600); // Seriële interface initialiseren
dht.begin(); // Sensor initialiseren
}
void loop() { // Wordt uitgevoerd in een oneindige lus
float humidity = dht.readHumidity(); // Gegevens uitlezen
float temperature = dht.readTemperature(); // Gegevens uitlezen
if (isnan(temperature) || isnan(humidity)) { // Is het uitlezen gelukt?
Serial.println(“Er is een fout opgetreden bij het lezen van DHT”);
} else {
// Gegevens tonen
Serial.print(temperature);
Serial.print(” | “);
Serial.print(humidity);
Serial.println();
}
delay(1000); // Uitvoeren programma 1s onderbreken
}
Elk Arduino-programma heeft twee methoden:
setup() wordt eenmaal aangeroepen als het programma start; het wordt dus aangeroepen als het voor het eert op de Arduino wordt afgespeeld, als de reset-knop wordt ingedrukt of als de stroomvoorziening naar de Arduino is onderbroken. Hier worden normaal gesproken apparaten geïnitialiseerd.
loop() wordt aangeroepen in een oneindige lus zodra setup is beëindigd. Hier vindt de daadwerkelijke programmalogistiek plaats: de gegevens worden uitgelezen door de sensor, er wordt gecontroleerd of het uitlezen gelukt is en of de gegevens naar de seriële interface zijn geschreven. Het delay aan het eind is erg belangrijk: Hier wordt de volledige uitvoering 1 seconde onderbroken, zodat de console nog op de pc kan worden gelezen.
Het programma wordt gemaakt met ‘Sketch’ → ‘Controleren/compileren’, zodat het op de Arduino kan worden geschreven. Daarbij worden ook meldingen over programmeerfouten en mogelijke problemen gemeld. Soms wordt er in het programma een waarschuwing in rood weergegeven in de statusuitvoer van Arduino Studio, omdat NAN opnieuw wordt gedefinieerd. Dat komt door de bibliotheek van de temperatuursensor en kan worden genegeerd.
Het programma wordt via ‘Sketch’ → ‘Uploaden’ naar de Arduino geschreven en wordt daarbij automatisch opgebouwd. Via ‘Tools’ → ‘Seriële monitor’ is dan de volgende uitvoer te zien:
26.10 | 64.50
26.20 | 64.50
26.20 | 64.50
Het display aansturen
Voor de eerste stappen met het lcd-display wordt een instance gedefinieerd van het display en een array met de pixels voor een nieuw teken. In setup() wordt dit teken vervolgens geregistreerd bij het display. In loop() stellen we de kleur in op rood en schrijven we de tekst met het nieuwe teken naar het display.#include <Wire.h>
#include <rgb_lcd.h> rgb_lcd lcd; // Instance van display-interface genereren
byte HEART_SYMBOL = 0; // Duidelijke naam voor het symbool
byte heart[8] = { // De instelling van de afzonderlijke pixels
0b00000,
0b01010,
0b11111,
0b11111,
0b11111,
0b01110,
0b00100,
0b00000
};
void setup(){
lcd.begin(16, 2); // Display initialiseren – 2 regels van elk 16 tekens
lcd.createChar(HEART_SYMBOL, heart); // Hartpictogram registreren
}
void loop() {
int red = 255;
int green = 0;
int blue = 0;
lcd.setRGB(red, green, blue);
lcd.setCursor(0, 0); // Cursor in display aan begin van eerste regel plaatsen
lcd.print(“I “);
lcd.write(HEART_SYMBOL);
lcd.print(” Arduino”);
lcd.setCursor(0, 1); // Cursor in display aan begin van tweede regel plaatsen
lcd.print(“===========”);
}
Het programma weer via ‘Sketch’ → ‘Uploaden’ naar de Arduino schrijven. De resultaten kunnen direct worden bekeken op het scherm.
Het definitieve programma
Om de temperatuur en de luchtvochtigheid op het display weer te geven, combineren we beide programma’s. Het display herkent nog geen -teken; daarom definiëren we dit teken, op dezelfde wijze als het hartteken uit het vorige programma.
In setup() worden de seriële interface, de sensor en het display geïnitialiseerd en wordt het nieuwe symbool geregistreerd bij het display.
In loop() worden temperatuur en luchtvochtigheid opgevraagd, zodat op basis van de temperatuur de kleurwaarden berekend kunnen worden en alles kan worden weergegeven. De formules zijn zo gekozen dat het display felblauw kleurt als de temperatuur gelijk aan of lager dan de koudste waarde is; het display kleurt helrood als de temperatuur gelijk aan of hoger dan de warmste waarde is. Als de groene waarde 0 blijft, is de overgang van blauw naar rood paars gekleurd. Als de overgang in plaats daarvan wit is gekleurd en het display alleen aan de uiteinden is gekleurd, dan kan de alternatieve formule met een commentaar worden toegevoegd.
De methode limit(float color) zorgt ervoor dat de kleurwaarde in het toegestane bereik van 0..255 blijft – temperaturen lager dan ‘coldest’ zouden anders bijvoorbeeld negatieve waarden opleveren. De omschakeling van een drijvende-kommagetal (float) naar een kleurwaarde met een geheel getal (int) vindt automatisch plaats, de cijfers achter de komma vallen weg.
#include <Wire.h>
#include <rgb_lcd.h>
#include <DHT.h>
rgb_lcd lcd;
DHT dht(A0, DHT22);
byte DEGREE_SYMBOL = 0;
byte degree[8] = {
0b00000,
0b00010,
0b00101,
0b00010,
0b00000,
0b00000,
0b00000,
0b00000
};
void setup(){
Serial.begin(9600); // Seriële aansluiting initialiseren
lcd.begin(16, 2); // Display initialiseren – 2 regels van elk 16 tekens
lcd.createChar(DEGREE_SYMBOL, degree); // Het nieuwe ‘°’-symbool registreren bij
het display
dht.begin(); // Sensor initialiseren
}
void loop() {
float humidity = dht.readHumidity();
float temperature = dht.readTemperature();
if (isnan(temperature) || isnan(humidity)) {
Serial.println(“Fout bij lezen van sensor”);
} else {
const float coldest = 18;
const float hottest = 30;
int red = limit(255 * (temperature – coldest) / (hottest – coldest));
// Kleur van blauw via lila naar rood
int green = 0;
// rood en blauw naarmate men dichterbij het uiteinde komt, wit in het midden
// int green = limit(255 * sqrt(max(0, (hottest – temperature)*(temperature –
coldest))) / (hottest – coldest));
int blue = limit(255 * (hottest – temperature) / (hottest – coldest));
lcd.setRGB(red, green, blue);
lcd.setCursor(0, 0);
lcd.print(“T: “);
lcd.print(temperature);
lcd.write(DEGREE_SYMBOL);
lcd.print(“C”);
lcd.setCursor(0, 1);
lcd.print(“H: “);
lcd.print(humidity);
lcd.print(“%”);
}
delay(100);
}
float limit(float color) { // Kleurwaarden moeten in het bereik 0..255 liggen
if (color < 0) {
return 0;
}
else if (color > 255) {
return 255;
}
else {
return color;
}
}
Veel plezier!
Stuklijst:
1x Arduino Shield – Base Shield V2 (Grove Base-Shield)
1x Grove LCD met RGB-Backlight
1x Arduino – Grove temperatuur- en vochtigheidssensor Pro (precies)
1x USB-kabel 2.0, Hi-Speed A-St naar B-St , 1m
Optioneel:
