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;
}