emotiv 0.0.13

Async Rust client and TUI for Emotiv EEG headsets via the Cortex API WebSocket (JSON-RPC 2.0)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

//! Record and export data — mirrors `cortex-example/python/record.py`.
//!
//! Creates a recording, waits for a duration, stops it, and exports to CSV.
//!
//! # Usage
//!
//! ```bash
//! cargo run --example record
//! ```
//!
//! # API credentials
//!
//! Requires `EMOTIV_CLIENT_ID` and `EMOTIV_CLIENT_SECRET` environment variables.
//! Create them at <https://www.emotiv.com/my-account/cortex-apps/>.

use anyhow::Result;

use emotiv::client::{CortexClient, CortexClientConfig};
use emotiv::types::*;

const RECORD_DURATION_SECS: u64 = 10;
const RECORD_TITLE: &str = "Rust Record Example";
const RECORD_DESCRIPTION: &str = "Recorded via emotiv-rs record example";
const EXPORT_FOLDER: &str = "/tmp/emotiv_export";
const EXPORT_FORMAT: &str = "CSV";
const EXPORT_VERSION: &str = "V2";

#[tokio::main]
async fn main() -> Result<()> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let client_id = std::env::var("EMOTIV_CLIENT_ID").expect("Set EMOTIV_CLIENT_ID");
    let client_secret = std::env::var("EMOTIV_CLIENT_SECRET").expect("Set EMOTIV_CLIENT_SECRET");

    let config = CortexClientConfig { client_id, client_secret, ..Default::default() };
    let client = CortexClient::new(config);
    let (mut rx, handle) = client.connect().await?;

    while let Some(event) = rx.recv().await {
        match event {
            CortexEvent::SessionCreated(_) => {
                println!("Session created. Creating record...");
                handle.create_record(RECORD_TITLE, RECORD_DESCRIPTION).await?;
            }
            CortexEvent::RecordCreated(rec) => {
                println!("Record created: {} ({})", rec.title, rec.uuid);
                println!("Recording for {RECORD_DURATION_SECS} seconds...");
                for i in 0..RECORD_DURATION_SECS {
                    println!("  recording at {i} s");
                    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
                }
                println!("Stopping record...");
                handle.stop_record().await?;
            }
            CortexEvent::RecordStopped(rec) => {
                println!("Record stopped: {} ({} -> {})", rec.uuid, rec.start_datetime, rec.end_datetime);
            }
            CortexEvent::RecordPostProcessingDone(rid) => {
                println!("Record {rid} post-processing done. Exporting...");
                let rid_str: &str = &rid;
                handle.export_record(
                    EXPORT_FOLDER, EXPORT_FORMAT,
                    &["EEG", "MOTION", "PM", "BP"],
                    &[rid_str], EXPORT_VERSION,
                ).await?;
            }
            CortexEvent::RecordExported(ids) => {
                println!("Export complete for records: {ids:?}");
                break;
            }
            CortexEvent::Error(msg) => eprintln!("Error: {msg}"),
            CortexEvent::Disconnected => { println!("Disconnected"); break; }
            _ => {}
        }
    }

    Ok(())
}