LabJackDevice.h

// This file is a part of the OpenSurgSim project.
// Copyright 2013, SimQuest Solutions Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef SURGSIM_DEVICES_LABJACK_LABJACKDEVICE_H
#define SURGSIM_DEVICES_LABJACK_LABJACKDEVICE_H

#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>

#include "SurgSim/DataStructures/OptionalValue.h"
#include "SurgSim/Input/CommonDevice.h"

namespace SurgSim
{
namespace Devices
{
class LabJackScaffold;

SURGSIM_STATIC_REGISTRATION(LabJackDevice);

namespace LabJack
{
enum TIMER
{
    TIMER0,
    TIMER1,
    TIMER2,
    TIMER3,
    TIMER4,
    TIMER5
};

enum FIO_LINE
{
    FIO0,
    FIO1,
    FIO2,
    FIO3,
    FIO4,
    FIO5,
    FIO6,
    FIO7
};

enum EIO_LINE
{
    EIO0 = 8,
    EIO1,
    EIO2,
    EIO3,
    EIO4,
    EIO5,
    EIO6,
    EIO7
};

enum CIO_LINE
{
    CIO0 = 16,
    CIO1,
    CIO2,
    CIO3
};

enum MIO_LINE
{
    MIO0 = 20,
    MIO1,
    MIO2
};

enum AIN
{
    AIN0,
    AIN1,
    AIN2,
    AIN3,
    AIN4,
    AIN5,
    AIN6,
    AIN7,
    AIN8,
    AIN9,
    AIN10,
    AIN11,
    AIN12,
    AIN13,
    AIN14,
    AIN15
};

enum DAC
{
    DAC0,
    DAC1
};

enum Model
{
    MODEL_SEARCH = -1,
    MODEL_UE9 = 9,
    MODEL_U3 = 3,
    MODEL_U6 = 6
};

enum Connection
{
    CONNECTION_SEARCH = -1,
    CONNECTION_USB = 1,
    CONNECTION_ETHERNET = 2,
    CONNECTION_ETHERNET_MB = 3,
    CONNECTION_ETHERNET_DATA_ONLY = 4
};

enum TimerBase
{
    TIMERBASE_DEFAULT = -1,
    TIMERBASE_0 = 0,
    TIMERBASE_1 = 1,
    TIMERBASE_2 = 2,
    TIMERBASE_3 = 3,
    TIMERBASE_4 = 4,
    TIMERBASE_5 = 5,
    TIMERBASE_6 = 6,
    TIMERBASE_20 = 20,
    TIMERBASE_21 = 21,
    TIMERBASE_22 = 22,
    TIMERBASE_23 = 23,
    TIMERBASE_24 = 24,
    TIMERBASE_25 = 25,
    TIMERBASE_26 = 26
};

enum TimerMode
{
    TIMERMODE_PWM_16BIT = 0, // 16 bit PWM
    TIMERMODE_PWM_8BIT = 1, // 8 bit PWM
    TIMERMODE_RISING_EDGES_32BIT = 2, // 32-bit rising to rising edge measurement
    TIMERMODE_FALLING_EDGES_32BIT = 3, // 32-bit falling to falling edge measurement
    TIMERMODE_DUTY_CYCLE = 4, // duty cycle measurement
    TIMERMODE_FIRMWARE_COUNTER = 5, // firmware based rising edge counter
    TIMERMODE_FIRMWARE_COUNTER_DEBOUNCED = 6, // firmware counter with debounce
    TIMERMODE_FREQUENCY_OUTPUT = 7, // frequency output
    TIMERMODE_QUADRATURE = 8, // Quadrature
    TIMERMODE_TIMER_STOP = 9, // stops another timer after n pulses
    TIMERMODE_SYSTEM_TIMER_LOWER_32BITS = 10, // read lower 32-bits of system timer
    TIMERMODE_SYSTEM_TIMER_UPPR_32BITS = 11, // read upper 32-bits of system timer
    TIMERMODE_RISING_EDGES_16BIT = 12, // 16-bit rising to rising edge measurement
    TIMERMODE_FALLING_EDGES_16BIT = 13, // 16-bit falling to falling edge measurement
    TIMERMODE_LINE_TO_LINE = 14 // Line to Line measurement
};

struct TimerSettings
{
    bool operator==(const TimerSettings& other) const
    {
        return (mode == other.mode) && (initialValue == other.initialValue);
    }

