bbt_device.h

Go to the documentation of this file.

#ifndef BBT_DEVICE_H
#define BBT_DEVICE_H
 
#if defined(WIN32) || defined(_WIN32)
#ifdef BBT_SDK_STATIC_DEFINE
#define BBT_SDK_API
#define BBT_SDK_NO_EXPORT
#else
#ifndef BBT_SDK_API
#ifdef BBT_SDK_EXPORTS
/* We are building this library */
#define BBT_SDK_API __declspec(dllexport)
#else
/* We are using this library */
#define BBT_SDK_API __declspec(dllimport)
#endif
#endif
 
#ifndef BBT_SDK_NO_EXPORT
#define BBT_SDK_NO_EXPORT
#endif
#endif
#else
#define BBT_SDK_API
#endif
 
#ifndef BBT_SDK_DEPRECATED
#define BBT_SDK_DEPRECATED __declspec(deprecated)
#endif
 
#ifndef BBT_SDK_DEPRECATED_EXPORT
#define BBT_SDK_DEPRECATED_EXPORT BBT_SDK_API BBT_SDK_DEPRECATED
#endif
 
#ifndef BBT_SDK_DEPRECATED_NO_EXPORT
#define BBT_SDK_DEPRECATED_NO_EXPORT BBT_SDK_NO_EXPORT BBT_SDK_DEPRECATED
#endif
 
