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