VMXIO.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 VMXIO_H_
#define VMXIO_H_

#include "VMXResourceConfig.h"
#include "VMXErrors.h"
#include "VMXTime.h"
#include <unordered_set>
#include <list>

class PIGPIOClient;
class IOCXClient;
class MISCClient;
class VMXChannelManager;
class VMXResourceManager;

class VMXIO_PIGPIOInterruptSink;

class VMXIO {

    friend class VMXPi;

    PIGPIOClient&       pigpio;
    IOCXClient&         iocx;
    MISCClient&         misc;
    VMXChannelManager&  chan_mgr;
    VMXResourceManager& res_mgr;
    VMXTime&            time;
    VMXIO_PIGPIOInterruptSink *p_int_sink;

    bool DisconnectAnalogInputInterrupt(uint8_t analog_trigger_num); /* ????? */

    VMXIO(PIGPIOClient& pigpio, IOCXClient& iocx, MISCClient& misc, VMXChannelManager& chan_mgr, VMXResourceManager& res_mgr, VMXTime& time_ref);
    void ReleaseResources();
    virtual ~VMXIO();

public:

    /*** RESOURCE AND CHANNEL ENUMERATION */
    uint8_t GetNumResourcesByType(VMXResourceType resource_type);
    uint8_t GetNumChannelsByCapability(VMXChannelCapability channel_capability);
    uint8_t GetNumChannelsByType(VMXChannelType channel_type, VMXChannelIndex& first_channel_index);
    bool GetChannelCapabilities(VMXChannelIndex channel_index, VMXChannelType& channel_type, VMXChannelCapability& capability_bits);
    bool ChannelSupportsCapability(VMXChannelIndex channel_index, VMXChannelCapability capability);

    /*** RESOURCE HANDLE ACQUISITION */
    bool GetResourceHandle(VMXResourceType resource_type, VMXResourceIndex res_index, VMXResourceHandle& resource_handle, VMXErrorCode *errcode = 0);
    bool GetResourcesCompatibleWithChannelAndCapability(VMXChannelIndex channel_index, VMXChannelCapability capability, std::list<VMXResourceHandle>& compatible_res_handles);
    bool GetUnallocatedResourcesCompatibleWithChannelAndCapability(VMXChannelIndex channel_index, VMXChannelCapability capability, std::list<VMXResourceHandle>& unallocated_compatible_res_handles);
    bool GetChannelsCompatibleWithResource(VMXResourceHandle resource_handle, VMXChannelIndex& first_channel_index, uint8_t& num_channels);

    /*** RESOURCE ALLOCATION ***/

    bool IsResourceAllocated(VMXResourceHandle resource, bool& allocated, bool& is_shared, VMXErrorCode *errcode = 0);
    bool AllocateResource(VMXResourceHandle resource, VMXErrorCode* errcode = 0);
    bool DeallocateResource(VMXResourceHandle resource, VMXErrorCode *errcode = 0);
    bool DeallocateAllResources(VMXErrorCode *last_errorcode = 0);

    /*** RESOURCE-CHANNEL ROUTING ***/

    bool RouteChannelToResource(VMXChannelIndex channel, VMXResourceHandle resource, VMXErrorCode* errcode = 0);
    bool UnrouteChannelFromResource(VMXChannelIndex channel, VMXResourceHandle resource, VMXErrorCode *errcode = 0);
    bool UnrouteAllChannelsFromResource(VMXResourceHandle resource, VMXErrorCode *errcode = 0);

    /*** RESOURCE CONFIGURATION (see VMXResourceConfig.h for various configuration classes) ***/

    bool SetResourceConfig(VMXResourceHandle resource, const VMXResourceConfig* p_config, VMXErrorCode *errcode = 0);
    bool GetResourceConfig(VMXResourceHandle resource, VMXResourceConfig*& p_config, VMXErrorCode *errcode = 0);
    bool GetResourceDefaultConfig(VMXResourceHandle resource, VMXResourceConfig*& p_config, VMXErrorCode *errcode = 0);

    /*** RESOURCE ACTIVATION ***/

    bool IsResourceActive(VMXResourceHandle, bool &active, VMXErrorCode* errcode = 0);
    bool ActivateResource(VMXResourceHandle resource, VMXErrorCode* errcode = 0);
    bool DeactivateResource(VMXResourceHandle resource, VMXErrorCode* errcode = 0);

    /*** ACTIVATION HELPERS ***/
    bool ActivateSinglechannelResource(VMXChannelIndex channel_index, VMXChannelCapability channel_capability,
            VMXResourceHandle& res_handle, const VMXResourceConfig *res_cfg = 0, VMXErrorCode *errcode = 0);
    bool ActivateMultichannelResource(uint8_t num_channels, VMXChannelIndex *p_channel_indexes, VMXChannelCapability *p_channel_capabilities,
            VMXResourceHandle& res_handle, const VMXResourceConfig *res_cfg = 0, VMXErrorCode *errcode = 0);

