dht.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include <idfxx/error>
#include <idfxx/gpio>
 
#include <chrono>
#include <cstdint>
#include <memory>
#include <string>
#include <thermo/thermo>
#include <utility>
 
namespace idfxx::dht {
 
enum class model : uint8_t {
    dht11, 
    dht22, 
};
 
struct reading {
    thermo::millicelsius temperature{0}; 
    float humidity_pct = 0.0f;           
};
 
class sensor {
public:
    struct config {
        idfxx::gpio pin = gpio::nc();    
        enum model model = model::dht22; 
        bool internal_pullup = true;
    };
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] explicit sensor(config config);
#endif
 
    [[nodiscard]] static result<sensor> make(config config);
 
    ~sensor();
 
    sensor(const sensor&) = delete;
    sensor& operator=(const sensor&) = delete;
    sensor(sensor&& other) noexcept;
    sensor& operator=(sensor&& other) noexcept;
 
    [[nodiscard]] idfxx::gpio pin() const noexcept;
 
    [[nodiscard]] enum model model() const noexcept;
 
    [[nodiscard]] std::chrono::milliseconds min_read_interval() const noexcept;
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] reading read() { return unwrap(try_read()); }
#endif
 
    [[nodiscard]] result<reading> try_read();
 
private:
    struct state;
    explicit sensor(std::unique_ptr<state> s) noexcept;
 
    std::unique_ptr<state> _state;
};
 
 
} // namespace idfxx::dht
 
namespace idfxx {
 
[[nodiscard]] inline std::string to_string(dht::model m) {
    switch (m) {
    case dht::model::dht11:
        return "DHT11";
    case dht::model::dht22:
        return "DHT22";
    default:
        return "unknown(" + std::to_string(std::to_underlying(m)) + ')';
    }
}
 
} // namespace idfxx
 
#include "sdkconfig.h"
#ifdef CONFIG_IDFXX_STD_FORMAT
#include <algorithm>
#include <format>
namespace std {
template<>
struct formatter<idfxx::dht::model> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    template<typename FormatContext>
    auto format(idfxx::dht::model m, FormatContext& ctx) const {
        auto s = idfxx::to_string(m);
        return std::copy(s.begin(), s.end(), ctx.out());
    }
};
} // namespace std
#endif // CONFIG_IDFXX_STD_FORMAT