#if 0 /* DEFINE_NO_DEPRECATED */
#ifndef BBT_SDK_NO_DEPRECATED
#define BBT_SDK_NO_DEPRECATED
#endif
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
    typedef struct bbt_device_s bbt_device_t;
 
    BBT_SDK_API bbt_device_t* bbt_device_new_air(const char* device_name);
 
    BBT_SDK_API bbt_device_t* bbt_device_new_diadem(const char* device_name);
 
    BBT_SDK_API bbt_device_t* bbt_device_new_hero(const char* device_name);
 
    BBT_SDK_API bbt_device_t* bbt_device_new_versatile_8(const char* device_name);
 
    BBT_SDK_API bbt_device_t* bbt_device_new_versatile_16(const char* device_name);
 
    BBT_SDK_API bbt_device_t* bbt_device_new_versatile_32(const char* device_name);
 
    BBT_SDK_API bbt_device_t* bbt_device_new_versatile_64(const char* left_device_name, const char* right_device_name);
 
    BBT_SDK_API bbt_device_t* bbt_device_new_versatile_bio(const char* device_name);
 
    BBT_SDK_API bbt_device_t* bbt_device_new_ring(const char* device_name);
 
    BBT_SDK_API bbt_device_t* bbt_device_new_ikon(const char* device_name);
 
    BBT_SDK_API bbt_device_t* bbt_device_new_ikon_sleep(const char* device_name);
 
    BBT_SDK_API bbt_device_t* bbt_device_new_versatile_plus_16(const char* device_name, const char* connection_type, unsigned short sampling_rate);
 
    BBT_SDK_API bbt_device_t* bbt_device_new_versatile_plus_32(const char* device_name, const char* connection_type, unsigned short sampling_rate);
 
    BBT_SDK_API void bbt_device_free(bbt_device_t* device);
 
    BBT_SDK_API int bbt_device_run_connection_server(const char* connection_server_folder, int connection_timeout);
 
    BBT_SDK_API int bbt_device_kill_connection_server();
 
    BBT_SDK_API int bbt_device_connect(bbt_device_t* device);
 
    BBT_SDK_API int bbt_device_disconnect(bbt_device_t* device);
 
    BBT_SDK_API int bbt_device_reconnect(bbt_device_t* device);
 
    BBT_SDK_API int bbt_device_is_connected(const bbt_device_t* device);
 
    BBT_SDK_API int
    bbt_device_get_hardware_version(const bbt_device_t* device, unsigned short* major, unsigned short* minor);
 
    BBT_SDK_API int
    bbt_device_get_firmware_version(const bbt_device_t* device, unsigned short* major, unsigned short* minor);
 
    BBT_SDK_API unsigned short bbt_device_get_frequency(const bbt_device_t* device);
 
    enum bbt_powerline_frequency_t
    {
        POWERLINE_DISABLED = 0, 
        POWERLINE_50 = 50,      
        POWERLINE_60 = 60,      
    };
 
    BBT_SDK_API int bbt_device_set_frequency(bbt_device_t *device, enum bbt_powerline_frequency_t powerline_info);
 
    BBT_SDK_API const int bbt_device_get_powerline_frequency(const bbt_device_t *device);
 
    BBT_SDK_API const char* bbt_device_get_conn_type(const bbt_device_t* device);
 
    BBT_SDK_API const int bbt_device_get_versatile_plus_sampling_rate(const bbt_device_t *device);
 
    enum bbt_device_signal_type_t
    {
        Accelerometer = 0,   
        Analog_Aux,          
        BVP,                 
        Digital_Aux,         
        Digital_Input,       
        Digital_Output,      
        EEG,                 
        EXG,                 
        GSR,                 
        IMU,                 
        Photodiode,          
        PPG,                 
        Digital_Input_Output,
    };
 
    enum bbt_device_type_t
    {
        AIR = 0,           
        DIADEM,            
        HERO,              
        VERSATILE_8,       
        VERSATILE_16,      
        VERSATILE_32,      
        VERSATILE_64,      
        VERSATILE_BIO,     
        RING,              
        IKON,              
        IKON_SLEEP,        
        VERSATILE_PLUS_16, 
        VERSATILE_PLUS_32, 
    };
 
    enum bbt_device_versatile_plus_dio_mode
    {
        DISABLED = 0,
 
        DIGITAL_INPUT,
 
        DIGITAL_OUTPUT,
    };
 
    BBT_SDK_API enum bbt_device_type_t bbt_device_get_type(const bbt_device_t* device);
    
    struct bbt_device_signal_t
    {
        enum bbt_device_signal_type_t type;
 
        unsigned short channels;
 
        unsigned short samples_in_block;
 
        unsigned short sampling_rate;
    };
 
    BBT_SDK_API int bbt_device_get_signals(const bbt_device_t* device,
                                           unsigned short* n,
                                           const struct bbt_device_signal_t** device_signals);
 
    BBT_SDK_API int bbt_device_get_signal_mode(const bbt_device_t* device, unsigned short n);
 
    BBT_SDK_API int bbt_device_enable_signal(bbt_device_t* device, unsigned short n);
 
    BBT_SDK_API int bbt_device_disable_signal(bbt_device_t* device, unsigned short n);
 
    BBT_SDK_API int bbt_device_set_signal_mode(bbt_device_t* device, unsigned short n, int mode);
 
    BBT_SDK_API int bbt_device_has_sd_card_capabilities(const bbt_device_t* device);
 
    BBT_SDK_API int bbt_device_is_sd_card_enabled(const bbt_device_t* device);
 
    BBT_SDK_API int
    bbt_device_enable_sd_card(bbt_device_t* device, const char* recording_folder_path, const char* recording_name);
 
    BBT_SDK_API int bbt_device_disable_sd_card(bbt_device_t* device);
 
    BBT_SDK_API int bbt_device_start(bbt_device_t* device);
 
    BBT_SDK_API int bbt_device_stop(bbt_device_t* device);
 
    BBT_SDK_API int bbt_device_is_acquiring(const bbt_device_t* device);
 
    BBT_SDK_API extern const short bbt_device_battery_unknown;  
    BBT_SDK_API extern const short bbt_device_battery_charging; 
    BBT_SDK_API extern const unsigned short bbt_device_impedance_unknown;
    BBT_SDK_API extern const unsigned short bbt_device_impedance_saturated;
    BBT_SDK_API extern const unsigned short bbt_device_impedance_bad;
    BBT_SDK_API extern const unsigned short bbt_device_impedance_fair;
    BBT_SDK_API extern const unsigned short bbt_device_impedance_good;
 
    struct bbt_device_data_block_t
    {
        unsigned short sequence;
 
        short battery;
 
        unsigned short flags;
 
        double* signal_data[10];
 
        unsigned short* impedances;
    };
 
    BBT_SDK_API int bbt_device_read(bbt_device_t* device, struct bbt_device_data_block_t* block);
 
    BBT_SDK_API int bbt_mount_versatile_plus_sd_card(bbt_device_t* device);
 
    BBT_SDK_API int
    bbt_device_import_sd_record(const char* input_folder, const char* recording_name, const char* output_folder, enum bbt_device_type_t dev_type, enum bbt_powerline_frequency_t powerline_info, const char *version);
 
    BBT_SDK_API int bbt_device_import_eeg64_sd_record(const char* left_input_folder,
                                                      const char* right_input_folder,
                                                      const char* recording_name,
                                                      const char* output_folder,
                                                      enum bbt_device_type_t dev_type,
                                                      enum bbt_powerline_frequency_t powerline_info,
                                                      const char *version);
 
 
#ifdef __cplusplus
}
#endif
 
#endif // BBT_DEVICE_H