BrainAccess Core C API Usage Example

#include "bacore.h"
#include "eeg_manager.h"
#include <stdio.h>
#include <string.h>
#include <unistd.h>

unsigned int runtime = 1;
bool is_reading = false;
ba_eeg_manager* manager;

void chunk_callback([[maybe_unused]] const void* const* data, [[maybe_unused]] size_t size, [[maybe_unused]] void* user_data)
        // Get the channel index for the sample number once and reuse it
        size_t sample_number_index = ba_eeg_manager_get_channel_index(manager, BA_EEG_CHANNEL_ID_SAMPLE_NUMBER);

        for (size_t i = 0; i < size; ++i)
                // Get the data for the sample number and channels
                const size_t* eeg_data_sample_number = (const size_t*)data[sample_number_index];
                const double* eeg_data_channel_0 = (const double*)data[ba_eeg_manager_get_channel_index(manager, BA_EEG_CHANNEL_ID_ELECTRODE_MEASUREMENT + 0)];
                const double* eeg_data_channel_1 = (const double*)data[ba_eeg_manager_get_channel_index(manager, BA_EEG_CHANNEL_ID_ELECTRODE_MEASUREMENT + 1)];
                const double* eeg_data_channel_2 = (const double*)data[ba_eeg_manager_get_channel_index(manager, BA_EEG_CHANNEL_ID_ELECTRODE_MEASUREMENT + 2)];
                const double* eeg_data_channel_3 = (const double*)data[ba_eeg_manager_get_channel_index(manager, BA_EEG_CHANNEL_ID_ELECTRODE_MEASUREMENT + 3)];
                const double* eeg_data_channel_4 = (const double*)data[ba_eeg_manager_get_channel_index(manager, BA_EEG_CHANNEL_ID_ELECTRODE_MEASUREMENT + 4)];
                const double* eeg_data_channel_5 = (const double*)data[ba_eeg_manager_get_channel_index(manager, BA_EEG_CHANNEL_ID_ELECTRODE_MEASUREMENT + 5)];
                const double* eeg_data_channel_6 = (const double*)data[ba_eeg_manager_get_channel_index(manager, BA_EEG_CHANNEL_ID_ELECTRODE_MEASUREMENT + 6)];
                const double* eeg_data_channel_7 = (const double*)data[ba_eeg_manager_get_channel_index(manager, BA_EEG_CHANNEL_ID_ELECTRODE_MEASUREMENT + 7)];

                // Process the data directly without storing it in a structure
                        "%d  %d  %f  %f  %f  %f  %f  %f  %f  %f\n", eeg_data_sample_number[i], eeg_data_channel_0[i], eeg_data_channel_1[i], eeg_data_channel_2[i],
                        eeg_data_channel_3[i], eeg_data_channel_4[i], eeg_data_channel_5[i], eeg_data_channel_6[i], eeg_data_channel_7[i]);

// Callback function for handling disconnection events.
// This function is called when the connection to the device is lost.
// It prints a message indicating the disconnection event.
void disconnect_callback([[maybe_unused]] void* data)

// Function to print the version information.
// This function takes a text string and a version structure as input and prints the version information.
void print_version(const char* text, const ba_version* version)
        printf("%s %d.%d.%d\n", text, version->major, version->minor, version->patch);

