Enum DataType 

pub enum DataType {
    EA(Vec<f32>),
    EL(Vec<f32>),
    ER(Vec<f32>),
    PI(Vec<u32>),
    PR(Vec<u32>),
    PG(Vec<u32>),
    T0(Vec<f32>),
    T1(Vec<f32>),
    TH(Vec<f32>),
    AX(Vec<f32>),
    AY(Vec<f32>),
    AZ(Vec<f32>),
    GX(Vec<f32>),
    GY(Vec<f32>),
    GZ(Vec<f32>),
    MX(Vec<i32>),
    MY(Vec<i32>),
    MZ(Vec<i32>),
    BV(Vec<f32>),
    BATLV(Vec<u32>),
    AK(Vec<String>),
    RD(Vec<String>),
    TL(String),
    TX(Vec<String>),
    TxTlLc((String, f32)),
    TxLcLm(Vec<f32>),
    EM(Vec<String>),
    HR(Vec<i32>),
    BI(Vec<i32>),
    SA(Vec<f32>),
    SF(Vec<f32>),
    SR(Vec<f32>),
    UN(Vec<String>),
    LM(String),
    RB(String),
}

Emotibit data type

Variants

EA(Vec<f32>)

EDA- Electrodermal Activity

EL(Vec<f32>)

EDL- Electrodermal Level

ER(Vec<f32>)

EDR- Electrodermal Response (EmotiBit V4+ combines ER into EA signal)

PI(Vec<u32>)

PPG Infrared

PR(Vec<u32>)

PPG Red

PG(Vec<u32>)

PPG Green

T0(Vec<f32>)

Temperature 0

T1(Vec<f32>)

Temperature 1

TH(Vec<f32>)

Temperature via Medical-grade Thermopile (only on EmotiBit MD)

AX(Vec<f32>)

Accelerometer X

AY(Vec<f32>)

Accelerometer Y

AZ(Vec<f32>)

Accelerometer Z

GX(Vec<f32>)

Gyroscope X

GY(Vec<f32>)

Gyroscope Y

GZ(Vec<f32>)

Gyroscope Z

MX(Vec<i32>)

Magnetometer X

MY(Vec<i32>)

Magnetometer Y

MZ(Vec<i32>)

Magnetometer Z

BV(Vec<f32>)

Battery Voltage

BATLV(Vec<u32>)

Battery Percentage Remaining (B%)

AK(Vec<String>)

RD(Vec<String>)

Request Data, TypeTag in Payload

TL(String)

TX(Vec<String>)

TxTlLc((String, f32))

TxLcLm(Vec<f32>)

EM(Vec<String>)

HR(Vec<i32>)

Heart Rate

BI(Vec<i32>)

Heart Inter-beat Interval

SA(Vec<f32>)

Skin Conductance Response (SCR) Amplitude

SF(Vec<f32>)

Skin Conductance Response (SCR) Frequency

SR(Vec<f32>)

Skin Conductance Response (SCR) Rise Time

UN(Vec<String>)

User Note

LM(String)

LSL Marker/message

RB(String)

Record begin (Include timestamp in Data)

Implementations

impl DataType

pub fn as_str(&self) -> &'static str

Examples found in repository

examples/to_csv.rs (line 62)

fn read_write(path_buf: Option<PathBuf>) -> Result<()> {
    let filename: &str = path_buf
        .as_ref()
        .and_then(|name| name.file_stem())
        .and_then(|name| name.to_str())
        .unwrap_or("default");

    let (datapackets, errors): (Vec<_>, Vec<_>) = parser::get_packets(
        &path_buf
            .as_ref()
            .unwrap()
            .clone()
            .into_os_string()
            .into_string()
            .unwrap(),
    )?
    .into_iter()
    .partition(Result::is_ok);

    let mut output_file = path_buf.clone().unwrap();
    output_file.set_file_name(format!("{}_ERROR.csv", filename));

    // Write Errors
    let mut output = File::create(output_file.clone())?;
    for err in errors.into_iter().filter_map(|result| result.err()) {
        writeln!(output, "{}", err)?;
    }

    // Write TimeSyncs
    output_file.set_file_name(format!("{}_timesyncs.csv", filename));
    let mut writer = writer::WriterBuilder::new().from_path(output_file.to_str().unwrap())?;
    match parser::find_syncs(&datapackets) {
        Ok(syncs) => {
            let header =
                StringRecord::from(vec!["RD", "TS_received", "TS_sent", "AK", "RoundTrip"]);
            writer.write(&header)?;
            for packet in syncs {
                writer.write(&packet)?;
            }
        }
        Err(e) => {
            writer.write(&StringRecord::from(vec![format!("{:?}", e)]))?;
        }
    }

    // Extract TypeTags
    let set: HashSet<&str> = HashSet::from_iter(
        datapackets
            .iter()
            .map(|result| result.as_ref().unwrap().data_type.as_str()),
    );

    // Write TimeSyncsMap
    output_file.set_file_name(format!("{}_timeSyncMap.csv", filename));
    let mut writer = writer::WriterBuilder::new().from_path(output_file.to_str().unwrap())?;
    let syncmap = parser::generate_sync_map(&datapackets);
    match &syncmap {
        Ok(map) => {
            let header = StringRecord::from(vec![
                "TE0",
                "TE1",
                "TL0",
                "TL1",
                "TimeSyncsReceived",
                "EmotiBitStartTime",
                "EmotiBitEndTime",
                "DataParserVersion",
            ]);
            writer.write(&header)?;
            writer.write(map)?;
        }
        Err(e) => {
            writer.write(&StringRecord::from(vec![format!("{:?}", e)]))?;
        }
    }

    // Write Packets
    let packets: Vec<DataPacket> = match syncmap {
        Ok(map) => datapackets
            .into_iter()
            .filter_map(|result| result.ok())
            .map(|p| p.inject_host_timestamp(&map))
            .collect(),
        Err(_) => datapackets
            .into_iter()
            .filter_map(|result| result.ok())
            .collect(),
    };

    for t in set.iter() {
        output_file.set_file_name(format!("{}_{}.csv", filename, t));
        let mut writer = writer::WriterBuilder::new().from_path(output_file.to_str().unwrap())?;
        let header = StringRecord::from(vec![
            "LocalTimestamp",
            "EmotiBitTimestamp",
            "PacketNumber",
            "DataLength",
            "TypeTag",
            "ProtocolVersion",
            "DataReliability",
            t,
        ]);
        writer.write(&header)?;
        for packet in packets.iter().filter(|x| x.data_type.as_str() == *t) {
            writer.write(packet)?;
        }
    }

    Ok(())
}

pub fn payload(&self) -> Vec<String>

Trait Implementations

impl Clone for DataType

fn clone(&self) -> DataType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DataType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for DataType

fn eq(&self, other: &DataType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for DataType