IOControl/include/IO/Controller.h

Go to the documentation of this file.

 
#pragma once
 
#include "Device.h"
#include <WVector.h>
 
namespace IO
{
using DeviceFactoryList = Vector<const Device::Factory*>;
 
enum class Direction {
    Incoming,
    Outgoing,
    Idle,
};
 
class Controller : public LinkedObjectTemplate<Controller>
{
    friend class Device;
    friend class DeviceManager;
 
public:
    using List = LinkedObjectListTemplate<Controller>;
 
    Controller(uint8_t instance) : instance(instance)
    {
    }
 
    virtual ~Controller() = default;
 
    static void registerDeviceClass(const Device::Factory& factory)
    {
        deviceClasses.addElement(&factory);
        debug_i("Device class '%s' registered", String(factory.deviceClass()).c_str());
    }
 
    uint8_t getInstance() const
    {
        return instance;
    }
 
    Device::OwnedList& getDevices()
    {
        return devices;
    }
 
    void freeDevices();
 
    ErrorCode createDevice(const char* id, JsonObjectConst config, Device*& device);
 
    template <class DeviceClass>
    ErrorCode createDevice(const char* id, const typename DeviceClass::Config& config, DeviceClass*& device);
 
    Device* findDevice(const String& id);
 
    virtual const FlashString& classname() const = 0;
 
    virtual void start()
    {
        startDevices();
    }
 
    virtual void stop()
    {
        stopDevices();
    }
 
    virtual bool canStop() const
    {
        return queue.isEmpty();
    }
 
    const CString& getId() const
    {
        return id;
    }
 
    bool operator==(const String& id) const
    {
        return this->id == id;
    }
 
protected:
    virtual void handleEvent(Request* request, Event event);
 
    void submit(Request* request);
 
    void checkDevices();
 
    void resetTransactionTime()
    {
        lastTransactionEnd.start();
    }
 
private:
    ErrorCode constructDevice(const Device::Factory& factory, const char* id, Device*& device);
 
    void executeNext();
 
    void deviceError(Device& device);
 
    void startDevices();
    void stopDevices();
 
    const Device::Factory* findDeviceClass(const String& className);
 
    Device::OwnedList devices;
    Request::OwnedList queue;
    static DeviceFactoryList deviceClasses;
    OneShotFastMs lastTransactionEnd;
    SimpleTimer timer;
    CString id;
    uint8_t instance;
};
 
template <class DeviceClass>
ErrorCode Controller::createDevice(const char* id, const typename DeviceClass::Config& config, DeviceClass*& device)
{
    auto& factory = DeviceClass::factory;
    Device* dev;
    auto err = constructDevice(factory, id, dev);
    if(err) {
        return err;
    }
 
    device = static_cast<DeviceClass*>(device);
    err = device->init(config);
    if(err) {
        delete device;
        device = nullptr;
        debug_err(err, String(factory.deviceClass()));
        return err;
    }
 
    devices.add(device);
    debug_d("Device %s created, class %s", device->caption().c_str(), String(factory.deviceClass()).c_str());
 
    return err;
}
 
} // namespace IO