def __init__(self,
n_df=None,
s_port=None,
baud_rate=115200,
buffered=True,
buf_size=1.,
calibration_file=None):
# If n_df is not given assume 18-DOF Cyberglove but issue warning
if n_df == None:
warnings.warn("Cyberglove: number of DOFs not given, assuming 18.")
self.n_df = 18
else:
if n_df not in [18, 22]:
raise ValueError(
"Cyberglove can have either 18 or 22 degrees-of-freedom.")
else:
self.n_df = n_df
# if port is not given use the first one available
if s_port == None:
try:
s_port = serial.tools.list_ports.comports().next()[0]
except StopIteration:
print("No serial ports found.")
self.si = serial.Serial(port=None,
baudrate=baud_rate,
timeout=0.05,
writeTimeout=0.05)
self.si.port = s_port
self.buffered = buffered
self.buf_size = buf_size
self.calibration_file = calibration_file
self.__srate = 100 # Hardware sampling rate. TODO: Double-check this is correct
if self.n_df == 18:
self.__bytesPerRead = 20 # First and last bytes are reserved
elif self.n_df == 22:
self.__bytesPerRead = 24 # First and last bytes are reserved
if self.buffered:
self.__buf_size_samples = int(np.ceil(self.__srate *
self.buf_size))
self.data = Buffer((self.__buf_size_samples, self.n_df))
self.time = Buffer((self.__buf_size_samples, ))
else:
self.data = np.zeros((self.n_df, ))
self.time = np.zeros((1, ))
if self.calibration_file is None:
self.calibration_ = False
else:
self.calibration_ = True
(self.calibration_offset_,
self.calibration_gain_) = load_calibration_file(
calibration_file, self.n_df)
def flush(self):
''' reset buffer '''
if self.buffered:
self.data = [Buffer((self._emgBufSize, self.__numSensors)), \
Buffer((self._imuBufSize, self.__numSensors*self.__signalsPerImuSensor))]
self.time = [Buffer((self._emgBufSize, 1)), \
Buffer((self._imuBufSize, 1))]
else:
self.data = [np.zeros((self.__numSensors,)), np.zeros((self.__numSensors*self.__signalsPerImuSensor,))]
self.time = [np.zeros((1,)), np.zeros((1,))]
def __init__(self,
buffered=True,
host_ip='127.0.0.1',
bufsize=1.,
samplesPerPacket=1,
imu_type=None):
self.host = host_ip
self.dataPort = 50043
self.imuPort = 50044
self.sdkPort = 50040
self.emg = None
self.imu = None
self.sdk = None
self.buffered = buffered
self.bufsize = bufsize
self.samplesPerPacket = samplesPerPacket
self.imuType = 'raw' if imu_type is None else imu_type
self.__numSensors = 16
self.__emgRate = 2000
self.__imuRate = 148.148148148148148148148148148148148148
self.__bytesPerSample = 4
self.__signalsPerEmgSensor = 1
if self.imuType == 'raw':
self.__signalsPerImuSensor = 9
self.__signalsPerImuSensorTransmitted = 9
elif self.imuType == 'quat':
self.__signalsPerImuSensor = 4
self.__signalsPerImuSensorTransmitted = 5
elif self.imuType == 'pry':
self.__signalsPerImuSensor = 3
self.__signalsPerImuSensorTransmitted = 5
else:
raise ValueError('Unrecognised type of IMU transmission.')
if self.buffered:
self._emgBufSize = int(np.ceil(self.__emgRate * self.bufsize))
self._imuBufSize = int(np.ceil(self.__imuRate * self.bufsize))
self.data = [Buffer((self._emgBufSize, self.__numSensors)), \
Buffer((self._imuBufSize, self.__numSensors * self.__signalsPerImuSensor))]
self.time = [Buffer((self._emgBufSize, 1)), \
Buffer((self._imuBufSize, 1))]
else:
self.data = [np.zeros((self.__numSensors,)), \
np.zeros((self.__numSensors * self.__signalsPerImuSensor,))]
self.time = [np.zeros((1, )), np.zeros((1, ))]
self.exitFlag = True
def __init__(self, shape, k, weights=None):
self.shape = shape
self.__check_k_weights(k, weights)
self.k = k
self.weights = np.ones((k,)) if weights is None else weights
self.buffer_ = Buffer(size=self.__get_buf_size())