// Function to connect to the Bluetooth EEG device and perform EEG operations
ba_init_error connect_ble()
        // Initialize the status variable to hold the result of the initialization
        ba_init_error status = BA_INIT_ERROR_OK;

        // Define the version constant for the Bluetooth EEG system
        const ba_version version = {1, 1, 1};

        // Initialize the Bluetooth EEG system using the defined version
        status |= ba_core_init(&version);

        // Check if the initialization was successful
        if (status != BA_INIT_ERROR_OK)
                // Print an error message if the initialization failed
                printf("Core init Error: %d\n", status);

        // Retrieve the current version of the Bluetooth EEG system
        const ba_version* current_version = ba_core_get_version();

        // Print the current version of the Bluetooth EEG system
        print_version("core current version: ", current_version);

        // Scan for available Bluetooth EEG devices
        status |= ba_core_scan(0);

        // Check if no devices were found after the first scan
        if (ba_core_device_count() == 0)
                // Keep scanning for devices until at least one is found
                while (ba_core_device_count() == 0)
                        // Print the number of scan attempts
                        printf("Found devices count: %d\n", ba_core_device_count());

                        // Scan for available devices again
                        status |= ba_core_scan(0);

        // Print a message indicating the end of the scanning process
        printf("Search: \n");

        // Check if no devices were found after scanning
        if (ba_core_device_count() == 0)
                // Print a message indicating that no devices were found
                printf("0 Devices were found\n");

                // Close the Bluetooth EEG system

                // Return an error code indicating that no devices were found
                return BA_INIT_ERROR_NOT_FOUND;
        // Create a new EEG manager instance
        manager = ba_eeg_manager_new();

        // Print the number of available devices
        printf("devices found: %d\n", ba_core_device_count());

        // Get the address of the first device
        char address[20];
        ba_core_device_get_address(address, 0);
        printf("Address: %s\n", address);

        // Get the name of the first device
        char name[20];
        ba_core_device_get_name(name, 0);
        printf("Name: %s\n", name);

        // Find the device with the name "BA MINI 002"
        int device = -1;
        for (int i = 0; i < ba_core_device_count(); ++i)
                ba_core_device_get_name(name, i);
                if (strcmp(name, "BA MINI 002") == 0)
                        device = i;
                        printf("Device found!!!!!!!\n");

        // If the device is not found, return -1
        if (device < 0)
                return -1;

        // Connect to the selected device
        ba_eeg_manager_connect(manager, device, NULL, NULL);

        // Get the battery information
        const ba_battery_info info = ba_eeg_manager_get_battery_info(manager);
        printf("battery level: %d | is charger connected: %d | is charging: %d ", info.level, info.is_charger_connected, info.is_charging);

        // Enable and set the gain for all electrode channels
        for (int i = 0; i < 8; ++i)
                ba_eeg_manager_set_channel_enabled(manager, BA_EEG_CHANNEL_ID_ELECTRODE_CONTACT + i, true);
                ba_eeg_manager_set_channel_enabled(manager, BA_EEG_CHANNEL_ID_ELECTRODE_MEASUREMENT + i, true);
                ba_eeg_manager_set_channel_gain(manager, BA_EEG_CHANNEL_ID_ELECTRODE_MEASUREMENT + i, BA_GAIN_MODE_X8);

        // Enable the sample number channel
        ba_eeg_manager_set_channel_enabled(manager, BA_EEG_CHANNEL_ID_SAMPLE_NUMBER, true);

        // Set the impedance measurement mode to off
        ba_eeg_manager_set_impedance_mode(manager, BA_IMPEDANCE_MEASUREMENT_MODE_OFF);

        // Load the configuration
        ba_eeg_manager_load_config(manager, NULL, NULL);

        // Define the callback function for handling EEG data chunks
        ba_callback_chunk my_callback = chunk_callback;

        // Define the callback function for handling disconnection events
        ba_callback_disconnect disconnect_cb = disconnect_callback;

        // Set the callback function for handling EEG data chunks
        ba_eeg_manager_set_callback_chunk(manager, my_callback, NULL);

        // Set the callback function for handling disconnection events
        ba_eeg_manager_set_callback_disconnect(manager, disconnect_cb, NULL);

        // Start the EEG data streaming
        ba_eeg_manager_start_stream(manager, NULL, NULL);

        // Check if the EEG data streaming is active

        // Sleep for 5 seconds

        // Stop the EEG data streaming
        ba_eeg_manager_stop_stream(manager, NULL, NULL);

        // Free the EEG manager instance

        // Close the Bluetooth EEG system

        // Set the is_reading flag to false
        is_reading = false;

        // Return the status of the initialization
        return status;

int main()
        return 0;