unit_IR.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2026 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_INFRARED_UNIT_IR_HPP
#define M5_UNIT_INFRARED_UNIT_IR_HPP
 
#include <M5UnitComponent.hpp>
#include "ir/auto_detect_codec.hpp"
 
namespace m5 {
namespace unit {
 
class UnitIR : public Component {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitIR, 0x00);
 
public:
    struct config_t {
        uint32_t tick_ns{1000};
        uint16_t rx_ring_buffer_size{1024};
        uint16_t rx_idle_threshold{20000};
        uint16_t rx_filter_threshold{200};
        uint8_t rx_min_item_count{2};
        bool rx_invert_level{true};
    };
 
    UnitIR() : Component(0x00)
    {
    }
 
    config_t config() const
    {
        return _cfg;
    }
    void config(const config_t& cfg)
    {
        _cfg = cfg;
    }
 
    bool begin() override;
    void update(const bool force = false) override;
 
 
    ir::IRCodec& codec()
    {
        return *_codec;
    }
    void setCodec(ir::IRCodec& codec)
    {
        _codec = &codec;
    }
    void resetCodec()
    {
        _codec = &_default_codec;
    }
    ir::AutoDetectCodec& defaultCodec()
    {
        return _default_codec;
    }
 
 
    bool send(uint16_t address, uint16_t command, uint8_t frames = 0);
 
    bool sendRaw(const gpio::m5_rmt_item_t* items, uint32_t num);
 
 
    size_t available() const
    {
        return _rx_available ? 1 : 0;
    }
    bool empty() const
    {
        return !_rx_available;
    }
    const ir::DecodeResult& latest() const
    {
        return _latest_result;
    }
    void flush();
    const gpio::m5_rmt_item_t* rawItems() const
    {
        return _raw_items;
    }
    uint32_t rawItemCount() const
    {
        return _raw_item_count;
    }
 
 
    bool hasTX() const
    {
        return _has_tx;
    }
    bool hasRX() const
    {
        return _has_rx;
    }
 
private:
    bool read_rx();
    bool apply_carrier();
 
    ir::AutoDetectCodec _default_codec{};
    ir::IRCodec* _codec{&_default_codec};
    config_t _cfg{};
    ir::DecodeResult _latest_result{};
    const gpio::m5_rmt_item_t* _raw_items{};
    uint32_t _raw_item_count{};
    bool _rx_available{};
    bool _has_tx{};
    bool _has_rx{};
 
    // RX buffer (4-byte aligned for RMT v2)
    struct FreeDeleter {
        void operator()(uint8_t* p) const
        {
            free(p);
        }
    };
    std::unique_ptr<uint8_t[], FreeDeleter> _rx_buffer{};
    size_t _rx_buffer_size{};
};
 
}  // namespace unit
}  // namespace m5
#endif