BrainAccess Core C++ API Usage Example

#include <thread>
#include <memory>
#include <iostream>
#include <future>
#include <mutex>
#include "bacore.hpp"
#include "eeg_manager.hpp"

using namespace brainaccess::core;

static std::mutex mtx;

static std::promise<bool> prom_connected;
static void connected(const bool b, void* const)
{
        prom_connected.set_value(b);
}

static std::promise<bool> prom_stream;
static void streamstart(void* const)
{
        prom_stream.set_value(true);
}

static std::promise<bool> prom_stop;
static void streamstop(void* const) noexcept
{
        prom_stop.set_value(true);
}

static std::promise<float> prom_latency;
static void latency(const float latency, void* const)
{
        prom_latency.set_value(latency);
}

static std::promise<full_battery_info> prom_battery;
static void battery(const full_battery_info* const b, void* const)
{
        prom_battery.set_value(*b);
}

static std::promise<bool> prom_io;
static void io_cbk(void* const)
{
        prom_io.set_value(true);
}

static float m = 0;

static void chunk(const void* const* const stream, const size_t stream_size, void* const callback_data)
{
        const auto mgr = static_cast<eeg_manager*>(callback_data);
        
        //Electrode data
        const bool* con_p = static_cast<const bool*>(stream[mgr->get_channel_index(eeg_channel_id::ELECTRODE_CONTACT_P+0)]);
        const bool* con_n = static_cast<const bool*>(stream[mgr->get_channel_index(eeg_channel_id::ELECTRODE_CONTACT_N+0)]);
        
        const float* acc_x = static_cast<const float*>(stream[mgr->get_channel_index(eeg_channel_id::ACCELEROMETER+0)]);
        const float* acc_y = static_cast<const float*>(stream[mgr->get_channel_index(eeg_channel_id::ACCELEROMETER+1)]);
        const float* acc_z = static_cast<const float*>(stream[mgr->get_channel_index(eeg_channel_id::ACCELEROMETER+2)]);

        //Print
        static float last = 0;
        for (size_t i = 0; i < stream_size; ++i)
        {
                /*std::array<const float*, 3> arr {acc_x, acc_y, acc_z};
                for (const float* f : arr)
                        if (abs(f[i]) > m) m = abs(f[i]);*/
                //std::cout << acc_x[i] << ' ' << acc_y[i] << ' ' << acc_z[i] << '\n';
                std::cout << con_p[i] << ' ' << con_n[i] << '\n';
                /*if (acc_x[i] == last)
                {
                        std::cout << "AAAAA" << '\n';
                }
                last = acc_x[i];*/
        }

        //std::scoped_lock g(mtx);
        //std::cout << m/9.80665f << std::endl;

        std::cout << std::flush;
}

int main()
{
        //Initialize core
        init(version{2, 0, 0});
        {
                //Create manager
                std::unique_ptr<eeg_manager> mgr(eeg_manager_new());

                //Connect manager to device
                prom_connected = std::promise<bool>();
                mgr->connect("/dev/rfcomm0", connected, nullptr);
                std::cout << "Connected: " << prom_connected.get_future().get() << std::endl;
                
                //Set up stream settings
                mgr->set_channel_enabled(eeg_channel_id::ELECTRODE_CONTACT_P+0, true);
                mgr->set_channel_enabled(eeg_channel_id::ELECTRODE_CONTACT_N+0, true);

                mgr->set_channel_enabled(eeg_channel_id::ACCELEROMETER+0, true);
                mgr->set_channel_enabled(eeg_channel_id::ACCELEROMETER+1, true);
                mgr->set_channel_enabled(eeg_channel_id::ACCELEROMETER+2, true);
                mgr->set_callback_chunk(chunk, mgr.get());

                //Start stream
                prom_stream = std::promise<bool>();
                mgr->start_stream(streamstart, nullptr);
                prom_stream.get_future().get();

                bool io_state = true;
                for (size_t i = 0; /*i < 10 &&*/ mgr->is_connected(); ++i)
                {
                        //Send Requests
                        prom_latency = std::promise<float>();
                        prom_battery = std::promise<full_battery_info>();
                        prom_io = std::promise<bool>();

                        mgr->get_latency(latency, nullptr);
                        mgr->get_full_battery_info(battery, nullptr);
                        /*mgr->set_io(0, io_state, io_cbk, nullptr);
                        io_state = !io_state;

                        //Wait for responses
                        const auto l = prom_latency.get_future().get();
                        const auto c = prom_battery.get_future().get();
                        prom_io.get_future().get();
                        
                        //Print responses
                        {
                                std::scoped_lock g(mtx);
                                
                                std::cout << "Latency: " << l << '\n';
                                std::cout << "Current: " << c.current << std::endl;
                        }*/

                        //Wait
                        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
                }

                //End stream
                prom_stop = std::promise<bool>();
                mgr->stop_stream(streamstop, nullptr);
                prom_stop.get_future().get();

                //Disconnect from device
                mgr->disconnect();
        }
        //Close core
        close();

        return EXIT_SUCCESS;
}