def test_ring_buffer():
tt = ThreadedDAQ(live_flag=mp.Value('b', False),
run_flag=mp.Value('b', True),
properties=None,
task_info='OpenModal Impact_',
trigger=False)
tt.samples_per_channel = 10
tt.number_of_channels = 2
tt.trigger_level = 3.5
tt.pre_trigger_samples = 5
tt.exc_channel = 0
tt.ring_buffer = RingBuffer.RingBuffer(tt.number_of_channels,
tt.samples_per_channel)
tt.samples_left_to_acquire = tt.samples_per_channel
tt.internal_trigger = False
_ = np.arange(tt.samples_per_channel)
data = np.array([_, _ + 0.1])
tt._add_data_if_triggered(data)
print(tt.ring_buffer.get())
print(tt.samples_left_to_acquire)
_ += len(_)
data = np.array([_, _ + 0.1])
tt._add_data_if_triggered(data)
print(tt.ring_buffer.get())
print(tt.samples_left_to_acquire)
def __init__(self, ms_period=500, dataWindowLength=None, com='COM3', baud=115200, verbose=False, timeout=10, data_updated_callback=None):
self.verbose = verbose
self.ms_period = ms_period
self.running = False
self.lock = threading.Lock()
# The default is large enough to store ten seconds of a data
if dataWindowLength is None:
self.dataWindow = RingBuffer(int(np.round(1000.0*10.0/float(ms_period))),2);
else:
self.dataWindow = RingBuffer(int(dataWindowLength),2);
self.timeout = timeout
self.interruptCheckPeriod = 1
self.serial = serial.Serial(port=com,baudrate=baud, timeout=self.timeout)
self.log("Set up serial port %s\n"%(self.serial))
self.updatePeriod(ms_period)
self.workerThread = None
self.data_updated_callback = data_updated_callback
def detect_beats(data,
frame_rate,
block_size=1024,
buffer_size_seconds=1,
scale=True) -> list:
if scale:
data = normalize(data)
# init ring buffer
frames = frame_rate * buffer_size_seconds
buffer_size = frames // block_size
index = 0
ring_buffer = RingBuffer.RingBuffer(buffer_size)
peaks = []
while index < len(data) - block_size:
# calculate current energy
block = data[index:index + block_size]
energy = calculate_energy(block)
ring_buffer.put(energy)
values = ring_buffer.values()[:-1]
# calculate average energy in buffer
# todo: save sum in buffer and change if new value is inserted
avg = sum(values) / len(values)
# calculate variance
variance = sum([np.square(e - avg) for e in values]) / buffer_size
c = (-0.0000015 * variance) + 1.5142857
# if current energy over threshold -> add to peaks
index_last_peak = peaks[-1] if len(peaks) != 0 else 0
delta = index - index_last_peak
min_delta = frame_rate * 0.2
if ring_buffer.is_ready() and delta >= min_delta and energy > avg * c:
peaks.append(index)
index += block_size
return peaks
def inject_properties(self, properties):
"""Get fresh arguments to the function before starting the measurement."""
self.type = properties['excitation_type']
self.task = DAQTask.DAQTask(properties['task_name'])
self.sampling_rate = self.task.sample_rate
self.task_info.send(self.sampling_rate)
self.channel_list = self.task.channel_list
self.samples_per_channel = self.task.samples_per_ch
self.number_of_channels = self.task.number_of_ch
self.exc_channel = properties['exc_channel']
self.trigger_level = properties['trigger_level']
self.pre_trigger_samples = properties['pre_trigger_samples']
if properties['samples_per_channel'] is 'auto':
self.samples_per_channel = self.task.samples_per_ch
else:
self.samples_per_channel = properties['samples_per_channel']
self.samples_left_to_acquire = self.samples_per_channel
# Reinitialize pipe always -- it is closed when measurement is stopped.
self.measured_data = properties['measured_data_pipe']
self.random_chunk = properties['random_chunk_pipe']
self.ring_buffer = RingBuffer.RingBuffer(self.number_of_channels,
self.samples_per_channel)
from RingBuffer import *
from CamThread import *
import numpy as np
import cv2
USBCam = cv2.VideoCapture(0)
sem = threading.Semaphore()
TestBuffer = RingBuffer()
TestCam = CamThread(USBCam, sem)
def main():
TestCam.RunThread(1, TestBuffer)
if __name__ == '__main__':
main()
#cv2.imshow('Feed', TestBuffer.Get())
USBCam.release()
ucv2.destroyAllWindows()
from CamThread import *
from FileIOThread import *
from RingBuffer import *
#########################################
## Initializations
#########################################
USBCam = cv2.VideoCapture(0)
Mutex = threading.Semaphore()
CamCycle = 0.01
FileCycle = 0.02
MaxFrames = 20
ImgBuffer = RingBuffer()
CamThread = CamThread(USBCam, CamCycle)
FileThread = IOFileThread(FileCycle)
#########################################
#########################################
## Main Program
#########################################
def main():
CamThread.RunThread(MaxFrames, ImgBuffer, Mutex)
FileThread.RunThread(MaxFrames, ImgBuffer, Mutex)
if __name__ == '__main__':
main()
def __init__(self, channels, dataWindowLength=None, sampleRate=2000.0, bufferSize=None, sampleEvery=None, timeout=None, data_updated_callback=None, debug=0):
Task.__init__(self)
self.debug = debug
self.numChans = len(channels)
self.timeStarted = -1
self.timeStopped = -1
self.data_updated_callback = data_updated_callback
devicesReset = []
for chan in channels:
if chan.deviceName not in devicesReset:
if self.debug > 0: print "Resetting device %s" % (chan.deviceName)
DAQmxResetDevice(chan.deviceName)
devicesReset.append(chan.deviceName)
self.CreateAIVoltageChan(chan.device,
chan.name,
chan.termConf,
chan.rangemin,
chan.rangemax,
chan.valType,
chan.units)
self.sampleRate = float(sampleRate)
# The small memory buffer in which the samples go when they are read from the device.
# The default is to make the buffer large enough to store a half second of data
if bufferSize is None:
self.bufferSize = int(self.numChans*np.round(self.sampleRate/2.0))
else:
self.bufferSize = int(bufferSize)
self.buffer = np.zeros(self.bufferSize)
# The larger memory buffer to which the samples are added, for later viewing.
# The default is large enough to store ten seconds of a data
if dataWindowLength is None:
self.dataWindow = RingBuffer(np.round(self.sampleRate*10.0),len(channels)+1);
else:
self.dataWindow = RingBuffer(dataWindowLength,len(channels)+1);
# The default is chosen such that the buffer is half full when it is emptied
if sampleEvery is None:
self.sampleEvery = int(max(math.floor(math.floor(self.bufferSize/(self.numChans))/2.0),1))
else:
self.sampleEvery = int(sampleEvery)
if timeout is None:
self.timeout = float(self.sampleEvery)/self.sampleRate
else:
self.timeout = float(timeout)
self.CfgSampClkTiming("OnboardClock",
self.sampleRate,
DAQmx_Val_Rising,
DAQmx_Val_ContSamps,
self.bufferSize)
self.AutoRegisterEveryNSamplesEvent(DAQmx_Val_Acquired_Into_Buffer,
self.sampleEvery,
0)
self.AutoRegisterDoneEvent(0)
def setUp(self):
self._rb = RingBuffer()
class MultiChannelAITask(Task):
"""Class to create a multi-channel analog input
The channels must be a list of AIChannelSpec objects.
"""
def __init__(self, channels, dataWindowLength=None, sampleRate=10000.0, bufferSize=None, sampleEvery=None, timeout=None, data_updated_callback=None, debug=0):
Task.__init__(self)
self.debug = debug
self.numChans = len(channels)
self.timeStarted = -1
self.timeStopped = -1
self.data_updated_callback = data_updated_callback
devicesReset = []
for chan in channels:
if chan.deviceName not in devicesReset:
if self.debug > 0: print "Resetting device %s" % (chan.deviceName)
DAQmxResetDevice(chan.deviceName)
devicesReset.append(chan.deviceName)
self.CreateAIVoltageChan(chan.device,
chan.name,
chan.termConf,
chan.rangemin,
chan.rangemax,
chan.valType,
chan.units)
self.sampleRate = float(sampleRate)
# The small memory buffer in which the samples go when they are read from the device.
# The default is to make the buffer large enough to store a half second of data
if bufferSize is None:
self.bufferSize = int(self.numChans*np.round(self.sampleRate/2.0))
else:
self.bufferSize = int(bufferSize)
self.buffer = np.zeros(self.bufferSize)
# The larger memory buffer to which the samples are added, for later viewing.
# The default is large enough to store ten seconds of a data
if dataWindowLength is None:
self.dataWindow = RingBuffer(np.round(self.sampleRate*10.0),len(channels)+1);
else:
self.dataWindow = RingBuffer(dataWindowLength,len(channels)+1);
# The default is chosen such that the buffer is half full when it is emptied
if sampleEvery is None:
self.sampleEvery = int(max(math.floor(math.floor(self.bufferSize/(self.numChans))/2.0),1))
else:
self.sampleEvery = int(sampleEvery)
if timeout is None:
self.timeout = float(self.sampleEvery)/self.sampleRate
else:
self.timeout = float(timeout)
self.CfgSampClkTiming("OnboardClock",
self.sampleRate,
DAQmx_Val_Rising,
DAQmx_Val_ContSamps,
self.bufferSize)
self.AutoRegisterEveryNSamplesEvent(DAQmx_Val_Acquired_Into_Buffer,
self.sampleEvery,
0)
self.AutoRegisterDoneEvent(0)
def EveryNCallback(self):
read = int32()
self.ReadAnalogF64(self.sampleEvery,
self.timeout,
DAQmx_Val_GroupByScanNumber,
self.buffer,
self.bufferSize,
byref(read),
None)
endTime = time.time()
numRead = int(read.value)
if(numRead != self.sampleEvery):
print '%d is not %d'%(numRead, self.sampleEvery)
return -1
startTime = endTime - float(numRead - 1)/self.sampleRate
timeVector = np.linspace(startTime,endTime,numRead).reshape(numRead,1)
readPortion = self.buffer[0:numRead*self.numChans].reshape(numRead,self.numChans)
self.dataWindow.extend(np.concatenate((timeVector,readPortion),axis=1))
if not (self.data_updated_callback is None):
self.data_updated_callback(startTime,endTime,numRead)
return 0
def DoneCallback(self, status):
return 0
def StopTask(self):
self.timeStopped = time.time()
read = int32()
self.ReadAnalogF64(-1,
self.timeout,
DAQmx_Val_GroupByScanNumber,
self.buffer,
self.bufferSize,
byref(read),
None)
numRead = int(read.value)
if numRead > 0:
endTime = time.time()
startTime = endTime - float(numRead)/self.sampleRate
timeVector = np.linspace(startTime,endTime,numRead).reshape(numRead,1)
readPortion = self.buffer[0:numRead*self.numChans].reshape(numRead,self.numChans)
self.dataWindow.extend(np.concatenate((timeVector,readPortion),axis=1))
Task.StopTask(self)
def StartTask(self):
self.timeStarted = time.time()
Task.StartTask(self)
loginButton = Button(myWindow, text="Login",
command=validateLogin).grid(row=1, column=4)
myWindow.mainloop()
return username.get(), password.get(), myWindow
veritabanim, cursor = veriTabaniOlusturma()
kullaniciadi, sifre, forCloseWindow = girisEkrani(validateLogin)
veritabanim.close()
dogrulamaByte = 0x03
ikinciDogrulamaByte = 0x01
sonKontrolByte = 0x0A
myRingBuffer = RingBuffer.RingBuffer(20)
myRingBufferY = RingBuffer.RingBuffer(20)
myRingBufferZ = RingBuffer.RingBuffer(20)
fig = plt.figure()
axline = fig.add_subplot(1, 1, 1)
ser = serial.Serial(port='COM5',
baudrate=9600,
parity=serial.PARITY_ODD,
stopbits=serial.STOPBITS_TWO,
bytesize=serial.SEVENBITS)
Xekseni = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
]
Yekseni = [
def setUp(self): self._rb = RingBuffer()
class TestRingBuffer(unittest.TestCase):
def setUp(self):
self._rb = RingBuffer()
def tearDown(self):
OpenRTM_aist.Manager.instance().shutdownManager()
return
def test_init(self):
prop = OpenRTM_aist.Properties()
prop.setProperty("length","5")
prop.setProperty("write.full_policy","overwrite")
#prop.setProperty("write.full_policy","do_nothing")
#prop.setProperty("write.full_policy","block")
prop.setProperty("write.timeout","5.0")
prop.setProperty("read.full_policy","overwrite")
#prop.setProperty("read.full_policy","do_nothing")
#prop.setProperty("read.full_policy","block")
prop.setProperty("read.timeout","5.0")
self._rb.init(prop)
self.assertEqual(self._rb.length(),5)
return
def test_length(self):
self.assertEqual(self._rb.length(), 8)
self.assertEqual(self._rb.length(7), OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.length(), 7)
self.assertEqual(self._rb.length(0), OpenRTM_aist.BufferStatus.NOT_SUPPORTED)
self.assertEqual(self._rb.length(-1), OpenRTM_aist.BufferStatus.NOT_SUPPORTED)
self.assertEqual(self._rb.length(1), OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.length(), 1)
return
def test_reset(self):
prop = OpenRTM_aist.Properties()
prop.setProperty("length","5")
prop.setProperty("write.full_policy","overwrite")
#prop.setProperty("write.full_policy","do_nothing")
#prop.setProperty("write.full_policy","block")
prop.setProperty("write.timeout","5.0")
prop.setProperty("read.full_policy","overwrite")
#prop.setProperty("read.full_policy","do_nothing")
#prop.setProperty("read.full_policy","block")
prop.setProperty("read.timeout","5.0")
self._rb.init(prop)
self.assertEqual(self._rb.write(123), OpenRTM_aist.BufferStatus.BUFFER_OK)
value = [None]
self.assertEqual(self._rb.read(value),OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(value[0],123)
self._rb.reset()
self.assertEqual(self._rb.read(value),OpenRTM_aist.BufferStatus.BUFFER_EMPTY)
self.assertEqual(value[0],123)
return
def test_write(self):
data=[0]
self.assertEqual(self._rb.write(1),OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0],1)
self.assertEqual(self._rb.write(2),OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0],2)
self.assertEqual(self._rb.write(3),OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0],3)
self.assertEqual(self._rb.write(4),OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0],4)
self.assertEqual(self._rb.write(5),OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0],5)
self.assertEqual(self._rb.write(6),OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0],6)
self.assertEqual(self._rb.write("string"),OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0],"string")
self.assertEqual(self._rb.write([1,2,3]),OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0],[1,2,3])
self.assertEqual(self._rb.write(0.12345),OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0],0.12345)
for i in range(8):
self.assertEqual(self._rb.write(0.12345,1,0),OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.write(0.12345,1,0),OpenRTM_aist.BufferStatus.TIMEOUT)
def test_read(self):
data=[0]
self.assertEqual(self._rb.read(data,1,0),OpenRTM_aist.BufferStatus.TIMEOUT)
self.assertEqual(self._rb.write("string"),OpenRTM_aist.BufferStatus.BUFFER_OK)
# Failure pattern (parameter must be List object.)
# data=0
# self._rb.read(data)
self.assertEqual(self._rb.read(data),OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(data[0],"string")
self.assertEqual(self._rb.read(data,1,0),OpenRTM_aist.BufferStatus.TIMEOUT)
def test_readable(self):
data=[0]
self.assertEqual(self._rb.readable(),0)
self.assertEqual(self._rb.write("string"),OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.readable(),1)
self.assertEqual(self._rb.read(data),OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.readable(),0)
self._rb.read(data)
self.assertEqual(self._rb.readable(),0)
def test_empty(self):
data=[0]
self.assertEqual(self._rb.empty(),True)
self.assertEqual(self._rb.write("string"),OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.empty(),False)
self.assertEqual(self._rb.read(data),OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.empty(),True)
self._rb.read(data)
self.assertEqual(self._rb.empty(),True)
def COMMENTtest_isFull(self):
self.assertEqual(self._rb.isFull(),False)
def COMMENTtest_isEmpty(self):
self.assertEqual(self._rb.isEmpty(),True)
self._rb.init(0)
self.assertEqual(self._rb.isEmpty(),False)
def COMMENTtest_isNew(self):
self.assertEqual(self._rb.isNew(),False)
self._rb.init(0)
self.assertEqual(self._rb.isNew(),True)
data=[0]
self._rb.read(data)
self.assertEqual(self._rb.isNew(),False)
self.assertEqual(self._rb.write(0.12345),OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.write(0.12345),OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.write(0.12345),OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.isNew(),True)
self.assertEqual(self._rb.isNew(),True)
self.assertEqual(self._rb.isNew(),True)
def service_request(self, key, mask):
if not self.isConnected:
if self.keepalive:
print('Not connected.')
return
else:
raise RuntimeError('Not connected.')
sock = key.fileobj
data = key.data
if mask & selectors.EVENT_READ:
try:
message = sock.recv(8)
except:
if self.keepalive:
print('Cannot read message.')
message = [] # this will be handled further down
else:
raise IOError('Cannot read message.')
if message and len(message) == 8:
(version, command,
bufsize) = struct.unpack('HHI', message[0:8])
if version != VERSION:
if self.keepalive:
print('Incompatible version.')
return
else:
raise RuntimeError('Incompatible version.')
try:
payload = sock.recv(bufsize)
except:
if self.keepalive:
print('Cannot read payload.')
return
else:
raise IOError('Cannot read payload.')
if command == PUT_HDR:
self.H = Header()
self.D = None # this flushes the data
self.E = None # this flushes the events
(self.H.nChannels, self.H.nSamples, self.H.nEvents,
self.H.fSample, self.H.dataType,
bufsize) = struct.unpack('IIIfII', payload[0:24])
response = struct.pack('HHI', VERSION, PUT_OK, 0)
sock.send(response)
elif command == PUT_DAT:
if self.H != None:
(nchans, nsamples, data_type,
bufsize) = struct.unpack('IIII', payload[0:16])
if nchans != self.H.nChannels:
raise RuntimeError('Incorrect number of channels')
if data_type != self.H.dataType:
raise RuntimeError('Incorrect data type')
if self.D == None:
nbytes = int(self.H.nChannels * self.H.fSample *
self.length *
wordSize[self.H.dataType])
self.D = RingBuffer.RingBuffer(nbytes)
print('Initialized ring buffer with %d bytes' %
nbytes)
self.D.append(payload[16:])
self.H.nSamples += nsamples
response = struct.pack('HHI', VERSION, PUT_OK, 0)
else:
response = struct.pack('HHI', VERSION, PUT_ERR, 0)
# send the response to PUT_DAT
sock.send(response)
elif command == PUT_EVT:
print('PUT_EVT not implemented')
response = struct.pack('HHI', VERSION, PUT_ERR, 0)
sock.send(response)
elif command == GET_HDR:
if self.H != None:
response = struct.pack('HHI', VERSION, GET_OK, 24)
response += struct.pack('IIIfII', self.H.nChannels,
self.H.nSamples,
self.H.nEvents, self.H.fSample,
self.H.dataType, 0)
else:
response = struct.pack('HHI', VERSION, GET_ERR, 0)
# send the response to GET_HDR
sock.send(response)
elif command == GET_DAT:
if self.H != None and self.D != None and bufsize == 8:
(begsample, endsample) = struct.unpack(
'II', payload[0:8]
) # this uses inclusive, zero-based start/end indices
begbyte = int(begsample * self.H.nChannels *
wordSize[self.H.dataType])
endbyte = int((endsample + 1) * self.H.nChannels *
wordSize[self.H.dataType])
nbytes = endbyte - begbyte
try:
response = struct.pack('HHI', VERSION, GET_OK,
nbytes + 16)
response += struct.pack('IIII', self.H.nChannels,
endsample - begsample + 1,
self.H.dataType, nbytes)
response += self.D.read(
begbyte, endbyte
) # this uses exclusive, zer0-based start/end indices
except Exception as e:
response = struct.pack('HHI', VERSION, GET_ERR, 0)
else:
response = struct.pack('HHI', VERSION, GET_ERR, 0)
# send the response to GET_DAT
sock.send(response)
elif command == GET_EVT:
print('GET_EVT not implemented')
response = struct.pack('HHI', VERSION, GET_ERR, 0)
sock.send(response)
elif command == FLUSH_HDR:
if self.H != None:
self.H = None
self.D = None # this also flushes the data
self.E = None # this also flushes the events
response = struct.pack('HHI', VERSION, FLUSH_OK, 0)
else:
response = struct.pack('HHI', VERSION, FLUSH_ERR, 0)
# send the response to FLUSH_HDR
sock.send(response)
elif command == FLUSH_DAT:
if self.D != None:
self.D = None
response = struct.pack('HHI', VERSION, FLUSH_OK, 0)
else:
response = struct.pack('HHI', VERSION, FLUSH_ERR, 0)
# send the response to FLUSH_DAT
sock.send(response)
elif command == FLUSH_EVT:
if E != None:
E = None
response = struct.pack('HHI', VERSION, FLUSH_OK, 0)
else:
response = struct.pack('HHI', VERSION, FLUSH_ERR, 0)
# send the response to FLUSH_EVT
sock.send(response)
elif command == WAIT_DAT:
if self.H != None and bufsize == 12:
(nsamples, nevents,
timeout) = struct.unpack('III', payload[0:12])
timeout /= 1000.0 # in seconds
start = time.time()
response = struct.pack('HHI', VERSION, WAIT_ERR, 0)
while time.time() < (start + timeout):
if self.H.nSamples >= nsamples or self.H.nEvents >= nevents:
response = struct.pack('HHI', VERSION, WAIT_OK,
8)
response += struct.pack(
'II', self.H.nSamples, self.H.nEvents)
break
else:
time.sleep(0.010)
else:
response = struct.pack('HHI', VERSION, WAIT_ERR, 0)
# send the response to WAIT_DAT
sock.send(response)
else:
# unrecognized command
print('Command not implemented')
response = struct.pack('HHI', VERSION, 0, 0)
sock.send(response)
else:
print(f'Closing connection to {data.addr}')
self.sel.unregister(sock)
sock.close()
class FreqServer(object):
def __init__(self, ms_period=500, dataWindowLength=None, com='COM3', baud=115200, verbose=False, timeout=10, data_updated_callback=None):
self.verbose = verbose
self.ms_period = ms_period
self.running = False
self.lock = threading.Lock()
# The default is large enough to store ten seconds of a data
if dataWindowLength is None:
self.dataWindow = RingBuffer(int(np.round(1000.0*10.0/float(ms_period))),2);
else:
self.dataWindow = RingBuffer(int(dataWindowLength),2);
self.timeout = timeout
self.interruptCheckPeriod = 1
self.serial = serial.Serial(port=com,baudrate=baud, timeout=self.timeout)
self.log("Set up serial port %s\n"%(self.serial))
self.updatePeriod(ms_period)
self.workerThread = None
self.data_updated_callback = data_updated_callback
def serve(self):
while self.running:
try:
ret = self.serial.readline()[:-1]
t = time.time()
if (not (ret is None)) and (ret != ""):
self.log("Read (%s)\n"%(ret))
r = int(ret)
self.dataWindow.append(np.array([t, r]))
if not (self.data_updated_callback is None):
self.data_updated_callback(t,r)
else:
self.log("Read timed out!\n")
except:
self.workerThread = None
self.stop()
raise
self.log("Thread finished\n")
def join(self):
while self.running:
try:
self.log("Checking for interrupts...\n")
self.workerThread.join(self.interruptCheckPeriod)
except KeyboardInterrupt:
self.log("Got interrupt.\n")
self.running = False
if not (self.workerThread is None):
self.log("Waiting...\n")
self.workerThread.join()
def stop(self):
assert(self.running == True)
self.running = False
self.join()
self.lock.acquire()
self.writeCommand('S')
self.workerThread = None
self.lock.release()
def start(self, autojoin=True):
assert(self.running == False)
self.running = True
self.lock.acquire()
self.writeCommand('B')
self.workerThread = threading.Thread(target=self.serve)
self.workerThread.start()
self.lock.release()
if autojoin:
self.join()
def updatePeriod(self, ms_period, autojoin=True):
if self.running:
needsRestart = True
self.stop()
else:
needsRestart = False
self.log("Resetting device to period of %d ms.\n"%(ms_period))
self.lock.acquire()
self.writeCommand('S')
self.writeCommand('R')
bt = [(ms_period >> 8) & 0x00FF, (ms_period) & 0x00FF ]
self.writeCommand(bt)
ret = self.serial.readline()
self.ms_period = ms_period
self.lock.release()
if needsRestart:
self.log("Restarting!\n")
self.start(autojoin)
def writeCommand(self, cmd):
self.serial.write(cmd)
return self.serial.readline()
def close(self):
if self.running:
self.stop()
self.serial.close()
self.log("Closed.\n")
def log(self,string):
if self.verbose:
sys.stderr.write(string)
def __init__(self, channels, dataWindowLength=None, sampleRate=10000.0, bufferSize=None, sampleEvery=None, timeout=None, data_updated_callback=None, debug=0):
Task.__init__(self)
self.debug = debug
self.numChans = len(channels)
self.timeStarted = -1
self.timeStopped = -1
self.data_updated_callback = data_updated_callback
devicesReset = []
for chan in channels:
if chan.deviceName not in devicesReset:
if self.debug > 0: print "Resetting device %s" % (chan.deviceName)
DAQmxResetDevice(chan.deviceName)
devicesReset.append(chan.deviceName)
self.CreateAIVoltageChan(chan.device,
chan.name,
chan.termConf,
chan.rangemin,
chan.rangemax,
chan.valType,
chan.units)
self.sampleRate = float(sampleRate)
# The small memory buffer in which the samples go when they are read from the device.
# The default is to make the buffer large enough to store a half second of data
if bufferSize is None:
self.bufferSize = int(self.numChans*np.round(self.sampleRate/2.0))
else:
self.bufferSize = int(bufferSize)
self.buffer = np.zeros(self.bufferSize)
# The larger memory buffer to which the samples are added, for later viewing.
# The default is large enough to store ten seconds of a data
if dataWindowLength is None:
self.dataWindow = RingBuffer(np.round(self.sampleRate*10.0),len(channels)+1);
else:
self.dataWindow = RingBuffer(dataWindowLength,len(channels)+1);
# The default is chosen such that the buffer is half full when it is emptied
if sampleEvery is None:
self.sampleEvery = int(max(math.floor(math.floor(self.bufferSize/(self.numChans))/2.0),1))
else:
self.sampleEvery = int(sampleEvery)
if timeout is None:
self.timeout = float(self.sampleEvery)/self.sampleRate
else:
self.timeout = float(timeout)
self.CfgSampClkTiming("OnboardClock",
self.sampleRate,
DAQmx_Val_Rising,
DAQmx_Val_ContSamps,
self.bufferSize)
self.AutoRegisterEveryNSamplesEvent(DAQmx_Val_Acquired_Into_Buffer,
self.sampleEvery,
0)
self.AutoRegisterDoneEvent(0)
class TestRingBuffer(unittest.TestCase):
def setUp(self):
self._rb = RingBuffer()
def tearDown(self):
OpenRTM_aist.Manager.instance().shutdownManager()
return
def test_init(self):
prop = OpenRTM_aist.Properties()
prop.setProperty("length", "5")
prop.setProperty("write.full_policy", "overwrite")
#prop.setProperty("write.full_policy","do_nothing")
#prop.setProperty("write.full_policy","block")
prop.setProperty("write.timeout", "5.0")
prop.setProperty("read.full_policy", "overwrite")
#prop.setProperty("read.full_policy","do_nothing")
#prop.setProperty("read.full_policy","block")
prop.setProperty("read.timeout", "5.0")
self._rb.init(prop)
self.assertEqual(self._rb.length(), 5)
return
def test_length(self):
self.assertEqual(self._rb.length(), 8)
self.assertEqual(self._rb.length(7),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.length(), 7)
self.assertEqual(self._rb.length(0),
OpenRTM_aist.BufferStatus.NOT_SUPPORTED)
self.assertEqual(self._rb.length(-1),
OpenRTM_aist.BufferStatus.NOT_SUPPORTED)
self.assertEqual(self._rb.length(1),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.length(), 1)
return
def test_reset(self):
prop = OpenRTM_aist.Properties()
prop.setProperty("length", "5")
prop.setProperty("write.full_policy", "overwrite")
#prop.setProperty("write.full_policy","do_nothing")
#prop.setProperty("write.full_policy","block")
prop.setProperty("write.timeout", "5.0")
prop.setProperty("read.full_policy", "overwrite")
#prop.setProperty("read.full_policy","do_nothing")
#prop.setProperty("read.full_policy","block")
prop.setProperty("read.timeout", "5.0")
self._rb.init(prop)
self.assertEqual(self._rb.write(123),
OpenRTM_aist.BufferStatus.BUFFER_OK)
value = [None]
self.assertEqual(self._rb.read(value),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(value[0], 123)
self._rb.reset()
self.assertEqual(self._rb.read(value),
OpenRTM_aist.BufferStatus.BUFFER_EMPTY)
self.assertEqual(value[0], 123)
return
def test_write(self):
data = [0]
self.assertEqual(self._rb.write(1),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0], 1)
self.assertEqual(self._rb.write(2),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0], 2)
self.assertEqual(self._rb.write(3),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0], 3)
self.assertEqual(self._rb.write(4),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0], 4)
self.assertEqual(self._rb.write(5),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0], 5)
self.assertEqual(self._rb.write(6),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0], 6)
self.assertEqual(self._rb.write("string"),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0], "string")
self.assertEqual(self._rb.write([1, 2, 3]),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0], [1, 2, 3])
self.assertEqual(self._rb.write(0.12345),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self._rb.read(data)
self.assertEqual(data[0], 0.12345)
for i in range(8):
self.assertEqual(self._rb.write(0.12345, 1, 0),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.write(0.12345, 1, 0),
OpenRTM_aist.BufferStatus.TIMEOUT)
def test_read(self):
data = [0]
self.assertEqual(self._rb.read(data, 1, 0),
OpenRTM_aist.BufferStatus.TIMEOUT)
self.assertEqual(self._rb.write("string"),
OpenRTM_aist.BufferStatus.BUFFER_OK)
# Failure pattern (parameter must be List object.)
# data=0
# self._rb.read(data)
self.assertEqual(self._rb.read(data),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(data[0], "string")
self.assertEqual(self._rb.read(data, 1, 0),
OpenRTM_aist.BufferStatus.TIMEOUT)
def test_readable(self):
data = [0]
self.assertEqual(self._rb.readable(), 0)
self.assertEqual(self._rb.write("string"),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.readable(), 1)
self.assertEqual(self._rb.read(data),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.readable(), 0)
self._rb.read(data)
self.assertEqual(self._rb.readable(), 0)
def test_empty(self):
data = [0]
self.assertEqual(self._rb.empty(), True)
self.assertEqual(self._rb.write("string"),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.empty(), False)
self.assertEqual(self._rb.read(data),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.empty(), True)
self._rb.read(data)
self.assertEqual(self._rb.empty(), True)
def COMMENTtest_isFull(self):
self.assertEqual(self._rb.isFull(), False)
def COMMENTtest_isEmpty(self):
self.assertEqual(self._rb.isEmpty(), True)
self._rb.init(0)
self.assertEqual(self._rb.isEmpty(), False)
def COMMENTtest_isNew(self):
self.assertEqual(self._rb.isNew(), False)
self._rb.init(0)
self.assertEqual(self._rb.isNew(), True)
data = [0]
self._rb.read(data)
self.assertEqual(self._rb.isNew(), False)
self.assertEqual(self._rb.write(0.12345),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.write(0.12345),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.write(0.12345),
OpenRTM_aist.BufferStatus.BUFFER_OK)
self.assertEqual(self._rb.isNew(), True)
self.assertEqual(self._rb.isNew(), True)
self.assertEqual(self._rb.isNew(), True)
class MultiChannelAITask(Task):
"""Class to create a multi-channel analog input
The channels must be a list of AIChannelSpec objects.
"""
def __init__(self, channels, dataWindowLength=None, sampleRate=2000.0, bufferSize=None, sampleEvery=None, timeout=None, data_updated_callback=None, debug=0):
Task.__init__(self)
self.debug = debug
self.numChans = len(channels)
self.timeStarted = -1
self.timeStopped = -1
self.data_updated_callback = data_updated_callback
devicesReset = []
for chan in channels:
if chan.deviceName not in devicesReset:
if self.debug > 0: print "Resetting device %s" % (chan.deviceName)
DAQmxResetDevice(chan.deviceName)
devicesReset.append(chan.deviceName)
self.CreateAIVoltageChan(chan.device,
chan.name,
chan.termConf,
chan.rangemin,
chan.rangemax,
chan.valType,
chan.units)
self.sampleRate = float(sampleRate)
# The small memory buffer in which the samples go when they are read from the device.
# The default is to make the buffer large enough to store a half second of data
if bufferSize is None:
self.bufferSize = int(self.numChans*np.round(self.sampleRate/2.0))
else:
self.bufferSize = int(bufferSize)
self.buffer = np.zeros(self.bufferSize)
# The larger memory buffer to which the samples are added, for later viewing.
# The default is large enough to store ten seconds of a data
if dataWindowLength is None:
self.dataWindow = RingBuffer(np.round(self.sampleRate*10.0),len(channels)+1);
else:
self.dataWindow = RingBuffer(dataWindowLength,len(channels)+1);
# The default is chosen such that the buffer is half full when it is emptied
if sampleEvery is None:
self.sampleEvery = int(max(math.floor(math.floor(self.bufferSize/(self.numChans))/2.0),1))
else:
self.sampleEvery = int(sampleEvery)
if timeout is None:
self.timeout = float(self.sampleEvery)/self.sampleRate
else:
self.timeout = float(timeout)
self.CfgSampClkTiming("OnboardClock",
self.sampleRate,
DAQmx_Val_Rising,
DAQmx_Val_ContSamps,
self.bufferSize)
self.AutoRegisterEveryNSamplesEvent(DAQmx_Val_Acquired_Into_Buffer,
self.sampleEvery,
0)
self.AutoRegisterDoneEvent(0)
def EveryNCallback(self):
read = int32()
self.ReadAnalogF64(self.sampleEvery,
self.timeout,
DAQmx_Val_GroupByScanNumber,
self.buffer,
self.bufferSize,
byref(read),
None)
endTime = time.time()
numRead = int(read.value)
if(numRead != self.sampleEvery):
print '%d is not %d'%(numRead, self.sampleEvery)
return -1
startTime = endTime - float(numRead - 1)/self.sampleRate
timeVector = np.linspace(startTime,endTime,numRead).reshape(numRead,1)
readPortion = self.buffer[0:numRead*self.numChans].reshape(numRead,self.numChans)
self.dataWindow.extend(np.concatenate((timeVector,readPortion),axis=1))
if not (self.data_updated_callback is None):
self.data_updated_callback(startTime,endTime,numRead)
return 0
def DoneCallback(self, status):
return 0
def StopTask(self):
self.timeStopped = time.time()
read = int32()
self.ReadAnalogF64(-1,
self.timeout,
DAQmx_Val_GroupByScanNumber,
self.buffer,
self.bufferSize,
byref(read),
None)
numRead = int(read.value)
if numRead > 0:
endTime = time.time()
startTime = endTime - float(numRead)/self.sampleRate
timeVector = np.linspace(startTime,endTime,numRead).reshape(numRead,1)
readPortion = self.buffer[0:numRead*self.numChans].reshape(numRead,self.numChans)
self.dataWindow.extend(np.concatenate((timeVector,readPortion),axis=1))
Task.StopTask(self)
def StartTask(self):
self.timeStarted = time.time()
Task.StartTask(self)
def doSim(self, trial, road, duration, tau, doEyetrack):
# Measure sample rate in order to calculate delay buffer
sample_rate = self.screen.measure_refresh_rate(2.0)
print "Sample rate: " + str(sample_rate)
#sample_rate = 60
self.doEyetrack = doEyetrack
self.pos_ring = RingBuffer(self.center,
int(math.floor(tau * sample_rate)) + 1)
print("Ring Buffer:: size: " + str(self.pos_ring.size))
if doEyetrack:
import pylink
from EyeLinkCoreGraphicsVE import EyeLinkCoreGraphicsVE
self.tracker = pylink.EyeLink()
if self.tracker == None:
print "Error: Eyelink is not connected"
sys.exit()
genv = EyeLinkCoreGraphicsVE(self.screen, self.tracker)
pylink.openGraphicsEx(genv)
#Opens the EDF file.
edfFileName = "TRIAL" + str(trial) + ".EDF"
self.tracker.openDataFile(edfFileName)
pylink.flushGetkeyQueue()
self.tracker.sendCommand("screen_pixel_coords = 0 0 %d %d" %
(VisionEgg.config.VISIONEGG_SCREEN_W,
VisionEgg.config.VISIONEGG_SCREEN_H))
tracker_software_ver = 0
eyelink_ver = self.tracker.getTrackerVersion()
if eyelink_ver == 3:
tvstr = self.tracker.getTrackerVersionString()
vindex = tvstr.find("EYELINK CL")
tracker_software_ver = int(
float(tvstr[(vindex + len("EYELINK CL")):].strip()))
if eyelink_ver >= 2:
self.tracker.sendCommand("select_parser_configuration 0")
if eyelink_ver == 2: #turn off scenelink camera stuff
self.tracker.sendCommand("scene_camera_gazemap = NO")
else:
self.tracker.sendCommand("saccade_velocity_threshold = 35")
self.tracker.sendCommand(
"saccade_acceleration_threshold = 9500")
# set EDF file contents
self.tracker.sendCommand(
"file_event_filter = LEFT,RIGHT,FIXATION,SACCADE,BLINK,MESSAGE,BUTTON"
)
if tracker_software_ver >= 4:
self.tracker.sendCommand(
"file_sample_data = LEFT,RIGHT,GAZE,AREA,GAZERES,STATUS,HTARGET"
)
else:
self.tracker.sendCommand(
"file_sample_data = LEFT,RIGHT,GAZE,AREA,GAZERES,STATUS")
# set link data (used for gaze cursor)
self.tracker.sendCommand(
"link_event_filter = LEFT,RIGHT,FIXATION,SACCADE,BLINK,BUTTON")
if tracker_software_ver >= 4:
self.tracker.sendCommand(
"link_sample_data = LEFT,RIGHT,GAZE,GAZERES,AREA,STATUS,HTARGET"
)
else:
self.tracker.sendCommand(
"link_sample_data = LEFT,RIGHT,GAZE,GAZERES,AREA,STATUS")
if not self.doneSetup:
self.tracker.doTrackerSetup()
self.doneSetup = True
else:
while 1:
try:
error = self.tracker.doDriftCorrect(
self.screen.size[0] / 2, self.screen.size[1] / 2,
1, 1)
if error != 27: # ?? from example
break
else:
self.tracker.doTrackerSetup()
except:
break
self.screen.parameters.bgcolor = 106.0 / 255.0, 147.0 / 255.0, 0.0
# Load road data from file and create an image
roadArray = numpy.loadtxt('road' + str(road) + '.txt')
# Convert to a Path
roadPath = ImagePath.Path(
map(lambda xy: (xy[0], xy[1]), roadArray.tolist()))
# Use Path to create a plot of the road
im = Image.new("RGB", (2000, 100), (50, 50, 50))
draw = ImageDraw.Draw(im)
# draw each side of the road separately
draw.line(roadPath[:4000], fill=(200, 200, 200))
draw.line(roadPath[4000:], fill=(200, 200, 200))
del draw
# Lay out a road texture in the x-z plane
roadTexture = Texture(im)
del im
eye_height = 2.5
vertices = [(-10, -eye_height, 0), (-10, -eye_height, -1000),
(10, -eye_height, 0), (10, -eye_height, -1000)]
rect = TextureStimulus3D(texture=roadTexture,
lowerleft=vertices[0],
lowerright=vertices[1],
upperleft=vertices[2],
upperright=vertices[3])
# We will use these later for our camera transforms
self.camera_matrix = ModelView()
self.frame_timer = FrameTimer()
self.outf = open(
'steersim-' + str(trial) + '-' + str(road) + '-out.txt', 'wb')
# Vewport for the road
viewport3D = Viewport(
screen=self.screen,
projection=SimplePerspectiveProjection(fov_x=75.2),
camera_matrix=self.camera_matrix,
stimuli=[rect])
# Construct a sky
sky_l = 0
sky_r = self.screen.size[0]
sky_t = self.screen.size[1]
sky_b = self.screen.size[1] / 2
sky_vertices = [(sky_l, sky_t, 0), (sky_r, sky_t, 0),
(sky_r, sky_b, 0), (sky_l, sky_b, 0)]
sky = Rectangle3D(color=(144.0 / 255.0, 190.0 / 255.0, 1.0),
vertex1=sky_vertices[0],
vertex2=sky_vertices[1],
vertex3=sky_vertices[2],
vertex4=sky_vertices[3])
wheelTexture = Texture('wheel.png')
self.wheel = TextureStimulus(texture=wheelTexture,
internal_format=gl.GL_RGBA,
position=(self.center, -75),
anchor='center')
# display the sky in its own viewport
viewport2D = Viewport(screen=self.screen)
viewport2D.parameters.stimuli = [sky, self.wheel]
self.init_state()
askText = Text(text='Press a key to start',
anchor='center',
position=(self.center, self.screen.size[1] / 2))
splash = Viewport(screen=self.screen)
splash.parameters.stimuli = [askText]
self.askForNext = Presentation(go_duration=(0.5, 'seconds'),
viewports=[splash])
self.askForNext.add_controller(
None, None, FunctionController(during_go_func=self.wait_for_key))
self.askForNext.parameters.enter_go_loop = True
self.askForNext.run_forever()
self.simPres = Presentation(go_duration=(duration, 'seconds'),
viewports=[viewport3D, viewport2D],
handle_event_callbacks=[
(pygame.KEYDOWN, self.check_keypress)
])
self.simPres.add_controller(
None, None, FunctionController(during_go_func=self.update))
if doEyetrack:
startTime = pylink.currentTime()
self.tracker.sendMessage("SYNCTIME %d" %
(pylink.currentTime() - startTime))
error = self.tracker.startRecording(1, 1, 1, 1)
self.tracker.sendMessage("PRES %d START" % (trial))
self.simPres.go()
if doEyetrack:
self.tracker.sendMessage("PRES %d END" % (trial))
self.tracker.stopRecording()
# File transfer and cleanup!
self.tracker.setOfflineMode()
pylink.msecDelay(500)
#Close the file and transfer it to Display PC
self.tracker.closeDataFile()
self.tracker.receiveDataFile(edfFileName, edfFileName)
self.outf.close()
if self.quit:
raise SystemExit
print("Check firmware version")
print("exiting...")
sys.exit()
# open the port for communication, wait 2 seconds for Arduino to initialize
openedSensePort = serial.Serial(sensorPort[0], baudrate=57600, timeout=0.1)
time.sleep(2)
# get hardware level information for each sensor (number of sensors,
# number of bits, ADC reference voltage)
nSensors = int(transeiveCmd(openedSensePort, "GET_N_SENSORS")[2])
nBits = int(transeiveCmd(openedSensePort, "GET_ADCBITS")[2])
adcRef = float(transeiveCmd(openedSensePort, "GET_ADCREFVOLT")[2])
# define our data buffer for sensor 1 and the time buffer to hold the times
timeBuffer = rb.RingBuffer(RINGBUFFERSIZE)
dataBufferList = []
# ring buffers for sensor data points
for num in range(0, nSensors):
dataBufferList.append(rb.RingBuffer(RINGBUFFERSIZE))
# =============== Begin Worker Thread for Sensor Data ===============
# close the sensor port to ensure no crossover between threads
openedSensePort.close()
closedSensePort = sensorPort[0]
worker = Process(target=readSensor, \
args=(dataQueue, timeQueue, fileQueue, closedSensePort, nSensors, ))
worker.daemon = True