    TimerMode mode;

    SurgSim::DataStructures::OptionalValue<int> initialValue;
};

enum Range : SURGSIM_ENUM_TYPE;

struct AnalogInputSettings
{
    bool operator==(const AnalogInputSettings& other) const
    {
        return (negativeChannel == other.negativeChannel) && (range == other.range);
    }

    Range range;

    SurgSim::DataStructures::OptionalValue<int> negativeChannel;
};
};

class LabJackDevice : public SurgSim::Input::CommonDevice
{
public:
    explicit LabJackDevice(const std::string& uniqueName);

    SURGSIM_CLASSNAME(SurgSim::Devices::LabJackDevice);

    virtual ~LabJackDevice();

    bool initialize() override;

    bool isInitialized() const override;

    void setModel(LabJack::Model model);

    LabJack::Model getModel() const;

    void setConnection(LabJack::Connection connection);

    LabJack::Connection getConnection() const;

    void setAddress(std::string address);

    const std::string& getAddress() const;

    void setResetOnDestruct(bool reset);

    bool getResetOnDestruct() const;

    void enableDigitalInput(int channel);

    void setDigitalInputs(const std::unordered_set<int>& digitalInputChannels);

    const std::unordered_set<int>& getDigitalInputs() const;

    void enableDigitalOutput(int channel);

    void setDigitalOutputs(const std::unordered_set<int>& digitalOutputChannels);

    const std::unordered_set<int>& getDigitalOutputs() const;

    void setTimerBase(LabJack::TimerBase base);

    LabJack::TimerBase getTimerBase() const;

    void setTimerClockDivisor(int divisor);

    int getTimerClockDivisor() const;

    void setTimerCounterPinOffset(int offset);

    int getTimerCounterPinOffset() const;

    void enableTimer(int index, LabJack::TimerMode mode);

    void enableTimer(int index, LabJack::TimerMode mode, int initialValue);

    void setTimers(const std::unordered_map<int, LabJack::TimerSettings>& timers);

    const std::unordered_map<int, LabJack::TimerSettings>& getTimers() const;

    void setMaximumUpdateRate(double rate);

    double getMaximumUpdateRate() const;

    void enableAnalogInput(int positiveChannel, LabJack::Range range, int negativeChannel);

    void enableAnalogInput(int channel, LabJack::Range range);

    void setAnalogInputs(const std::unordered_map<int, LabJack::AnalogInputSettings>& analogInputs);

    const std::unordered_map<int, LabJack::AnalogInputSettings>& getAnalogInputs() const;

    void enableAnalogOutput(int channel);

    void setAnalogOutputs(const std::unordered_set<int>& analogOutputChannels);

    const std::unordered_set<int>& getAnalogOutputs() const;

    void setAnalogInputResolution(int resolution);

    int getAnalogInputResolution() const;

    void setAnalogInputSettling(int settling);

    int getAnalogInputSettling() const;

private:
    friend class LabJackScaffold;

    bool finalize() override;

    std::shared_ptr<LabJackScaffold> m_scaffold;

    LabJack::Model m_model;

    LabJack::Connection m_connection;

    std::string m_address;

    bool m_reset;

    std::unordered_set<int> m_digitalInputChannels;

    std::unordered_map<int, LabJack::AnalogInputSettings> m_analogInputs;

    std::unordered_set<int> m_digitalOutputChannels;

    std::unordered_set<int> m_analogOutputChannels;

    LabJack::TimerBase m_timerBase;

    int m_timerClockDivisor;

    int m_timerCounterPinOffset;

    std::unordered_map<int, LabJack::TimerSettings> m_timers;

    double m_threadRate;

    int m_analogInputResolution;

    int m_analogInputSettling;
};

};  // namespace Devices
};  // namespace SurgSim

SURGSIM_SERIALIZABLE_ENUM(SurgSim::Devices::LabJack::Range, (RANGE_NONE)(RANGE_20)(RANGE_10)(RANGE_5)(RANGE_4)(RANGE_2_POINT_5)(RANGE_2)(RANGE_1_POINT_25)(RANGE_1)(RANGE_0_POINT_625)(RANGE_0_POINT_1)(RANGE_0_POINT_01));

#endif  // SURGSIM_DEVICES_LABJACK_LABJACKDEVICE_H