libsmu.hpp

Go to the documentation of this file.

// Released under the terms of the BSD License
// (C) 2014-2016
//   Analog Devices, Inc.
//   Kevin Mehall <km@kevinmehall.net>
//   Ian Daniher <itdaniher@gmail.com>


#pragma once

#include <cstdint>
#include <array>
#include <atomic>
#include <condition_variable>
#include <functional>
#include <mutex>
#include <set>
#include <string>
#include <thread>
#include <vector>
#include <map>

#include <libusb.h>

#include <libsmu/version.hpp>

const std::vector<std::vector<uint16_t>> SUPPORTED_DEVICES = {
    {0x0456, 0xcee2}, // old
    {0x064b, 0x784c}, // new
};

const std::vector<std::vector<uint16_t>> SAMBA_DEVICES = {
    {0x03eb, 0x6124}, // shows up as a CDC device by default
};

typedef struct sl_signal_info {
    const char* label;

    uint32_t inputModes;

    uint32_t outputModes;

    double min;

    double max;

    double resolution;
} sl_signal_info;

typedef struct sl_channel_info {
    const char* label; 
    size_t mode_count; 
    size_t signal_count; 
} sl_channel_info;

typedef struct sl_device_info {
    const char* label; 
    size_t channel_count; 
} sl_device_info;

enum Src {
    CONSTANT, 
    SQUARE, 
    SAWTOOTH, 
    STAIRSTEP, 
    SINE, 
    TRIANGLE, 
};

enum Mode {
    HI_Z, 
    SVMI, 
    SIMV, 
    HI_Z_SPLIT, 
    SVMI_SPLIT, 
    SIMV_SPLIT, 
};

enum LED{
    RED = 47,
    GREEN = 29,
    BLUE = 28,
    ALL = 0
};

namespace smu {
    class Device;
    class Signal;

    class Session {
    public:
        Session();
        ~Session();

        void set_off(Device*);

        std::vector<Device*> m_available_devices;

        std::set<Device*> m_devices;

        unsigned m_active_devices;

        std::map<libusb_device*, libusb_device_handle*> m_deviceHandles;

        unsigned m_queue_size = 100000;

        unsigned m_samples;

        int scan();

        int add(Device* device);

        int add_all();

        int remove(Device* device, bool detached = false);

        int destroy(Device* device);

        int configure(uint32_t sampleRate = 0);

        int run(uint64_t samples);

        int start(uint64_t samples);

        int cancel();

        bool cancelled() { return m_cancellation != 0; }

        void flush();

        int scan_samba_devs(std::vector<libusb_device*>& samba_devs);

        int flash_firmware(std::string file, std::vector<Device*> devices = {});

        void completion();
        void handle_error(int status, const char * tag);
        void attached(libusb_device* usb_dev);
        void detached(libusb_device* usb_dev);

        int end();

        std::function<void(unsigned)> m_completion_callback;

        uint64_t m_sample_rate = 0;

        bool m_continuous = false;

    protected:
        unsigned m_cancellation = 0;

        std::atomic<bool> m_usb_thread_loop;
        std::thread m_usb_thread;

        std::mutex m_lock;
        std::mutex m_lock_devlist;
        std::condition_variable m_completion;

        libusb_context* m_usb_ctx;

        libusb_hotplug_callback_handle m_usb_cb;

        std::vector<std::function<void(Device* device)>> m_hotplug_attach_callbacks;
        std::vector<std::function<void(Device* device)>> m_hotplug_detach_callbacks;

        Device* probe_device(libusb_device* usb_dev);

        Device* find_existing_device(libusb_device* usb_dev);
    };

    class Device {
    public:
        virtual ~Device() {};

        virtual const sl_device_info* info() const = 0;

        virtual const sl_channel_info* channel_info(unsigned channel) const = 0;

        virtual Signal* signal(unsigned channel, unsigned signal) = 0;

        const std::string m_hwver;
        const std::string m_fwver;
        const std::string m_serial;

        std::pair<uint8_t, uint8_t> m_usb_addr;

        virtual int fwver_sem(std::array<unsigned, 3>& components) = 0;

        virtual int set_serial(std::string serial = "") = 0;

        //  set in order to restore it for the next data acquisition, defaults to true.
        virtual int set_mode(unsigned channel, unsigned mode, bool restore = true) = 0;

        void set_usb(libusb_device_handle* usb) {m_usb = usb;}

        virtual int get_mode(unsigned channel) = 0;

        virtual ssize_t read(std::vector<std::array<float, 4>>& buf, size_t samples, int timeout = 0, bool skipsamples = false) = 0;

        virtual int write(std::vector<float>& buf, unsigned channel, bool cyclic = false) = 0;

        virtual void flush(int channel, bool read = false) = 0;

        int ctrl_transfer(unsigned bmRequestType, unsigned bRequest, unsigned wValue, unsigned wIndex,
                        unsigned char *data, unsigned wLength, unsigned timeout);

        virtual int samba_mode() = 0;

        virtual int get_default_rate() { return 100000; }

        virtual int sync() = 0;

        virtual void lock() { m_state.lock(); }

        virtual void unlock() { m_state.unlock(); }

        virtual int write_calibration(const char* cal_file_name) { return 0; }

        virtual int read_calibration() = 0;

        virtual void calibration(std::vector<std::vector<float>>* cal) = 0;

        int m_overcurrent = 0;
        
        virtual int set_led(unsigned leds) = 0;
        virtual int set_adc_mux(unsigned adc_mux) = 0;

        virtual void set_usb_device_addr(std::pair<uint8_t, uint8_t> usb_addr) = 0;

    protected:
        Device(Session* s, libusb_device* usb_dev, libusb_device_handle* usb_handle,
            const char* hw_version, const char* fw_version, const char* serial);

        virtual int claim() { return 0; }

        virtual int release() { return 0; }

        virtual int configure(uint32_t sampleRate) = 0;

        virtual int on() = 0;

        virtual int off() = 0;

        virtual int run(uint64_t samples) = 0;

        virtual int cancel() = 0;

        Session* const m_session;

        libusb_device* const m_usb_dev = NULL;
        libusb_device_handle* m_usb = NULL;

        uint64_t m_requested_sampleno = 0;
        uint64_t m_in_sampleno = 0;
        uint64_t m_out_sampleno = 0;

        double m_write_timeout = 100;

        std::recursive_mutex m_state;

        friend class Session;
    };

    class Signal {
    public:
        Signal(const sl_signal_info* info = NULL):
            m_info(info)
            {}

        const sl_signal_info* info() const { return m_info; }
        const sl_signal_info* const m_info;

        void constant(std::vector<float>& buf, uint64_t samples, float val);

        void square(std::vector<float>& buf, uint64_t samples, float midpoint, float peak, double period, double phase, double duty);

        void sawtooth(std::vector<float>& buf, uint64_t samples, float midpoint, float peak, double period, double phase);

        void stairstep(std::vector<float>& buf, uint64_t samples, float midpoint, float peak, double period, double phase);

        void sine(std::vector<float>& buf, uint64_t samples, float midpoint, float peak, double period, double phase);

        void triangle(std::vector<float>& buf, uint64_t samples, float midpoint, float peak, double period, double phase);

    protected:
        Src m_src;

        float m_src_v1;

        float m_src_v2;

        double m_src_period;

        double m_src_duty;

        double m_src_phase;

        float get_sample();
    };
}