public DeviceEnumerator(DeviceType deviceType)
{
_enumeratorPtr = create_device_enumerator(deviceType);
if (_enumeratorPtr == null)
{
throw new InvalidOperationException(SdkError.LastErrorMessage);
}
_deviceListChangedCallbackFunc = OnDeviceListChanged;
SdkError.ThrowIfError(enumerator_set_device_list_changed_callback(_enumeratorPtr, _deviceListChangedCallbackFunc, out _deviceListChangedListenerPtr, IntPtr.Zero));
}
public AnyChannel(IntPtr channelPtr)
{
if (channelPtr == null)
{
throw new InvalidOperationException(SdkError.LastErrorMessage);
}
ChannelPtr = channelPtr;
_lengthChangedFunc = OnTotalLengthChanged;
SdkError.ThrowIfError(AnyChannel_add_length_callback(ChannelPtr, _lengthChangedFunc, out _listenerPtr, IntPtr.Zero));
}
public SignalChannel(Device device, ChannelInfo info, Filter[] filters)
{
ChannelPtr = create_SignalChannel_info_filters(device.DevicePtr, info, filters, (IntPtr)filters.Length);
if (ChannelPtr == IntPtr.Zero)
{
throw new InvalidOperationException(SdkError.LastErrorMessage);
}
_lengthChangedFunc = OnTotalLengthChanged;
SdkError.ThrowIfError(SignalChannel_add_length_callback(ChannelPtr, _lengthChangedFunc, out _listenerPtr));
Info = info;
}
public ResistanceChannel(Device device, ChannelInfo info)
{
ChannelPtr = create_ResistanceChannel_info(device.DevicePtr, info);
if (ChannelPtr == null)
{
throw new InvalidOperationException(SdkError.LastErrorMessage);
}
_lengthChangedFunc = OnTotalLengthChanged;
SdkError.ThrowIfError(ResistanceChannel_add_length_callback(ChannelPtr, _lengthChangedFunc, out _listenerPtr));
Info = info;
}
public SignalChannel(Device device)
{
ChannelPtr = create_SignalChannel(device.DevicePtr);
if (ChannelPtr == IntPtr.Zero)
{
throw new InvalidOperationException(SdkError.LastErrorMessage);
}
_lengthChangedFunc = OnTotalLengthChanged;
SdkError.ThrowIfError(SignalChannel_add_length_callback(ChannelPtr, _lengthChangedFunc, out _listenerPtr));
SdkError.ThrowIfError(SignalChannel_get_info(ChannelPtr, out var info));
Info = info;
}
public ArtifactZone[] ReadData(int offset, int length)
{
var bufferPtr = Marshal.AllocHGlobal(length * Marshal.SizeOf <ArtifactZone>());
try
{
SdkError.ThrowIfError(EegArtifactChannel_read_data(ChannelPtr, (IntPtr)offset, (IntPtr)length, bufferPtr));
return(_arrayMarshaler.MarshalArray(bufferPtr, (IntPtr)length));
}
finally
{
Marshal.FreeHGlobal(bufferPtr);
}
}
internal Device(IntPtr devicePtr)
{
DevicePtr = devicePtr;
Debug.Assert(DevicePtr != null);
if (DevicePtr == null)
{
throw new ArgumentNullException(nameof(devicePtr), "Device pointer is null");
}
var result = device_subscribe_param_changed(DevicePtr, OnParameterChanged);
Debug.Assert(result == SdkError.SdkNoError);
SdkError.ThrowIfError(result);
}
public DeviceScanner()
{
_scannerPtr = create_device_scanner();
Debug.Assert(_scannerPtr != null);
if (_scannerPtr == null)
{
throw new InvalidOperationException(SdkError.LastErrorMessage);
}
_deviceFoundFunc = OnDeviceFound;
_scanStateFunc = OnScanStateChanged;
SdkError.ThrowIfError(scanner_set_scan_state_callback(_scannerPtr, _scanStateFunc, out _scanStateListenerPtr, IntPtr.Zero));
SdkError.ThrowIfError(scanner_set_device_found_callback(_scannerPtr, _deviceFoundFunc, out _deviceFoundListenerPtr, IntPtr.Zero));
}
public Device(DeviceInfo info)
{
DevicePtr = create_Device(info);
if (DevicePtr == null)
{
throw new InvalidOperationException(SdkError.LastErrorMessage);
}
_paramChangedFunc = OnParameterChanged;
var result = device_subscribe_param_changed(DevicePtr, _paramChangedFunc, out _paramChangedListenerPtr, IntPtr.Zero);
SdkError.ThrowIfError(result);
_doubleDataReceivedFunc = OnDoubleDataReceived;
_signalDataReceivedFunc = OnSignalDataReceived;
_intDataReceivedFunc = OnIntDataReceived;
}
internal Device(IntPtr devicePtr)
{
DevicePtr = devicePtr;
if (DevicePtr == null)
{
throw new ArgumentNullException(nameof(devicePtr), "Device pointer is null");
}
_paramChangedFunc = OnParameterChanged;
var result = device_subscribe_param_changed(DevicePtr, _paramChangedFunc, out _paramChangedListenerPtr, IntPtr.Zero);
SdkError.ThrowIfError(result);
_doubleDataReceivedFunc = OnDoubleDataReceived;
_signalDataReceivedFunc = OnSignalDataReceived;
_intDataReceivedFunc = OnIntDataReceived;
}
public double[] ReadData(int offset, int length)
{
if (length <= 0)
{
return(new double[0]);
}
var bufferPtr = Marshal.AllocHGlobal(length * sizeof(double));
try
{
SdkError.ThrowIfError(
SignalChannel_read_data(ChannelPtr, (IntPtr)offset, (IntPtr)length, bufferPtr));
var buffer = new double[length];
Marshal.Copy(bufferPtr, buffer, 0, length);
return(buffer);
}
finally
{
Marshal.FreeHGlobal(bufferPtr);
}
}
public void StopTimer()
{
SdkError.ThrowIfError(EmulationDoubleChannel_stop_timer(ChannelPtr));
}
public void Reset()
{
SdkError.ThrowIfError(EmulationDoubleChannel_reset(ChannelPtr));
}
public void StopScan()
{
SdkError.ThrowIfError(scanner_stop_scan(_scannerPtr));
}
public void StartScan(int timeoutMs = 0)
{
SdkError.ThrowIfError(scanner_start_scan(_scannerPtr, timeoutMs));
}
public void ReleaseDevice(string name, string address)
{
SdkError.ThrowIfError(scanner_release_device(_scannerPtr, name, address));
}
public ParameterTypeInfo(Parameter parameter)
{
switch (parameter)
{
case Parameter.Name:
Type = typeof(string);
ReadParamValue = device =>
{
var nameBuffer = new StringBuilder(128);
SdkError.ThrowIfError(device_read_Name(device.DevicePtr, nameBuffer, (IntPtr)nameBuffer.Capacity));
return(nameBuffer.ToString());
};
SetParamValue = (device, value) =>
{
var name = (string)value;
SdkError.ThrowIfError(device_set_Name(device.DevicePtr, name));
};
break;
case Parameter.State:
Type = typeof(DeviceState);
ReadParamValue = device =>
{
SdkError.ThrowIfError(device_read_State(device.DevicePtr, out var state));
return(state);
};
SetParamValue = (device, value) =>
{
var state = (DeviceState)value;
SdkError.ThrowIfError(device_set_State(device.DevicePtr, state));
};
break;
case Parameter.Address:
Type = typeof(string);
ReadParamValue = device =>
{
var addressBuffer = new StringBuilder(64);
SdkError.ThrowIfError(device_read_Address(device.DevicePtr, addressBuffer, (IntPtr)addressBuffer.Capacity));
return(addressBuffer.ToString());
};
SetParamValue = (device, value) =>
{
var address = (string)value;
SdkError.ThrowIfError(device_set_Address(device.DevicePtr, address));
};
break;
case Parameter.SerialNumber:
Type = typeof(string);
ReadParamValue = device =>
{
var stringBuilder = new StringBuilder(64);
SdkError.ThrowIfError(device_read_SerialNumber(device.DevicePtr, stringBuilder, (IntPtr)stringBuilder.Capacity));
return(stringBuilder.ToString());
};
SetParamValue = (device, value) =>
{
var serial = (string)value;
SdkError.ThrowIfError(device_set_SerialNumber(device.DevicePtr, serial));
};
break;
case Parameter.HardwareFilterState:
Type = typeof(bool);
ReadParamValue = device =>
{
SdkError.ThrowIfError(device_read_HardwareFilterState(device.DevicePtr, out var isEnabled));
return(isEnabled);
};
SetParamValue = (device, value) =>
{
var filterState = (bool)value;
SdkError.ThrowIfError(device_set_HardwareFilterState(device.DevicePtr, filterState));
};
break;
case Parameter.FirmwareMode:
Type = typeof(FirmwareMode);
ReadParamValue = device =>
{
SdkError.ThrowIfError(device_read_FirmwareMode(device.DevicePtr, out var firmwareMode));
return(firmwareMode);
};
SetParamValue = (device, value) =>
{
var firmwareMode = (FirmwareMode)value;
SdkError.ThrowIfError(device_set_FirmwareMode(device.DevicePtr, firmwareMode));
};
break;
case Parameter.SamplingFrequency:
Type = typeof(SamplingFrequency);
ReadParamValue = device =>
{
SdkError.ThrowIfError(device_read_SamplingFrequency(device.DevicePtr, out var samplingFrequency));
return(samplingFrequency);
};
SetParamValue = (device, value) =>
{
var samplingFrequency = (SamplingFrequency)value;
SdkError.ThrowIfError(device_set_SamplingFrequency(device.DevicePtr, samplingFrequency));
};
break;
case Parameter.Gain:
Type = typeof(Gain);
ReadParamValue = device =>
{
SdkError.ThrowIfError(device_read_Gain(device.DevicePtr, out var gain));
return(gain);
};
SetParamValue = (device, value) =>
{
var gain = (Gain)value;
SdkError.ThrowIfError(device_set_Gain(device.DevicePtr, gain));
};
break;
case Parameter.Offset:
Type = typeof(byte);
ReadParamValue = device =>
{
SdkError.ThrowIfError(device_read_Offset(device.DevicePtr, out var offset));
return(offset);
};
SetParamValue = (device, value) =>
{
var offset = (byte)value;
SdkError.ThrowIfError(device_set_Offset(device.DevicePtr, offset));
};
break;
case Parameter.ExternalSwitchState:
Type = typeof(ExternalSwitchInput);
ReadParamValue = device =>
{
SdkError.ThrowIfError(device_read_ExternalSwitchState(device.DevicePtr, out var externalSwitchInput));
return(externalSwitchInput);
};
SetParamValue = (device, value) =>
{
var externalSwitch = (ExternalSwitchInput)value;
SdkError.ThrowIfError(device_set_ExternalSwitchState(device.DevicePtr, externalSwitch));
};
break;
case Parameter.ADCInputState:
Type = typeof(ADCInput);
ReadParamValue = device =>
{
SdkError.ThrowIfError(device_read_ADCInputState(device.DevicePtr, out var adcInput));
return(adcInput);
};
SetParamValue = (device, value) =>
{
var adcInput = (ADCInput)value;
SdkError.ThrowIfError(device_set_ADCInputState(device.DevicePtr, adcInput));
};
break;
case Parameter.AccelerometerSens:
Type = typeof(AccelerometerSensitivity);
ReadParamValue = device =>
{
SdkError.ThrowIfError(device_read_AccelerometerSens(device.DevicePtr, out var accelerometerSensitivity));
return(accelerometerSensitivity);
};
SetParamValue = (device, value) =>
{
var accelerometerSensitivity = (AccelerometerSensitivity)value;
SdkError.ThrowIfError(device_set_AccelerometerSens(device.DevicePtr, accelerometerSensitivity));
};
break;
case Parameter.GyroscopeSens:
Type = typeof(GyroscopeSensitivity);
ReadParamValue = device =>
{
SdkError.ThrowIfError(device_read_GyroscopeSens(device.DevicePtr, out var gyroscopeSensitivity));
return(gyroscopeSensitivity);
};
SetParamValue = (device, value) =>
{
var gyroscopeSensitivity = (GyroscopeSensitivity)value;
SdkError.ThrowIfError(device_set_GyroscopeSens(device.DevicePtr, gyroscopeSensitivity));
};
break;
case Parameter.StimulatorAndMAState:
Type = typeof(StimulationDeviceState);
ReadParamValue = device =>
{
SdkError.ThrowIfError(device_read_StimulatorAndMAState(device.DevicePtr, out var state));
return(state);
};
SetParamValue = (device, value) => throw new InvalidOperationException("Unable to set parameter stimulation and MA state. Use appropriate command to change state");
break;
case Parameter.StimulatorParamPack:
Type = typeof(StimulationParams);
ReadParamValue = device =>
{
SdkError.ThrowIfError(device_read_StimulatorParamPack(device.DevicePtr, out var stimulationParams));
return(stimulationParams);
};
SetParamValue = (device, value) =>
{
var stimulationParams = (StimulationParams)value;
SdkError.ThrowIfError(device_set_StimulatorParamPack(device.DevicePtr, stimulationParams));
};
break;
case Parameter.MotionAssistantParamPack:
Type = typeof(MotionAssistantParams);
ReadParamValue = device =>
{
SdkError.ThrowIfError(device_read_MotionAssistantParamPack(device.DevicePtr, out var motionAssistantParams));
return(motionAssistantParams);
};
SetParamValue = (device, value) =>
{
var motionAssistantParams = (MotionAssistantParams)value;
SdkError.ThrowIfError(device_set_MotionAssistantParamPack(device.DevicePtr, motionAssistantParams));
};
break;
case Parameter.FirmwareVersion:
Type = typeof(FirmwareVersion);
ReadParamValue = device =>
{
SdkError.ThrowIfError(device_read_FirmwareVersion(device.DevicePtr, out var firmwareVersion));
return(firmwareVersion);
};
SetParamValue = (device, value) => throw new InvalidOperationException("Unable to set firmware version. Parameter is read-only.");
break;
default:
throw new ArgumentOutOfRangeException(nameof(parameter), parameter, null);
}
}
public void Execute(Command command)
{
SdkError.ThrowIfError(device_execute(DevicePtr, command));
}
public void Disconnect()
{
SdkError.ThrowIfError(device_disconnect(DevicePtr));
}
