# Start scanning
bluetoothctl scan on

# Find NEUROFOCUS_V4
# Note the MAC address (XX:XX:XX:XX:XX:XX)

# Connect
bluetoothctl connect XX:XX:XX:XX:XX:XX

# Trust device (optional, for auto-reconnect)
bluetoothctl trust XX:XX:XX:XX:XX:XX

import asyncio
from bleak import BleakClient, BleakScanner

SERVICE_UUID = "0338ff7c-6251-4029-a5d5-24e4fa856c8d"
DATA_CHAR_UUID = "ad615f2b-cc93-4155-9e4d-f5f32cb9a2d7"
CMD_CHAR_UUID = "b5e3d1c9-8a2f-4e7b-9c6d-1a3f5e7b9c2d"

async def main():
    # Find device
    devices = await BleakScanner.discover()
    neurofocus = None
    for device in devices:
        if device.name == "NEUROFOCUS_V4":
            neurofocus = device
            break
    
    if not neurofocus:
        print("Device not found")
        return
    
    # Connect
    async with BleakClient(neurofocus.address) as client:
        print(f"Connected to {neurofocus.name}")
        
        # Subscribe to data notifications
        def callback(sender, data):
            value = int(data.decode('ascii'))
            print(f"EEG: {value}")
        
        await client.start_notify(DATA_CHAR_UUID, callback)
        
        # Send start command
        await client.write_gatt_char(CMD_CHAR_UUID, b'b')
        print("Streaming started")
        
        # Stream for 10 seconds
        await asyncio.sleep(10)
        
        # Send stop command
        await client.write_gatt_char(CMD_CHAR_UUID, b's')
        print("Streaming stopped")

asyncio.run(main())

const SERVICE_UUID = '0338ff7c-6251-4029-a5d5-24e4fa856c8d';
const DATA_CHAR_UUID = 'ad615f2b-cc93-4155-9e4d-f5f32cb9a2d7';
const CMD_CHAR_UUID = 'b5e3d1c9-8a2f-4e7b-9c6d-1a3f5e7b9c2d';

async function connect() {
  try {
    // Request device
    const device = await navigator.bluetooth.requestDevice({
      filters: [{ name: 'NEUROFOCUS_V4' }],
      optionalServices: [SERVICE_UUID]
    });
    
    // Connect to GATT server
    const server = await device.gatt.connect();
    const service = await server.getPrimaryService(SERVICE_UUID);
    
    // Get characteristics
    const dataChar = await service.getCharacteristic(DATA_CHAR_UUID);
    const cmdChar = await service.getCharacteristic(CMD_CHAR_UUID);
    
    // Subscribe to data
    await dataChar.startNotifications();
    dataChar.addEventListener('characteristicvaluechanged', (event) => {
      const value = new TextDecoder().decode(event.target.value);
      console.log('EEG:', parseInt(value));
    });
    
    // Start streaming
    await cmdChar.writeValue(new TextEncoder().encode('b'));
    console.log('Streaming started');
    
  } catch (error) {
    console.error('Error:', error);
  }
}

// Call connect() when user clicks a button
document.getElementById('connectBtn').addEventListener('click', connect);

"12543221"
"12545009"
"12543891"

# Python example
raw_value = 12543221
voltage_uV = raw_value * (3300000.0 / 8388607.0)
electrode_uV = voltage_uV / 100.0  # Divide by gain

if (bleManager.wasJustConnected()) {
  streamer.start();
}
if (bleManager.wasJustDisconnected()) {
  streamer.stop();
}

// In BLEManager::init()
BLECharacteristic* myChar = pService->createCharacteristic(
  "12345678-1234-5678-1234-56789abcdef0",
  BLECharacteristic::PROPERTY_READ | 
  BLECharacteristic::PROPERTY_WRITE
);

import asyncio
import matplotlib.pyplot as plt
from bleak import BleakClient
from collections import deque

SERVICE_UUID = "0338ff7c-6251-4029-a5d5-24e4fa856c8d"
DATA_CHAR_UUID = "ad615f2b-cc93-4155-9e4d-f5f32cb9a2d7"

data = deque(maxlen=660)  # 1 second of data

def callback(sender, data_bytes):
    value = int(data_bytes.decode('ascii'))
    data.append(value)

async def stream():
    device = await BleakScanner.find_device_by_name("NEUROFOCUS_V4")
    async with BleakClient(device.address) as client:
        await client.start_notify(DATA_CHAR_UUID, callback)
        while True:
            await asyncio.sleep(1)
            plt.clf()
            plt.plot(data)
            plt.pause(0.01)

asyncio.run(stream())

import asyncio
import csv
from datetime import datetime
from bleak import BleakClient, BleakScanner

SERVICE_UUID = "0338ff7c-6251-4029-a5d5-24e4fa856c8d"
DATA_CHAR_UUID = "ad615f2b-cc93-4155-9e4d-f5f32cb9a2d7"

csv_file = open('eeg_data.csv', 'w', newline='')
writer = csv.writer(csv_file)
writer.writerow(['timestamp', 'raw_value'])

def callback(sender, data):
    value = int(data.decode('ascii'))
    timestamp = datetime.now().isoformat()
    writer.writerow([timestamp, value])

async def log():
    device = await BleakScanner.find_device_by_name("NEUROFOCUS_V4")
    async with BleakClient(device.address) as client:
        await client.start_notify(DATA_CHAR_UUID, callback)
        await asyncio.sleep(60)  # Log for 1 minute

asyncio.run(log())
csv_file.close()