Meet de watertemperatuur met een DS18B20 temperatuur sensor en een Arduino Uno

Een simpele badwater-thermometer die door middel van 3 LED’s aangeeft of het badwater op de juiste temperatuur is (voor baby’s 36-38 graden Celsius). De blauwe LED staat voor te koud, de rode LED voor te warm en als de groene LED brandt dan is het water op de juiste temperatuur.

De temperatuur sensor is een DS18B20 waterbestendige sensor met een nauwkeurigheid van 0.5 C. Meer info over dit product op de website van Adafruit.

Installeer in de Arduino IDE de bibliotheek van OneWire én Dallas Temperature Control Arduino.

De code:

// Include the libraries we need
#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE_BUS 2

// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature. 
DallasTemperature sensors(&oneWire);

// arrays to hold device address
DeviceAddress insideThermometer;

 * Setup function. Here we do the basics
void setup(void)
 // start serial port
 Serial.println("Dallas Temperature IC Control Library Demo");

// locate devices on the bus
 Serial.print("Locating devices...");
 Serial.print("Found ");
 Serial.print(sensors.getDeviceCount(), DEC);
 Serial.println(" devices.");

// report parasite power requirements
 Serial.print("Parasite power is: "); 
 if (sensors.isParasitePowerMode()) Serial.println("ON");
 else Serial.println("OFF");

// Method 1:
 // Search for devices on the bus and assign based on an index. Ideally,
 // you would do this to initially discover addresses on the bus and then 
 // use those addresses and manually assign them (see above) once you know 
 // the devices on your bus (and assuming they don't change).
 if (!sensors.getAddress(insideThermometer, 0)) Serial.println("Unable to find address for Device 0"); 

// show the addresses we found on the bus
 Serial.print("Device 0 Address: ");

// set the resolution to 9 bit (Each Dallas/Maxim device is capable of several different resolutions)
 sensors.setResolution(insideThermometer, 9);
 Serial.print("Device 0 Resolution: ");
 Serial.print(sensors.getResolution(insideThermometer), DEC); 

