Libraries/IOControl/include/IO/DMX512/Device.h

Go to the documentation of this file.

#pragma once

#include "../RS485/Device.h"
#include <Data/Range.h>

namespace IO
{
namespace DMX512
{
class Request;

struct NodeData {
    enum class State {
        disabled,
        enabling,
        enabled,
        disabling,
    };

    uint8_t target;
    uint8_t value;
    State state;

    bool changed() const
    {
        return (state == State::enabling) || (state == State::disabling) || (target != value);
    }

    void enable()
    {
        if(state != State::enabled) {
            state = State::enabling;
        }
    }

    void disable()
    {
        if(state != State::disabled) {
            state = State::disabling;
        }
    }

    void setTarget(int newTarget)
    {
        target = TRange(0, 0xff).clip(newTarget);
    }

    void setValue(uint8_t newValue)
    {
        value = newValue;
        target = value;
        state = newValue ? State::enabling : State::disabling;
    }

    bool adjust()
    {
        if(state == State::disabled) {
            return false;
        }

        uint8_t adjustTarget = (state == State::disabling) ? 0 : target;

        if(value == adjustTarget) {
            if(state == State::disabling) {
                state = State::disabled;
            } else if(state == State::enabling) {
                state = State::enabled;
            }
            return false;
        }

        int step = (state == State::enabled) ? 1 : 4;
        int newValue = value + ((value < adjustTarget) ? step : -step);
        value = TRange(0, 0xff).clip(newValue);
        return true;
    }
};

class Device : public RS485::Device
{
    friend Request;

public:
    class Factory : public IO::Device::Factory
    {
    public:
        IO::Device* createDevice(IO::Controller& controller, const char* id) const override
        {
            return new Device(reinterpret_cast<RS485::Controller&>(controller), id);
        }

        const FlashString& controllerClass() const override
        {
            return RS485::CONTROLLER_CLASSNAME;
        }

        const FlashString& deviceClass() const override
        {
            DEFINE_FSTR_LOCAL(DEVICE_CLASSNAME, "dmx")
            return DEVICE_CLASSNAME;
        }
    };

    static const Factory factory;

    static constexpr size_t MaxPacketSize{520};

    struct Config {
        IO::RS485::Device::Config rs485; 

        uint8_t nodeCount;
    };

    using IO::RS485::Device::Device;

    const DeviceType type() const override
    {
        return DeviceType::DMX512;
    }

    ErrorCode init(const Config& config);
    ErrorCode init(JsonObjectConst config) override;

    IO::Request* createRequest() override;

    DevNode::ID nodeIdMax() const override
    {
        return nodeCount - 1;
    }

    uint16_t maxNodes() const override
    {
        return nodeCount;
    }

    const NodeData& getNodeData(uint8_t nodeId) const
    {
        assert(nodeId < nodeCount);
        return nodeData[nodeId];
    }

    bool isValid(DevNode node) const
    {
        return node == DevNode_ALL || node.id < nodeCount;
    }

    void handleEvent(IO::Request* request, Event event) override;

protected:
    void parseJson(JsonObjectConst json, Config& cfg);

    ErrorCode start() override
    {
        return Error::success;
    }

    bool update();

    void updateSlaves();

    ErrorCode execute(Request& request);

private:
    uint8_t nodeCount{1};                 
    std::unique_ptr<NodeData[]> nodeData; 
    static SimpleTimer timer;             
    static bool dataChanged;              
    static bool updating;                 
};

} // namespace DMX512
} // namespace IO