example/main.cpp

 
#include <array>
#include <iostream>
#include <regex>
#include <sstream>
 
#include "bbt_driver.h"
 
/*
 * AUXILIARY FUNCTIONS
 */
 
// tries to connect to the device
// returns true if successfull
bool connect(bbt_driver_t* driver, int tries);
 
// tries to disconnect from the device
// returns true if successfull
bool disconnect(bbt_driver_t* driver, int tries);
 
// print the device information (hw and fw version and frequency)
void print_device_information(const bbt_driver_t* driver);
 
// print the device configuration (all the signals and the sd configuration)
void print_device_configuration(const bbt_driver_t* driver);
 
// enable all the signals avaiable
void enable_all_signals(bbt_driver_t* driver);
 
// enable the sd card (if available) and configure the folder and file
void configure_sd_card(bbt_driver_t* driver);
 
// Compute the offset between the device clock and the computer
// only required if using multiple devices with different clocks
void synchronize_device(bbt_driver_t* driver);
 
// reads a data block from the device
// returns true if successfull
bool read(bbt_driver_t* driver);
 
// returns the number of eeg channels provided by the device
unsigned int eeg_channels(bbt_driver_t* driver);
 
/*
 *  MAIN FUNCTION
 */
 
int main(int argc, char** argv)
{
    //parse parameters
    if (argc < 3) {
        std::cout << "Usage: " << argv[0] << " <[bluetooth|usb]> <device> [time in seconds (default = 10)]\n";
        return -1;
    }
 
    const auto device_type = std::string(argv[1]);
    bbt_driver_t* driver = nullptr;
    std::string device_name;
 
    if (device_type.find("bluetooth") == 0)
    {
        const auto device = argv[2];
        driver = bbt_driver_new_bluetooth(device, bbt_dry_eeg_sensor);
        device_name = device;
    }
    else if (device_type.find("usb") == 0)
    {
        const auto port = std::strtol(argv[2], nullptr, 0);
        driver = bbt_driver_new_usb(port, bbt_dry_eeg_sensor);
        std::ostringstream oss;
        oss << "usb (port " << port << ")";
        device_name = oss.str();
    }
 
    const auto time = argc > 3? strtol(argv[3], nullptr, 0): 10;
 
 
 
    if (!driver)
    {
        std::cout << "Unable to create an instance with the parameter provided\n";
        return -1;
    }
 
    std::cout << "driver to " << device_name << " created\n";
 
 
 
    if (!connect(driver, 10)) {
        std::cout << "Unable to connect to " << device_name << "\n";
        bbt_driver_free(driver);
        return -1;
    }
 
    print_device_information(driver);
 
    std::cout << "Initial signals:\n";
    print_device_configuration(driver);
 
    std::cout << "Enable all signals:\n";
    enable_all_signals(driver);
 
    std::cout << "Configure sd card:\n";
    configure_sd_card(driver);
 
    synchronize_device(driver);
 
    if (bbt_driver_start(driver))
    {
        std::cout << "recording started\n";
 
        auto count = 0;
        while (count < time * bbt_driver_get_frequency(driver)) { //reads for some seconds (of correct data)
 
            if (!bbt_driver_is_connected(driver))
            {
                std::cout << "reconnect\n";
                bbt_driver_reconnect(driver);
                continue;
            }
 
            //restart if not running (the device has been reset)
            if (!bbt_driver_is_running(driver))
            {
                std::cout << "restart\n";
                //CAUTION HERE: If sd is configured, the
                /*
                std::ostringstream filename;
                filename << "a_file_name_" << count << ".sdf";
                bbt_driver_set_file(driver, filename.str().c_str());
                */
                bbt_driver_start(driver);
            }
 
            if (!read(driver))
                continue;
            count++;
        }
 
        if (bbt_driver_stop(driver)) {
            std::cout << "recording stopped\n";
        } else
            std::cout << "Unable to stop recording\n";
 
    } else
    {
        std::cout << "Unable to start recording\n";
    }
    //disconnect device
    if (!disconnect(driver, 10))
    {
        std::cout << "Unable to disconnect\n";
    }
 
    //release instance
    bbt_driver_free(driver);
 
    return 0;
}
 
bool connect(bbt_driver_t* driver, int tries)
{
    for (auto t = 0; !bbt_driver_is_connected(driver) && t < tries; ++t) {
        std::cout << "try to connect [" << t + 1 << "]\n";
        bbt_driver_connect(driver);
    }
 
    return bbt_driver_is_connected(driver) != 0;
}
 
bool disconnect(bbt_driver_t* driver, int tries)
{
    //disconnect device
    for (auto t = 0; bbt_driver_is_connected(driver) && t < tries; ++t) {
        std::cout << "try to disconnect [" << t + 1 << "]\n";
        bbt_driver_disconnect(driver);
    }
 
    return bbt_driver_is_connected(driver) == 0;
}
 
void print_device_information(const bbt_driver_t* driver)
{
    unsigned short hw_major = 0, hw_minor = 0, fw_major = 0, fw_minor = 0;
    if (bbt_driver_get_hw_version(driver, &hw_major, &hw_minor))
        std::cout << "Hardware version: " << hw_major << "." << hw_minor << "\n";
 
    if (bbt_driver_get_fw_version(driver, &fw_major, &fw_minor))
        std::cout << "Firmware version: " << fw_major << "." << fw_minor << "\n";
 
    std::cout << "Frequency: " << bbt_driver_get_frequency(driver) << " messages per second\n";
}
 
