MiniR4_DHT11.h

Go to the documentation of this file.

 
#ifndef MINIR4_DHT11_H
#define MINIR4_DHT11_H
 
#include <Arduino.h>
 
template <uint8_t PIN1, uint8_t PIN2>
class MiniR4DHT11
{
public:
    MiniR4DHT11()
    {
        _pin = PIN2; //PIN設定在DI_R位置，通過MiniR4Digital_h模板Pin1_2順序來初始化Grove或MATRIX物件
        pinMode(_pin, OUTPUT);
        digitalWrite(_pin, HIGH);
    }
 
    static const int ERROR_CHECKSUM = 254;    // Error code for checksum mismatch.
    static const int ERROR_TIMEOUT = 253;     // Error code for timeout.
                                              // static const int ERROR_NOT_READY = 252;  // Error code for not ready (delay not passed).
    static const int TIMEOUT_DURATION = 1000; // Timeout duration in milliseconds.
 
    void setDelay(unsigned long delay)
    {
        _delayMS = delay;
    }
 
    float readTemperature()
    {
        byte data[5];
        int error = readRawData(data);
        if (error != 0)
        {
            return error;
        }
 
        float t = (float)data[3] / 10;
        return data[2] + t;
    }
 
    int readHumidity()
    {
        byte data[5];
        int error = readRawData(data);
        if (error != 0)
        {
            return error;
        }
 
        return data[0];
    }
 
    int readTemperatureHumidity(float &temperature, int &humidity)
    {
        byte data[5];
        int error = readRawData(data);
        if (error != 0)
        {
            return error;
        }
 
        humidity = data[0];
        float t = (float)data[3] / 10;
        temperature = data[2] + t;
        return 0;
    }
 
    String getErrorString(int errorCode)
    {
        switch (errorCode)
        {
        case ERROR_TIMEOUT:
            return "Error 253: Timeout reading from DHT11.";
        case ERROR_CHECKSUM:
            return "Error 254: Checksum mismatch reading from DHT11.";
        // case ERROR_NOT_READY:
        // return "Error 252: Not ready to read from DHT11. Delay not passed.";
        default:
            return "Error: Unknown.";
        }
    }
 
private:
    int _pin;                     // Pin number for the DHT11 sensor.
    unsigned long _delayMS = 250; // Delay between readings.
 
    void startSignal()
    {
        pinMode(_pin, OUTPUT);
        digitalWrite(_pin, LOW);
        delay(18);
        digitalWrite(_pin, HIGH);
        delayMicroseconds(40);
        pinMode(_pin, INPUT);
    }
 
    int readRawData(byte data[5])
    {
        delay(_delayMS);
        // if (millis() - _lastReadTime < _delayMS) {
        // return ERROR_NOT_READY; // if not reach delayMS, bypass.
        // }
 
        startSignal();
        unsigned long timeout_start = millis();
 
        while (digitalRead(_pin) == HIGH)
        {
            if (millis() - timeout_start > TIMEOUT_DURATION)
            {
                return ERROR_TIMEOUT;
            }
        }
 
        delayMicroseconds(80);
        if (digitalRead(_pin) == HIGH)
        {
            delayMicroseconds(80);
            for (int i = 0; i < 5; i++)
            {
                data[i] = readByte();
            }
 
            if (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF))
            {
                // _lastReadTime = millis(); // update daley timer
                return 0; // Success
            }
            else
            {
                return ERROR_CHECKSUM;
            }
        }
        return ERROR_TIMEOUT;
    }
 
    byte readByte()
    {
        byte value = 0;
        for (int i = 0; i < 8; i++)
        {
            while (digitalRead(_pin) == LOW)
                ;
            delayMicroseconds(30);
            if (digitalRead(_pin) == HIGH)
            {
                value |= (1 << (7 - i));
            }
            while (digitalRead(_pin) == HIGH)
                ;
        }
        return value;
    }
};
 
#endif // MINIR4_DHT11_H