    /*** RESOURCE ACTIONS ***/

    /* DIO Resources */
    bool DIO_Get(VMXResourceHandle dio_res_handle, bool& high, VMXErrorCode *errcode = 0);
    bool DIO_Set(VMXResourceHandle dio_res_handle, bool high, VMXErrorCode *errcode = 0);

    /* PWMGenerator */
    const uint8_t MIN_PWM_GENERATOR_DUTY_CYCLE = 0;
    const uint8_t MAX_PWM_GENERATOR_DUTY_CYCLE = 255;
    bool PWMGenerator_SetDutyCycle(VMXResourceHandle pwmgen_res_handle, VMXResourcePortIndex port_index, uint8_t duty_cycle, VMXErrorCode *errcode = 0);

    /* PWMCapture */
    /* Returns current PWM Capture count of 1us ticks in the current duty cycle. */
    bool PWMCapture_GetCount(VMXResourceHandle pwmcap_res_handle, int32_t& count, VMXErrorCode *errcode = 0);

    /* Encoder */
    /* Returns current integrated count of encoder ticks (at the current resolution) */
    bool Encoder_GetCount(VMXResourceHandle encoder_res_handle, int32_t& count, VMXErrorCode *errcode = 0);
    typedef enum { EncoderForward, EncoderReverse } EncoderDirection;
    bool Encoder_GetDirection(VMXResourceHandle encoder_res_handle, EncoderDirection& direction, VMXErrorCode *errcode = 0);
    bool Encoder_Reset(VMXResourceHandle encoder_res_handle, VMXErrorCode *errcode = 0);

    /* Accumulator */
    /* NOTE:  The resolution of Accumulator values is dependent upon the current number of bits */
    /* 0 bits:  12-bit resolution, 1 bit:  13-bit resolution, etc. */
    /* See the AccumulatorConfig for more information on modifying these bits */

    bool Accumulator_GetOversampleValue(VMXResourceHandle accum_res_handle, uint32_t& oversample_value, VMXErrorCode *errcode = 0);
    bool Accumulator_GetAverageValue(VMXResourceHandle accum_res_handle, uint32_t& average_value, VMXErrorCode *errcode = 0);
    bool Accumulator_GetInstantaneousValue(VMXResourceHandle accum_res_handle, uint32_t& average_value, VMXErrorCode *errcode = 0);
    bool Accumulator_GetFullScaleVoltage(float& full_scale_voltage, VMXErrorCode *errcode = 0);
    bool Accumulator_GetAverageVoltage(VMXResourceHandle accum_res_handle, float& average_value, VMXErrorCode *errcode = 0);

    /* Analog Trigger */
    typedef enum { BelowThreshold, AboveThreshold, InWindow } AnalogTriggerState;
    bool AnalogTrigger_GetState(VMXResourceHandle antrig_res_handle, AnalogTriggerState& state, VMXErrorCode *errcode = 0);

    /* Interrupt */

    /* UART */
    bool UART_Write(VMXResourceHandle uart_res_handle, uint8_t *p_data, uint16_t size, VMXErrorCode *errcode = 0);
    bool UART_Read(VMXResourceHandle uart_res_handle, uint8_t *p_data, uint16_t max_size, uint16_t& actual_size_read, VMXErrorCode *errcode = 0);
    bool UART_GetBytesAvailable(VMXResourceHandle uart_es_handle, uint16_t& size, VMXErrorCode *errcode = 0);

    /* SPI */
    bool SPI_Write(VMXResourceHandle spi_res_handle, uint8_t *p_send_data, uint16_t size, VMXErrorCode *errcode = 0);
    bool SPI_Read(VMXResourceHandle spi_res_handle, uint8_t *p_rcv_data, uint16_t size, VMXErrorCode *errcode = 0);
    bool SPI_Transaction(VMXResourceHandle spi_res_handle, uint8_t *p_send_data, uint8_t *p_rcv_data, uint16_t size, VMXErrorCode *errcode = 0);

    /* I2C */
    bool I2C_Write(VMXResourceHandle i2c_res_handle, uint8_t deviceAddress, uint8_t* dataToSend, int32_t sendSize, VMXErrorCode *errcode = 0);
    bool I2C_Read(VMXResourceHandle i2c_res_handle, uint8_t deviceAddress, uint8_t* buffer, int32_t count, VMXErrorCode *errcode = 0);
    bool I2C_Transaction(VMXResourceHandle i2c_res_handle, uint8_t deviceAddress,
                        uint8_t* dataToSend, uint16_t sendSize,
                        uint8_t* dataReceived, uint16_t receiveSize, VMXErrorCode *errcode = 0);
};

#endif /* VMXIO_H_ */