温度(湿度)センサを使ってみた(2)
RaspberryPi/pigpioでDHT11

#include <iostream>
#include "Sensor/CDHT11.h"
#include "CGpio/CGpio.h"

using namespace std;

#define DHT11_DATA      (21)

int main() {

    CDHT11 dht11;
    dht11.setupGpioPin(DHT11_DATA);
    while (1) {
        if (CDHT11::CDHT11_ERROR_OK == dht11.read()) {
            printf("Temperature = %d.%d[C] ",
                    dht11.getTemperature() / 256,
                    abs(dht11.getTemperature()) % 256);
            printf("humidity = %d.%d[%%]\n",
                    dht11.getHumidity() / 256,
                    abs(dht11.getHumidity()) % 256);

        }
    }
    return 0;
}

/**
 * @brief   Read sensor value.
 * @return  Returns 0 if reading sensor value finished succeeded, otherwise
 *          returns none 0 value.
 */
int CDHT11::read() {

    if (false == this->isScanIntervalPassed()) {
        return CDHT11_ERROR_SENSOR_NO_UPDATA;
    }

    int sequenceResult = this->readSequence();
    if (CDHT11_ERROR_OK != sequenceResult) {
        CLog::Error("Reading sensor failed.");
    } else {
        //Nothing to do.
    }
    this->updateInterval();

    return sequenceResult;
}

/*
 * A wait time to set data signal level keeping low to send start signal.
 * From the data sheet, the time should be larger than 18 msec, no more than
 * 30 msec.
 */
//#define   DHT11_START_SIGNAL_LOW_TIME_MILLISEC                (18)
//A little bit longer than the value in data sheet...
#define DHT11_START_SIGNAL_LOW_TIME_MILLISEC                (20)
#define DHT11_START_SIGNAL_HIGH_TIME_MILLISEC               (80)
#define MILLI2MICRO_SEC(milli_sec)                          ((milli_sec) * 1000)
#define DHT11_SENSOR_READY_TO_OUTPUT_SIGNAL_TIME_MICROSEC   (80)

#define DHT11_DATA_START_LOW_BIT_WAIT_TIME                  (50)
#define DHT11_DATA_FOLLOW_HIGH_BIT_WAIT_TIME                (70)

/**
 * @brief   Run sequence to read the data from sensor, DHT11.
 *          A sequence run in this method is on the data sheet.
 * @return  Returns true if the sequence finished succesfully, otherwise
 *          retunrs none 0 value.
 */
