linux-comedi / comedilib Goto Github PK

#include <comedilib.h>

#include <iostream>
#include <vector>
#include <chrono>
#include <cstring>
#include <unistd.h>
#include <signal.h>

uint32_t getMaximumSamplingFrequency(comedi_t* dev, int sub_dev);

bool stop{};

void sigint_handler(int) {
    stop = true;
}

int main() {
    const auto dev = comedi_open("/dev/comedi0");
    const auto sub_dev = 0;

    if (comedi_get_n_subdevices(dev) <= sub_dev) {
        std::cerr << "subdevice " << sub_dev << " does not exist" << std::endl;
        return 1;
    }

    int ret = comedi_get_subdevice_flags(dev, sub_dev);
    if (ret < 0 || !(ret & SDF_CMD_READ)) {
        std::cerr << "subdevice " << sub_dev
                  << " does not support 'read' commands" << std::endl;
        return 2;
    }

    comedi_set_global_oor_behavior(COMEDI_OOR_NUMBER);

    std::vector<uint32_t> chanlist(6);
    for (uint32_t i = 0; i < 6; ++i) {
        chanlist[i] = CR_PACK(i, 0, AREF_DIFF);
    }

    // max bandwidth = 10k -> fs > 2*10k -> fs = 25k
    uint32_t sampling_freq = 25000;
    const uint32_t daq_sampling_freq =
        getMaximumSamplingFrequency(dev, sub_dev);
    const uint32_t max_sampling_freq = daq_sampling_freq / 6;
    if (sampling_freq > max_sampling_freq) {
        sampling_freq = max_sampling_freq;
        std::cout << "Lowering the per channel sampling frequency to "
                  << sampling_freq << " to be able to sample " << 6
                  << " channels at " << daq_sampling_freq << "Hz" << std::endl;
    }

    // number of scans to perform during one acquisition
    const uint32_t read_frequency = 1000;
    const auto scan_count = sampling_freq / read_frequency;

    comedi_cmd command;
    memset(&command, 0, sizeof(command));

    command.subdev = sub_dev;
    command.start_src = TRIG_NOW; // Start the acquisition when the command
                                  // is sent and after start_arg ns
    command.start_arg = 0;        // no delay
    command.scan_begin_src =
        TRIG_TIMER; // one acquisition every scan_begin_arg ns
    command.scan_begin_arg = 1'000'000'000 / sampling_freq;
    command.convert_src = TRIG_TIMER; // Sampling timer
    command.convert_arg =
        1'000'000'000 /
        daq_sampling_freq; // Sample all channels as fast as possible
    command.scan_end_src =
        TRIG_COUNT; // Stop the scan after scan_end_arg convertions
    command.scan_end_arg = 6;
    command.stop_src = TRIG_NONE; // Continuous acquisition, stopped by
                                  // a call to comedi_cancel
    command.stop_arg = scan_count;
    command.chanlist = chanlist.data(); // List of channels to sample
    command.chanlist_len = 6;           // Number of channels to sample

    const auto sample_count = scan_count * 6;
    const auto buffer_size = sample_count * sizeof(sampl_t);
    std::vector<char> reading_buffer(buffer_size);

    const std::string cmdtest_messages[] = {
        "success",          "invalid source",    "source conflict",
        "invalid argument", "argument conflict", "invalid chanlist",
    };

    ret = comedi_command_test(dev, &command);
    if (ret < 0) {
        comedi_perror("comedi_command_test");
        if (errno == EIO) {
            fprintf(stderr,
                    "Ummm... this subdevice doesn't support commands\n");
        }
        return 3;
    }
    ret = comedi_command_test(dev, &command);
    if (ret < 0) {
        comedi_perror("comedi_command_test");
        return 4;
    }
    if (ret != 0) {
        std::cerr << "Error preparing command, second test returned " << ret
                  << "(" << cmdtest_messages[ret] << ")" << std::endl;
        return 5;
    }

    comedi_set_read_subdevice(dev, sub_dev);
    ret = comedi_get_read_subdevice(dev);
    if (ret < 0 || ret != sub_dev) {
        std::cerr << "failed to change 'read' subdevice from " << ret << " to "
                  << sub_dev << std::endl;
        return 6;
    }

    comedi_cancel(dev, sub_dev);
    ret = comedi_command(dev, &command);
    if (ret < 0) {
        comedi_perror("comedi_command");
        return 7;
    } else {
        signal(SIGINT, sigint_handler);
        while (not stop) {
            std::cout << "Reading a new packet of data\n";
            auto buffer = reading_buffer.data();

            ssize_t bytes_read = 0;
            auto bytes_to_read = buffer_size;
            do {
                const auto before = std::chrono::steady_clock::now();

                ret = read(comedi_fileno(dev), buffer + bytes_read,
                           bytes_to_read);

                const auto after = std::chrono::steady_clock::now();

                std::cout
                    << "\tgot " << ret << " bytes in "
                    << std::chrono::duration_cast<std::chrono::microseconds>(
                           after - before)
                           .count()
                    << "µs\n";

                if (ret >= 0) {
                    bytes_read += ret;
                    bytes_to_read -= static_cast<size_t>(ret);
                }
            } while (ret >= 0 and bytes_to_read > 0);
        }
        signal(SIGINT, nullptr);
    }

    comedi_cancel(dev, sub_dev);
    comedi_close(dev);
}

uint32_t getMaximumSamplingFrequency(comedi_t* dev, int sub_dev) {
    comedi_cmd cmd;
    if (comedi_get_cmd_generic_timed(dev, sub_dev, &cmd, 6, 1) < 0) {
        throw std::runtime_error(
            "Cannot get the maximum sampling frequency of the DAQ");
    } else {
        return 1'000'000'000 / cmd.convert_arg;
    }
}