unit_PbHub.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_HUB_UNIT_PBHUB_HPP
#define M5_UNIT_HUB_UNIT_PBHUB_HPP
 
#include <M5UnitComponent.hpp>
#include <array>
 
class TwoWire;
 
namespace m5 {
namespace unit {
 
namespace pbhub {
 
enum class LEDMode : uint8_t {
    WS28xx,  
    SK6822,  
    Unknown = 0xFF,
};
 
}  // namespace pbhub
 
class UnitPbHub : public Component {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitPbHub, 0x61);
 
public:
    constexpr static uint8_t MAX_CHANNEL{6};     
    constexpr static uint8_t MAX_LED_COUNT{74};  
 
    explicit UnitPbHub(const uint8_t addr = DEFAULT_ADDRESS);
    virtual ~UnitPbHub() = default;
 
    virtual bool begin() override;
 
    inline uint8_t firmwareVersion() const
    {
        return _ver;
    }
 
 
    inline bool writeDigital0(const uint8_t ch, const bool high)
    {
        return write_digital(ch, 0, high);
    }
    inline bool writeDigital1(const uint8_t ch, const bool high)
    {
        return write_digital(ch, 1, high);
    }
    inline bool readDigital0(bool& high, const uint8_t ch)
    {
        return read_digital(ch, 0, high);
    }
    inline bool readDigital1(bool& high, const uint8_t ch)
    {
        return read_digital(ch, 1, high);
    }
 
 
    inline bool writeAnalog0(const uint8_t ch, const uint8_t val)
    {
        return write_analog(ch, 0, val);
    }
    inline bool writeAnalog1(const uint8_t ch, const uint8_t val)
    {
        return write_analog(ch, 1, val);
    }
 
 
    bool readAnalog0(uint16_t& val, const uint8_t ch);
 
 
    inline bool writePWM0(const uint8_t ch, const uint8_t pwm)
    {
        return write_pwm(ch, 0, pwm);
    }
    inline bool writePWM1(const uint8_t ch, const uint8_t pwm)
    {
        return write_pwm(ch, 1, pwm);
    }
    inline bool readPWM0(uint8_t& pwm, const uint8_t ch)
    {
        return read_pwm(ch, 0, pwm);
    }
    inline bool readPWM1(uint8_t& pwm, const uint8_t ch)
    {
        return read_pwm(ch, 1, pwm);
    }
 
 
    bool writeLEDCount(const uint8_t ch, const uint16_t num);
    bool writeLEDColor(const uint8_t ch, const uint16_t index, const uint32_t rgb888);
    bool fillLEDColor(const uint8_t ch, const uint32_t rgb888, const uint16_t first = 0, const uint16_t count = 0);
    bool writeLEDBrightness(const uint8_t ch, const uint8_t value);
    bool writeLEDMode(const pbhub::LEDMode m);
    bool readLEDMode(pbhub::LEDMode& m);
 
 
    inline bool writeServo0Angle(const uint8_t ch, const uint8_t angle)
    {
        return write_servo_angle(ch, 0, angle);
    }
    inline bool writeServo1Angle(const uint8_t ch, const uint8_t angle)
    {
        return write_servo_angle(ch, 1, angle);
    }
    inline bool writeServo0Pulse(const uint8_t ch, const uint16_t pulse)
    {
        return write_servo_pulse(ch, 0, pulse);
    }
    inline bool writeServo1Pulse(const uint8_t ch, const uint16_t pulse)
    {
        return write_servo_pulse(ch, 1, pulse);
    }
    inline bool readServo0Angle(uint8_t& angle, const uint8_t ch)
    {
        return read_servo_angle(ch, 0, angle);
    }
    inline bool readServo1Angle(uint8_t& angle, const uint8_t ch)
    {
        return read_servo_angle(ch, 1, angle);
    }
    inline bool readServo0Pulse(uint16_t& pulse, const uint8_t ch)
    {
        return read_servo_pulse(ch, 0, pulse);
    }
    inline bool readServo1Pulse(uint16_t& pulse, const uint8_t ch)
    {
        return read_servo_pulse(ch, 1, pulse);
    }
 
    bool readFirmwareVersion(uint8_t& ver);
 
    bool changeI2CAddress(const uint8_t addr);
 
protected:
    virtual std::shared_ptr<Adapter> ensure_adapter(const uint8_t ch) override;
 
    bool write_digital(const uint8_t ch, const uint8_t index, const bool high);
    bool read_digital(const uint8_t ch, const uint8_t index, bool& high);
    bool write_analog(const uint8_t ch, const uint8_t index, const uint8_t val);
    bool write_pwm(const uint8_t ch, const uint8_t index, const uint8_t val);
    bool read_pwm(const uint8_t ch, const uint8_t index, uint8_t& val);
    bool write_servo_angle(const uint8_t ch, const uint8_t index, const uint8_t angle);
    bool read_servo_angle(const uint8_t ch, const uint8_t index, uint8_t& angle);
    bool write_servo_pulse(const uint8_t ch, const uint8_t index, const uint16_t pulse);
    bool read_servo_pulse(const uint8_t ch, const uint8_t index, uint16_t& pulse);
    void wait_led_output(const uint16_t num_leds) const;
 
    inline bool is_firmware_2_or_later() const
    {
        return (_ver != 0xFF) && (_ver >= 2);
    }
    inline bool is_pbhub() const
    {
        return (_ver != 0xFF) && (_ver == 0);
    }
    inline bool is_pbhub_v11() const
    {
        return (_ver != 0xFF) && _ver;
    }
 
private:
    std::array<uint16_t, +MAX_CHANNEL> _numLED{74, 74, 74, 74, 74, 74};
    uint8_t _ver{0xFF};
};
 
namespace pbhub {
namespace command {
constexpr uint8_t WRITE_DIGITAL_0_REG{0x00};
constexpr uint8_t WRITE_DIGITAL_1_REG{0x01};
 
constexpr uint8_t PWM_0_REG{0x02};  // v1.1
constexpr uint8_t PWM_1_REG{0x03};  // v1.1
constexpr uint8_t WRITE_ANALOG_0_REG{0x02};
constexpr uint8_t WRITE_ANALOG_1_REG{0x03};
 
constexpr uint8_t READ_DIGITAL_0_REG{0x04};
constexpr uint8_t READ_DIGITAL_1_REG{0x05};
constexpr uint8_t READ_ANALOG_0_REG{0x06};
// reserved
constexpr uint8_t LED_NUM_REG{0x08};
constexpr uint8_t LED_COLOR_SINGLE_REG{0x09};
constexpr uint8_t LED_COLOR_MORE_REG{0x0A};
constexpr uint8_t LED_BRIGHTNESS_REG{0x0B};
 
constexpr uint8_t SERVO_ANGLE_0_REG{0x0C};  // v1.1
constexpr uint8_t SERVO_ANGLE_1_REG{0x0D};  // v1.1
constexpr uint8_t SERVO_PULSE_0_REG{0x0E};  // v1.1
constexpr uint8_t SERVO_PULSE_1_REG{0x0F};  // v1.1
 
constexpr uint8_t LED_MODE_REG{0xFA};          // v1.1 FW V2
constexpr uint8_t FIRMWARE_VERSION_REG{0xFE};  // v1.1
constexpr uint8_t I2C_ADDRESS_REG{0xFF};       // v1.1
}  // namespace command
}  // namespace pbhub
 
}  // namespace unit
}  // namespace m5
#endif