void print_device_configuration(const bbt_driver_t* driver)
{    
    for (auto i = 0u; i < bbt_driver_get_number_of_signals(driver); ++i)
    {
        const auto signal = bbt_driver_get_signal(driver, i);
 
        std::array<char, 10> signal_type;
        std::cout << "signal: " << i
                  << ", type: " << bbt_signal_get_type(signal, signal_type.data(), static_cast<unsigned int>(signal_type.size()))
                  << ", channels: " << bbt_signal_get_channels(signal)
                  << ", samples: " << bbt_signal_get_samples(signal)
                  << ", mode: " << bbt_signal_get_mode(signal) << "\n";
    }
 
    std::cout << "SD card available? " << (bbt_driver_has_sd_card_capability(driver) ? "yes" : "nope") << "\n";
 
 
    std::array<char, 256> sd_folder, sd_file;
    if (bbt_driver_has_sd_card_capability(driver))
    {
        std::cout << "SD card enabled? " << (bbt_driver_is_sd_card_enabled(driver) ? "yes" : "nope") << "\n";
        std::cout << "SD file name: " << bbt_driver_get_file(driver, sd_file.data(), static_cast<unsigned int>(sd_file.size())) << "\n";
        std::cout << "SD folder name: " << bbt_driver_get_folder(driver, sd_folder.data(), static_cast<unsigned int>(sd_folder.size())) << "\n";
    }
}
 
void enable_all_signals(bbt_driver_t* driver)
{
    for (auto i = 0u; i < bbt_driver_get_number_of_signals(driver); ++i) {
        const auto signal = bbt_driver_get_signal(driver, i);
 
        std::array<char, 10> signal_type;
        bbt_signal_get_type(signal, signal_type.data(), static_cast<unsigned int>(signal_type.size()));
 
        if (!bbt_signal_set_mode(signal, 1))
            std::cout << "can't enable the signal " << signal_type.data() << "\n";
    }
}
 
void configure_sd_card(bbt_driver_t* driver)
{
    //configure sd card recording
    if (bbt_driver_has_sd_card_capability(driver)) {
        std::cout << "Enable sd card:\n";
        if (bbt_driver_enable_sd_card(driver, true)) {
            std::cout << "SD card enabled? " << (bbt_driver_is_sd_card_enabled(driver) ? "yes" : "nope") << "\n";
        } else
            std::cout << "Unable to enable sd card. Is the card in the device?\n";
 
        std::cout << "Set folder and file names\n";
 
        if (!bbt_driver_set_file(driver, "a_file_name.sdf"))
            std::cout << "Unable to set file name\n";
 
        if (!bbt_driver_set_folder(driver, "a/folder/name"))
            std::cout << "Unable to set folder name\n";
    }
}
 
void synchronize_device(bbt_driver_t* driver)
{
    unsigned short fw_major = 0, fw_minor = 0;
 
    bbt_driver_get_fw_version(driver, &fw_major, &fw_minor);
 
    if (fw_major >= 1) { //only devices with firmware version 1.x or above can be synchronized.
        std::cout << "Start synchronization\n";
 
        long offset;
        unsigned long rtt;
        if (bbt_driver_synchronize(driver, &rtt, &offset)) {
            std::cout << "RTT computed: " << rtt << "\n";
            std::cout << "Offset computed: " << offset << "\n";
        } else {
            std::cout << "Unable to synchronize\n";
        }
    }
}
 
bool read(bbt_driver_t* driver)
{
    
    unsigned short sequence, flags;
    short battery;
 
    const auto size = bbt_driver_read_data_size(driver);
    const auto data = bbt_driver_read(driver, &sequence, &battery, &flags);
    
    if (!data) {
        std::cout << "read error\n";
        return false;
    }
 
    std::ostringstream battery_oss;
    if (battery == bbt_driver_battery_charging) {
        battery_oss << "charging";
    } else if (battery == bbt_driver_battery_unknown)
        battery_oss << "-- %";
    else
        battery_oss << 20 * battery << " %";
 
    std::cout << "read sequence " << sequence << " of size " << size << " with battery " << battery_oss.str() << "\n";
    if (flags != bbt_driver_flags_ok)
        std::cout << "ERROR flag active\n";
 
    const auto n_eeg_channels  = eeg_channels(driver);
    std::cout << "EEG impedances:";
    for (auto i = 0u; i < n_eeg_channels; ++i)
        std::cout << " " << bbt_driver_get_eeg_impedance(driver, i);
    std::cout << "\n";
 
 
    return true;
}
 
unsigned int eeg_channels(bbt_driver_t* driver)
{
    for (auto i = 0u; i < bbt_driver_get_number_of_signals(driver); ++i)
    {
        const auto signal = bbt_driver_get_signal(driver, i);
        std::array<char, 10> signal_type;
        bbt_signal_get_type(signal, signal_type.data(), static_cast<unsigned int>(signal_type.size()));
        std::regex re("EEG");
        std::cmatch match;
        if (std::regex_search(signal_type.data(), match, re))
        {
            return bbt_signal_get_channels(signal);
        }
    }
 
    return 0u;
}