int CDHT11::readSequence() {

    CGpio* gpio = CGpio::getInstance();
    uint32_t cycleBuff[80] = { 0 };

    //Sending start signal.
    //Step1:Sending start signals.
    gpio->SetMode(this->m_pin, CGpio::CGPIO_PIN_IN_OUT_OUTPUT);
    gpio->SetPullUpDownMode(this->m_pin, CGpio::CGPIO_PULL_UP_DOWN_OFF);
    gpio->Write(this->m_pin, CGpio::CGPIO_PIN_LEVEL_LOW);
    gpio->DelayMilli(DHT11_START_SIGNAL_LOW_TIME_MILLISEC);

    //Step2:Waiting for response signal by setting GPIO pin pulled up.
    gpio->SetMode(this->m_pin, CGpio::CGPIO_PIN_IN_OUT_INPUT);
    gpio->SetPullUpDownMode(this->m_pin, CGpio::CGPIO_PULL_UP_DOWN_UP);

    this->waitForPulse(CGpio::CGPIO_PIN_LEVEL_LOW,
            MILLI2MICRO_SEC(DHT11_START_SIGNAL_HIGH_TIME_MILLISEC));
    if (WAIT_SIGNAL_TIMEOUT == this->waitForPulse(
            CGpio::CGPIO_PIN_LEVEL_HIGH,
            DHT11_START_SIGNAL_HIGH_TIME_MILLISEC))
    {
        CLog::Warn("Response to pulled up signal can not be detected.");
        return CDHT11_ERROR_PULLED_UP_TIMEOUT;
    }

    /*
     * Step3:Waiting for response signal sensor send to notify host,
     * raspberry-pi, to ready to output data.
     */
    uint32_t startSignalWaitTime_Low = this->waitForPulse(
            CGpio::CGPIO_PIN_LEVEL_LOW,
            DHT11_SENSOR_READY_TO_OUTPUT_SIGNAL_TIME_MICROSEC);
    if (WAIT_SIGNAL_TIMEOUT == startSignalWaitTime_Low)
    {
        CLog::Warn("Response to start signal of low can not be detected.");
        return CDHT11_ERROR_SENSOR_PULL_LOW_TIMEOUT;
    }
    uint32_t startSignalWaitTime_high = this->waitForPulse(
            CGpio::CGPIO_PIN_LEVEL_HIGH,
            DHT11_SENSOR_READY_TO_OUTPUT_SIGNAL_TIME_MICROSEC);
    if (WAIT_SIGNAL_TIMEOUT == startSignalWaitTime_high)
    {
        CLog::Warn("Response to start signal of high can not be detected.");
        return CDHT11_ERROR_SENSOR_PULL_HIGH_TIMEOUT;
    }

    //Step4:Read signal sensor sends.
    for (int buffIndex = 0; buffIndex < 40; buffIndex++) {
        cycleBuff[buffIndex * 2] = this->waitForPulse(
                (const unsigned int)CGpio::CGPIO_PIN_LEVEL_LOW,
                (const unsigned int)DHT11_DATA_START_LOW_BIT_WAIT_TIME);
        cycleBuff[(buffIndex * 2) + 1] = this->waitForPulse(
                (const unsigned int)CGpio::CGPIO_PIN_LEVEL_HIGH,
                (const unsigned int)DHT11_DATA_FOLLOW_HIGH_BIT_WAIT_TIME);
    }
//  for (int buffIndex = 0; buffIndex < 40; buffIndex++) {
//      printf("cycleBuff[%2d] = %7d, cycleBuff[%2d] = %7d\n",
//              buffIndex * 2,
//              cycleBuff[buffIndex * 2],
//              (buffIndex * 2) + 1,
//              cycleBuff[(buffIndex * 2) + 1]);
//  }

    //Step5:Convert Low-High time to bit data.
    this->InitDataBuff();
    for (int index = 0; index < 40; index++) {
        uint32_t startBit = cycleBuff[index * 2];
        uint32_t followBit = cycleBuff[index * 2 + 1];
        if ((CDHT11::WAIT_SIGNAL_TIMEOUT == startBit) ||
            (CDHT11::WAIT_SIGNAL_TIMEOUT == followBit))
        {
            CLog::Warn("Reading data failed.");
            return CDHT11_ERROR_SENSOR_READ_DATA_TIMEOUT;;
        }

        this->m_dataBuff[index / 8] <<= 1;
        if (startBit < followBit) {
            this->m_dataBuff[index / 8] |= 1;
        }
    }
//  this->ShowBuff();

    if (false == this->validateCheckSum()) {
        CLog::Error("Receive data invalid.");
        return CDHT11_ERROR_SENSOR_READ_DATA_INVALID;
    } else {
        CLog::Debug("Receive data valid.");
        return CDHT11_ERROR_OK;
    }
}

/**
 * Wait while the pin level is kept.
 *
 * @param   level   The pin level to wait while.
 * @param   time    Max time to wait for, specified by micro seconds.
 * @return  Returns wait time. If timeout occurred, returns 0xFFFFFFFF, meaning
 *          -1.
 */
uint32_t CDHT11::waitForPulse(
        const unsigned int level,
        const unsigned int time)
{
    CGpio* instance = CGpio::getInstance();

    unsigned int readLevel = 0;
    instance->Read(this->m_pin, &readLevel);

    uint32_t passedTime = 0;
    while (level == readLevel) {
        if ((time) < passedTime) {
            //Time out!
            return CDHT11::WAIT_SIGNAL_TIMEOUT;
        }
        instance->Read(this->m_pin, &readLevel);
        passedTime += instance->DelayMicro(1);
    }
    //CLog::Debug("Wait for sensor start signal : OK");
    return passedTime;
}