onewire.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 <cstdint>
#include <memory>
#include <mutex>
#include <span>
#include <string>
#include <vector>
 
namespace idfxx::onewire {
 
class address {
public:
    constexpr address() = default;
 
    constexpr explicit address(uint64_t raw)
        : _raw(raw) {}
 
    [[nodiscard]] static constexpr address any() { return address{}; }
 
    [[nodiscard]] static constexpr address none() { return address{0xFFFFFFFFFFFFFFFF}; }
 
    [[nodiscard]] constexpr uint64_t raw() const { return _raw; }
 
    [[nodiscard]] constexpr uint8_t family() const { return static_cast<uint8_t>(_raw & 0xFF); }
 
    [[nodiscard]] constexpr bool operator==(const address&) const noexcept = default;
 
    [[nodiscard]] constexpr auto operator<=>(const address&) const noexcept = default;
 
private:
    uint64_t _raw = 0;
};
 
class bus;
 
// -- CRC utilities -----------------------------------------------------------
 
[[nodiscard]] uint8_t crc8(std::span<const uint8_t> data);
 
[[nodiscard]] uint16_t crc16(std::span<const uint8_t> data, uint16_t crc_iv = 0);
 
[[nodiscard]] bool
check_crc16(std::span<const uint8_t> data, std::span<const uint8_t, 2> inverted_crc, uint16_t crc_iv = 0);
 
// -- bus ---------------------------------------------------------------------
 
class bus {
public:
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] explicit bus(gpio pin);
#endif
 
    [[nodiscard]] static result<bus> make(gpio pin);
 
    ~bus() = default;
 
    bus(const bus&) = delete;
    bus& operator=(const bus&) = delete;
    bus(bus&& other) noexcept = default;
    bus& operator=(bus&& other) noexcept = default;
 
    void lock() const {
        if (!_mux) {
            return;
        }
        _mux->lock();
    }
 
    [[nodiscard]] bool try_lock() const noexcept {
        if (!_mux) {
            return false;
        }
        return _mux->try_lock();
    }
 
    void unlock() const {
        if (!_mux) {
            return;
        }
        _mux->unlock();
    }
 
    [[nodiscard]] gpio pin() const noexcept { return _pin; }
 
    // -- Bus reset -----------------------------------------------------------
 
    [[nodiscard]] bool reset();
 
    // -- ROM commands --------------------------------------------------------
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void select(address addr) { unwrap(try_select(addr)); }
 
    void skip_rom() { unwrap(try_skip_rom()); }
#endif
 
    [[nodiscard]] result<void> try_select(address addr);
 
    [[nodiscard]] result<void> try_skip_rom();
 
    // -- Write operations ----------------------------------------------------
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void write(uint8_t value) { unwrap(try_write(value)); }
 
    void write(std::span<const uint8_t> data) { unwrap(try_write(data)); }
#endif
 
    [[nodiscard]] result<void> try_write(uint8_t value);
 
    [[nodiscard]] result<void> try_write(std::span<const uint8_t> data);
 
    // -- Read operations -----------------------------------------------------
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] uint8_t read() { return unwrap(try_read()); }
 
    void read(std::span<uint8_t> buf) { unwrap(try_read(buf)); }
#endif
 
    [[nodiscard]] result<uint8_t> try_read();
 
    [[nodiscard]] result<void> try_read(std::span<uint8_t> buf);
 
    // -- Parasitic power -----------------------------------------------------
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void power() { unwrap(try_power()); }
#endif
 
    [[nodiscard]] result<void> try_power();
 
    void depower() noexcept;
 
    // -- Device search -------------------------------------------------------
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] std::vector<address> search(size_t max_devices = 8) { return unwrap(try_search(max_devices)); }
 
    [[nodiscard]] std::vector<address> search(uint8_t family_code, size_t max_devices = 8) {
        return unwrap(try_search(family_code, max_devices));
    }
#endif
 
    [[nodiscard]] result<std::vector<address>> try_search(size_t max_devices = 8);
 
    [[nodiscard]] result<std::vector<address>> try_search(uint8_t family_code, size_t max_devices = 8);
 
private:
    struct validated {};
    bus(gpio pin, validated)
        : _pin(pin)
        , _mux(std::make_unique<std::recursive_mutex>()) {}
    gpio _pin;
    mutable std::unique_ptr<std::recursive_mutex> _mux;
};
 
 
} // namespace idfxx::onewire
 
namespace idfxx {
 
[[nodiscard]] inline std::string to_string(onewire::address addr) {
    if (addr == onewire::address::any()) {
        return "ONEWIRE_ANY";
    }
    if (addr == onewire::address::none()) {
        return "ONEWIRE_NONE";
    }
    static constexpr char hex[] = "0123456789ABCDEF";
    std::string result;
    result.reserve(23);
    auto raw = addr.raw();
    for (int i = 0; i < 8; ++i) {
        if (i > 0) {
            result += ':';
        }
        auto byte = static_cast<uint8_t>((raw >> (i * 8)) & 0xFF);
        result += hex[byte >> 4];
        result += hex[byte & 0xF];
    }
    return result;
}
 
} // namespace idfxx
 
#include "sdkconfig.h"
#ifdef CONFIG_IDFXX_STD_FORMAT
#include <algorithm>
#include <format>
namespace std {
template<>
struct formatter<idfxx::onewire::address> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    template<typename FormatContext>
    auto format(idfxx::onewire::address addr, FormatContext& ctx) const {
        auto s = idfxx::to_string(addr);
        return std::copy(s.begin(), s.end(), ctx.out());
    }
};
} // namespace std
#endif // CONFIG_IDFXX_STD_FORMAT