VMXResourceConfig.h

/* ============================================
VMX-pi HAL source code is placed under the MIT license
Copyright (c) 2017 Kauai Labs
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
===============================================
*/

#ifndef VMXRESOURCECONFIG_H_
#define VMXRESOURCECONFIG_H_

#include "VMXResource.h"
#include "VMXHandlers.h"

struct VMXResourceConfig {
    VMXResourceType res_type;
    VMXResourceConfig(VMXResourceType res_type) {
        this->res_type = res_type;
    }
    VMXResourceType GetResourceType() const { return res_type; }
    virtual VMXResourceConfig *GetCopy() const = 0;
    virtual bool Copy(const VMXResourceConfig *p_config) = 0;
    virtual ~VMXResourceConfig() {}
};

struct InterruptConfig : public VMXResourceConfig {

    typedef enum { RISING, FALLING, BOTH } InterruptEdge;

    InterruptEdge edge;
    VMXIO_InterruptHandler p_handler;
    void *p_param;

    InterruptConfig() : VMXResourceConfig(VMXResourceType::Interrupt) {
        edge = InterruptEdge::RISING;
        p_handler = 0;
        p_param = 0;
    }
    InterruptConfig(InterruptEdge edge, VMXIO_InterruptHandler p_handler, void *p_param) :
        VMXResourceConfig(VMXResourceType::Interrupt) {
        this->edge = edge;
        this->p_handler = p_handler;
        this->p_param = p_param;
    }

    VMXIO_InterruptHandler GetHandler() { return p_handler; }
    void * GetParam() { return p_param; }
    InterruptEdge GetEdge() { return edge; }

    void SetHandler(VMXIO_InterruptHandler p_handler) { this->p_handler = p_handler; }
    void SetParam(void *p_param) { this->p_param = p_param; }
    void SetEdge(InterruptEdge edge) { this->edge = edge; }

    virtual VMXResourceConfig *GetCopy() const {
        InterruptConfig *p_new = new InterruptConfig();
        *p_new = *this;
        return p_new;
    }
    virtual bool Copy(const VMXResourceConfig *p_config) {
        if (p_config->GetResourceType() != this->GetResourceType()) return false;
        *this = *((InterruptConfig *)p_config);
        return true;
    }

    virtual ~InterruptConfig() {}
};

struct DIOConfig : public VMXResourceConfig {
    typedef enum { PUSHPULL, OPENDRAIN } OutputMode;
    typedef enum { PULLUP, PULLDOWN, NONE } InputMode;

    /* NOTE:  Certain DIOs may be input-only or output-only at the hardware level. */
    /* Therefore it's possible this configuration may fail if an incompatible state is requested. */
    bool input;
    OutputMode outputmode; /* Not all DIO (e.g., rpi) channels can support !pushpull (opendrain) */
    InputMode inputmode;

    DIOConfig() : VMXResourceConfig(VMXResourceType::DigitalIO) {
        input = true;
        outputmode = OutputMode::PUSHPULL;
        inputmode = InputMode::PULLUP;
    }
    DIOConfig(InputMode inputmode) :
        VMXResourceConfig(VMXResourceType::DigitalIO) {
        this->input = true;
        this->inputmode = inputmode;
        this->outputmode = OutputMode::PUSHPULL;
    }
    DIOConfig(OutputMode outputmode) :
        VMXResourceConfig(VMXResourceType::DigitalIO) {
        this->input = false;
        this->inputmode = InputMode::NONE;
        this->outputmode = outputmode;
    }

    bool GetInput() { return input; }
    OutputMode GetOutputMode() { return outputmode; }
    InputMode GetInputMode() { return inputmode; }

    void SetInput(bool input) { this->input = input; }
    void SetInputMode(InputMode inputmode) { this->inputmode = inputmode; }
    void SetOutputMode(OutputMode outputmode) { this->outputmode = outputmode; }

    virtual VMXResourceConfig *GetCopy() const {
        DIOConfig *p_new = new DIOConfig();
        *p_new = *this;
        return p_new;
    }
    virtual bool Copy(const VMXResourceConfig *p_config) {
        if (p_config->GetResourceType() != this->GetResourceType()) return false;
        *this = *((DIOConfig *)p_config);
        return true;
    }
    virtual ~DIOConfig() {}
};

struct PWMGeneratorConfig : public VMXResourceConfig {
    uint32_t frequency_hz;

    PWMGeneratorConfig() : VMXResourceConfig(VMXResourceType::PWMGenerator) {
        frequency_hz = 200;
    }
    PWMGeneratorConfig(uint32_t frequency_hz) : VMXResourceConfig(VMXResourceType::PWMGenerator) {
        this->frequency_hz = frequency_hz;
    }

    uint32_t GetFrequencyHz() { return frequency_hz; }

