unit_DDS.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_DDS_UNIT_DDS_HPP
#define M5_UNIT_DDS_UNIT_DDS_HPP
 
#include <M5UnitComponent.hpp>
 
namespace m5 {
namespace unit {
 
namespace dds {
 
enum class Mode : uint8_t {
    Reserved,  
    Sin,       
    Triangle,  
    Square,    
    Sawtooth,  
    DC,        
};
 
}  // namespace dds
 
class UnitDDS : public Component {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitDDS, 0x31);
 
public:
    struct config_t {
        bool start_output{true};         
        dds::Mode mode{dds::Mode::Sin};  
        bool select{};                   
        uint32_t freq{10000};            
        uint16_t deg{0};                 
    };
 
    explicit UnitDDS(const uint8_t addr = DEFAULT_ADDRESS) : Component(addr)
    {
        auto ccfg  = component_config();
        ccfg.clock = 400 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitDDS()
    {
    }
 
    virtual bool begin() override;
 
 
    inline config_t config()
    {
        return _cfg;
    }
    inline void config(const config_t& cfg)
    {
        _cfg = cfg;
    }
 
    uint32_t frequency0() const
    {
        return _freq[0];
    }
    uint32_t frequency1() const
    {
        return _freq[1];
    }
 
 
    bool readMode(dds::Mode& mode);
    bool writeMode(const dds::Mode mode);
 
 
    bool writeFrequency(const bool select, const uint32_t freq);
    inline bool writeFrequency0(const uint32_t freq)
    {
        return writeFrequency(false, freq);
    }
    inline bool writeFrequency1(const uint32_t freq)
    {
        return writeFrequency(true, freq);
    }
    bool writePhase(const bool select, const uint16_t deg);
    inline bool writePhase0(const uint16_t deg)
    {
        return writePhase(false, deg);
    }
    inline bool writePhase1(const uint16_t deg)
    {
        return writePhase(true, deg);
    }
    bool writeFrequencyAndPhase(const bool select_freq, const uint32_t freq, const bool select_phase,
                                const uint16_t deg);
    bool writeCurrent(const bool select_freq, const bool select_phase);
    bool writeCurrentFrequency(const bool select);
    bool writeCurrentPhase(const bool select);
 
 
    bool writeOutput(const dds::Mode mode, const bool select, const uint32_t freq, const uint16_t deg);
    bool sleep(const bool mclk = true, const bool DAC = true);
    bool wakeup();
    bool reset();
 
    bool readDescription(char str[7]);
 
protected:
    bool read_control(uint8_t& ctrl);
    bool write_register8(const uint8_t reg, const uint8_t v);
 
private:
    config_t _cfg{};
    dds::Mode _mode{};
    uint32_t _freq[2]{};
};
 
namespace dds {
namespace command {
constexpr uint8_t READ_DESCRIPTION_REG{0x10};
constexpr uint8_t MODE_REG{0x20};
constexpr uint8_t CONTROL_REG{0x21};
constexpr uint8_t FREQUENCY_REG{0x30};
constexpr uint8_t PHASE_REG{0x34};
}  // namespace command
}  // namespace dds
 
}  // namespace unit
}  // namespace m5
#endif