//initialise LED pins
 for(int pinNumber = 3; pinNumber < 6; pinNumber++){
 pinMode(pinNumber, OUTPUT);
 digitalWrite(pinNumber, LOW);

// function to print the temperature for a device
void printTemperature(DeviceAddress deviceAddress)
// method 2 - faster
 float tempC = sensors.getTempC(deviceAddress);
 Serial.print("Temperatuur: ");

 * Main function. It will request the tempC from the sensors and display on Serial.
void loop(void)
 // call sensors.requestTemperatures() to issue a global temperature 
 // request to all devices on the bus
 //Serial.print("Requesting temperatures...");
 sensors.requestTemperatures(); // Send the command to get temperatures
 // It responds almost immediately. Let's print out the data
 printTemperature(insideThermometer); // Use a simple function to print out the data

float tempC = sensors.getTempC(insideThermometer);
 if(tempC < 36.00){
 digitalWrite(3, LOW);
 digitalWrite(4, LOW);
 digitalWrite(5, HIGH);
 } else if(tempC >= 36.00 && tempC <= 38.00){
 digitalWrite(3, LOW);
 digitalWrite(4, HIGH);
 digitalWrite(5, LOW);
 } else if(tempC > 38.00){
 digitalWrite(3, HIGH);
 digitalWrite(4, LOW);
 digitalWrite(5, LOW);

// function to print a device address
void printAddress(DeviceAddress deviceAddress)
 for (uint8_t i = 0; i < 8; i++)
 if (deviceAddress[i] < 16) Serial.print("0");
 Serial.print(deviceAddress[i], HEX);

Smart Doorbell project with Adafruit Feather HUZZAH ESP8266

My doorbell is nothing more than a simple pushbutton. So if I wire a microcontroller to my doorbell, I just have to figure out some simple code that executed the following: if the doorbell is pushed, then send a push notification to my iPhone. So I need a doorbell, gladly my house is provided with one, a microcontroller (Feather HUZZAH), some wiring, a push notification service (Pushover) and at last some code.


  • Adafruit Feather HUZZAH (cheap, simple and WiFi onboard!)
  • Wires
  • Breadboard
  • Resistor 10K ohm
  • LED
  • Doorbell including wires


  • Arduino IDE (from
  • Basic Button tutorial from
  • Pushover Library for ESP8266 (Github)
  • Pushover API – Pushover has no monthly subscription fees and users will always be able to receive unlimited messages by making a one-time license purchase ($ 4,99) for our Android, iOS, or Desktop apps.


  1. IN PROGRESSConnect Wires: 3.3V to + and GND to – on the breadboard.
  2. IN PROGRESS: Upload the code to the Feather via Arduino IDE – beware of the settings!

Example code:

#include "Pushover.h"

void setup() {
WiFi.begin("myNetwork", "secureWPAKii");
while (WiFi.status() != WL_CONNECTED) delay(50);

Pushover po = Pushover("SecureAppToken","UserToken");
Serial.println(po.send()); //should return 1 on success

void loop() {

 Turns on and off a light emitting diode(LED) connected to digital
 pin 13, when pressing a pushbutton attached to pin 2.

 The circuit:
 * LED attached from pin 13 to ground
 * pushbutton attached to pin 2 from +5V
 * 10K resistor attached to pin 2 from ground

 * Note: on most Arduinos there is already an LED on the board
 attached to pin 13.

 created 2005
 by DojoDave <>
 modified 30 Aug 2011
 by Tom Igoe

 This example code is in the public domain.

// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 2;     // the number of the pushbutton pin
const int ledPin =  13;      // the number of the LED pin

// variables will change:
int buttonState = 0;         // variable for reading the pushbutton status

void setup() {
  // initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);
  // initialize the pushbutton pin as an input:
  pinMode(buttonPin, INPUT);

void loop() {
  // read the state of the pushbutton value:
  buttonState = digitalRead(buttonPin);

  // check if the pushbutton is pressed.
  // if it is, the buttonState is HIGH:
  if (buttonState == HIGH) {
    // turn LED on:
    digitalWrite(ledPin, HIGH);
  } else {
    // turn LED off:
    digitalWrite(ledPin, LOW);

Feather HUZZAH ESP8266 + DHT22 temperature and humidity sensor

Do you want to monitor your room temperature and humidity in realtime? The Feather HUZZAH from Adafruit in combination with the DHT temperature sensor does the job.

  Adafruit MQTT Library ESP8266 Example

  Must use ESP8266 Arduino from:

  Works great with Adafruit's Huzzah ESP board & Feather

  Adafruit invests time and resources providing this open source code,
  please support Adafruit and open-source hardware by purchasing
  products from Adafruit!

  Written by Tony DiCola for Adafruit Industries.
  MIT license, all text above must be included in any redistribution
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"
#include "DHT.h"

/************************* WiFi Access Point *********************************/

//#define WLAN_SSID       "####SSID#####"
//#define WLAN_PASS       "####WPA2#####"

/************************* Setup *********************************/

#define AIO_SERVER      ""
#define AIO_SERVERPORT  1883                   // use 8883 for SSL
#define AIO_USERNAME    "########"
#define AIO_KEY         "########"

/************ Global State (you don't need to change this!) ******************/

// Create an ESP8266 WiFiClient class to connect to the MQTT server.
WiFiClient client;
// or... use WiFiFlientSecure for SSL
//WiFiClientSecure client;

// Store the MQTT server, username, and password in flash memory.
// This is required for using the Adafruit MQTT library.

// Setup the MQTT client class by passing in the WiFi client and MQTT server and login details.

/************ DHT settings ******************/

#define DHTPIN 4     // what digital pin we're connected to

#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321


/****************************** Feeds ***************************************/

// Setup a feed called 'photocell' for publishing.
// Notice MQTT paths for AIO follow the form: /feeds/
const char PHOTOCELL_FEED[] PROGMEM = AIO_USERNAME "/feeds/photocell";
Adafruit_MQTT_Publish photocell = Adafruit_MQTT_Publish(&mqtt, PHOTOCELL_FEED);

const char TEMP_FEED[] PROGMEM = AIO_USERNAME "/feeds/temp";
Adafruit_MQTT_Publish temp = Adafruit_MQTT_Publish(&mqtt, TEMP_FEED);

const char HUM_FEED[] PROGMEM = AIO_USERNAME "/feeds/hum";
Adafruit_MQTT_Publish hum = Adafruit_MQTT_Publish(&mqtt, HUM_FEED);

// Setup a feed called 'onoff' for subscribing to changes.
const char ONOFF_FEED[] PROGMEM = AIO_USERNAME "/feeds/onoff";
Adafruit_MQTT_Subscribe onoffbutton = Adafruit_MQTT_Subscribe(&mqtt, ONOFF_FEED);

/*************************** Sketch Code ************************************/

// Bug workaround for Arduino 1.6.6, it seems to need a function declaration
// for some reason (only affects ESP8266, likely an arduino-builder bug).
void MQTT_connect();

void setup() {

  Serial.println(F("Adafruit MQTT demo"));

  // Connect to WiFi access point.
  Serial.println(); Serial.println();
  Serial.print("Connecting to ");

  while (WiFi.status() != WL_CONNECTED) {

  Serial.println("WiFi connected");
  Serial.println("IP address: "); Serial.println(WiFi.localIP());

  // Setup MQTT subscription for onoff feed.


uint32_t x=0;

void loop() {
  // Ensure the connection to the MQTT server is alive (this will make the first
  // connection and automatically reconnect when disconnected).  See the MQTT_connect
  // function definition further below.

  // this is our 'wait for incoming subscription packets' busy subloop
  // try to spend your time here

  Adafruit_MQTT_Subscribe *subscription;
  while ((subscription = mqtt.readSubscription(5000))) {
    if (subscription == &onoffbutton) {
      Serial.print(F("Got: "));
      Serial.println((char *)onoffbutton.lastread);


  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  float h = dht.readHumidity();
  // Read temperature as Celsius (the default)
  float t = dht.readTemperature();

  // Check if any reads failed and exit early (to try again).
 // if (isnan(h) || isnan(t) || isnan(f)) {
 //   Serial.println("Failed to read from DHT sensor!");
 //   return;
 // }

  // Now we can publish stuff!
 // Serial.print(F("\nSending photocell val "));
 // Serial.print(t);
  //if (! photocell.publish(t)) {
   // Serial.println(F("Failed"));
  //} else {
   // Serial.println(F("OK!"));

   if (isnan(h) || isnan(t)) {
    Serial.println("Failed to read from DHT sensor!");
   } else {

  // ping the server to keep the mqtt connection alive
  // NOT required if you are publishing once every KEEPALIVE seconds
  if(! {

// Function to connect and reconnect as necessary to the MQTT server.
// Should be called in the loop function and it will take care if connecting.
void MQTT_connect() {
  int8_t ret;

  // Stop if already connected.
  if (mqtt.connected()) {

  Serial.print("Connecting to MQTT... ");

  uint8_t retries = 3;
  while ((ret = mqtt.connect()) != 0) { // connect will return 0 for connected
       Serial.println("Retrying MQTT connection in 5 seconds...");
       delay(5000);  // wait 5 seconds
       if (retries == 0) {
         // basically die and wait for WDT to reset me
         while (1);
  Serial.println("MQTT Connected!");