    void SetFrequencyHz(uint32_t frequency_hz) { this->frequency_hz = frequency_hz; }

    virtual VMXResourceConfig *GetCopy() const {
        PWMGeneratorConfig *p_new = new PWMGeneratorConfig();
        *p_new = *this;
        return p_new;
    }
    virtual bool Copy(const VMXResourceConfig *p_config) {
        if (p_config->GetResourceType() != this->GetResourceType()) return false;
        *this = *((PWMGeneratorConfig *)p_config);
        return true;
    }
    virtual ~PWMGeneratorConfig() {}
};

struct PWMCaptureConfig : public VMXResourceConfig {
    typedef enum { RISING, FALLING } CaptureEdge;
    CaptureEdge edge_type;

    PWMCaptureConfig() : VMXResourceConfig(VMXResourceType::PWMCapture) {
        edge_type = CaptureEdge::RISING;
    }
    PWMCaptureConfig(CaptureEdge edge_type) : VMXResourceConfig(VMXResourceType::PWMCapture) {
        this->edge_type = edge_type;
    }

    CaptureEdge GetCaptureEdge() { return edge_type; }

    void SetCaptureEdge(CaptureEdge edge) { this->edge_type = edge; }

    virtual VMXResourceConfig *GetCopy() const {
        PWMCaptureConfig *p_new = new PWMCaptureConfig();
        *p_new = *this;
        return p_new;
    }
    virtual bool Copy(const VMXResourceConfig *p_config) {
        if (p_config->GetResourceType() != this->GetResourceType()) return false;
        *this = *((PWMCaptureConfig *)p_config);
        return true;
    }
    virtual ~PWMCaptureConfig() {}
};

struct EncoderConfig : public VMXResourceConfig {
    typedef enum { x1, x2, x4 } EncoderEdge;
    EncoderEdge edge_count;

    EncoderConfig() : VMXResourceConfig(VMXResourceType::Encoder) {
        edge_count = EncoderEdge::x4;
    }
    EncoderConfig(EncoderEdge edge) : VMXResourceConfig(VMXResourceType::Encoder) {
        edge_count = edge;
    }

    EncoderEdge GetEncoderEdge() { return edge_count; }

    void SetEncoderEdge(EncoderEdge edge) { this->edge_count = edge; }

    virtual VMXResourceConfig *GetCopy() const {
        EncoderConfig *p_new = new EncoderConfig();
        *p_new = *this;
        return p_new;
    }
    virtual bool Copy(const VMXResourceConfig *p_config) {
        if (p_config->GetResourceType() != this->GetResourceType()) return false;
        *this = *((EncoderConfig *)p_config);
        return true;
    }
    virtual ~EncoderConfig() {}
};

struct AccumulatorConfig : public VMXResourceConfig {
    uint8_t num_average_bits;
    uint8_t num_oversample_bits;

    AccumulatorConfig() : VMXResourceConfig(VMXResourceType::Accumulator) {
        num_oversample_bits = 3;
        num_average_bits = 3;
    }
    AccumulatorConfig(uint8_t num_oversample_bits, uint8_t num_average_bits) :
        VMXResourceConfig(VMXResourceType::Accumulator) {
        this->num_oversample_bits = num_oversample_bits;
        this->num_average_bits = num_average_bits;
    }

    uint8_t GetNumAverageBits() { return num_average_bits; }
    /* For more information on oversampling, see <a href="https://en.wikipedia.org/wiki/Oversampling">this Wikipedia article</a> */
    uint8_t GetNumOversampleBits() { return num_oversample_bits; }

    void SetNumAverageBits(uint8_t num_average_bits) { this->num_average_bits = num_average_bits; }
    void SetNumOversampleBits(uint8_t num_oversample_bits) { this->num_oversample_bits = num_oversample_bits; }

    virtual VMXResourceConfig *GetCopy() const {
        AccumulatorConfig *p_new = new AccumulatorConfig();
        *p_new = *this;
        return p_new;
    }
    virtual bool Copy(const VMXResourceConfig *p_config) {
        if (p_config->GetResourceType() != this->GetResourceType()) return false;
        *this = *((AccumulatorConfig *)p_config);
        return true;
    }
    virtual ~AccumulatorConfig() {}
};

struct AnalogTriggerConfig : public VMXResourceConfig {
    typedef enum {
        STATE,
        RISING_EDGE_PULSE,
        FALLING_EDGE_PULSE
    } AnalogTriggerMode;

    uint16_t threshold_high; /* 12-bit value (0-4095) */
    uint16_t threshold_low;  /* 12-bit value (0-4095) */
    AnalogTriggerMode mode;

    AnalogTriggerConfig() : VMXResourceConfig(VMXResourceType::AnalogTrigger) {
        threshold_high = 992; /* .8V on a 3.3V scale */
        threshold_low = 2482; /* 2V on a 3.3V scale */
        mode = AnalogTriggerMode::STATE;
    }
    AnalogTriggerConfig(uint16_t threshold_high, uint16_t threshold_low, AnalogTriggerMode mode) :
        VMXResourceConfig(VMXResourceType::AnalogTrigger) {
        this->threshold_high = threshold_high;
        this->threshold_low = threshold_low;
        this->mode = mode;
    }

    uint16_t GetThresholdHigh() { return threshold_high; }
    uint16_t GetThresholdLow() { return threshold_low; }
    AnalogTriggerMode GetMode() { return mode; }

    void SetThresholdHigh(uint16_t threshold_high) { this->threshold_high = threshold_high; }
    void SetThresholdLow(uint16_t threshold_low) { this->threshold_low = threshold_low; }
    void SetMode(AnalogTriggerMode mode) { this->mode = mode; }

    virtual VMXResourceConfig *GetCopy() const {
        AnalogTriggerConfig *p_new = new AnalogTriggerConfig();
        *p_new = *this;
        return p_new;
    }
    virtual bool Copy(const VMXResourceConfig *p_config) {
        if (p_config->GetResourceType() != this->GetResourceType()) return false;
        *this = *((AnalogTriggerConfig *)p_config);
        return true;
    }
    virtual ~AnalogTriggerConfig() {}
};

struct UARTConfig : public VMXResourceConfig {
    uint32_t baudrate_bps;

    UARTConfig() : VMXResourceConfig(VMXResourceType::UART) {
        baudrate_bps = 57600;
    }
    UARTConfig(uint32_t baudrate_bps) : VMXResourceConfig(VMXResourceType::UART) {
        this->baudrate_bps = baudrate_bps;
    }

    uint32_t GetBaudrate() { return baudrate_bps; }

    void SetBaudrate(uint32_t baudrate_bps) { this->baudrate_bps = baudrate_bps; }

    virtual VMXResourceConfig *GetCopy() const {
        UARTConfig *p_new = new UARTConfig();
        *p_new = *this;
        return p_new;
    }
    virtual bool Copy(const VMXResourceConfig *p_config) {
        if (p_config->GetResourceType() != this->GetResourceType()) return false;
        *this = *((UARTConfig *)p_config);
        return true;
    }
    virtual ~UARTConfig() {}
};

struct SPIConfig : public VMXResourceConfig {
    uint32_t bitrate_bps;
    uint8_t mode; /* Range:  0-3 */
    bool cs_active_low;
    bool msbfirst;

    SPIConfig() : VMXResourceConfig(VMXResourceType::SPI) {
        bitrate_bps = 1000000;
        mode = 3;
        cs_active_low = true;
        msbfirst = true;
    }
    SPIConfig(uint32_t bitrate) : VMXResourceConfig(VMXResourceType::SPI) {
        bitrate_bps = bitrate;
        mode = 3;
        cs_active_low = true;
        msbfirst = true;
    }
    SPIConfig(uint32_t bitrate, uint8_t mode, bool cs_active_low, bool msbfirst) :
        VMXResourceConfig(VMXResourceType::SPI)
    {
        this->bitrate_bps = bitrate;
        this->mode = mode;
        this->cs_active_low = cs_active_low;
        this->msbfirst = msbfirst;
    }

    uint32_t GetBitrate() { return bitrate_bps; }
    uint8_t GetMode() { return mode; }
    bool GetCSActiveLow() { return cs_active_low; }
    bool GetMSBFirst() { return msbfirst; }

    void SetBitrate(uint32_t bitrate) { this->bitrate_bps = bitrate; }
    void SetMode(uint8_t mode) { this->mode = mode % 4; }
    void SetCSActiveLow(bool cs_active_low) { this->cs_active_low = cs_active_low; }
    void SetMSBFirst(bool msbfirst) { this->msbfirst = msbfirst; }

    virtual VMXResourceConfig *GetCopy() const {
        SPIConfig *p_new = new SPIConfig();
        *p_new = *this;
        return p_new;
    }
    virtual bool Copy(const VMXResourceConfig *p_config) {
        if (p_config->GetResourceType() != this->GetResourceType()) return false;
        *this = *((SPIConfig *)p_config);
        return true;
    }
    virtual ~SPIConfig() {}
};

struct I2CConfig : public VMXResourceConfig {
    I2CConfig() : VMXResourceConfig(VMXResourceType::I2C) {}

    virtual VMXResourceConfig *GetCopy() const {
        I2CConfig *p_new = new I2CConfig();
        *p_new = *this;
        return p_new;
    }
    virtual bool Copy(const VMXResourceConfig *p_config) {
        if (p_config->GetResourceType() != this->GetResourceType()) return false;
        *this = *((I2CConfig *)p_config);
        return true;
    }
    virtual ~I2CConfig() {}
};

#endif /* VMXRESOURCECONFIG_H_ */