def record(state, amp_name, amp_serial, record_dir, eeg_only):
# set data file name
filename = time.strftime(record_dir + "/%Y%m%d-%H%M%S-raw.pcl",
time.localtime())
qc.print_c('>> Output file: %s' % (filename), 'W')
# test writability
try:
qc.make_dirs(record_dir)
open(
filename,
'w').write('The data will written when the recording is finished.')
except:
raise RuntimeError('Problem writing to %s. Check permission.' %
filename)
# start a server for sending out data filename when software trigger is used
outlet = start_server('StreamRecorderInfo', channel_format='string',\
source_id=filename, stype='Markers')
# connect to EEG stream server
sr = StreamReceiver(amp_name=amp_name,
amp_serial=amp_serial,
eeg_only=eeg_only)
# start recording
qc.print_c('\n>> Recording started (PID %d).' % os.getpid(), 'W')
qc.print_c('\n>> Press Enter to stop recording', 'G')
tm = qc.Timer(autoreset=True)
next_sec = 1
while state.value == 1:
sr.acquire()
if sr.get_buflen() > next_sec:
duration = str(datetime.timedelta(seconds=int(sr.get_buflen())))
print('RECORDING %s' % duration)
next_sec += 1
tm.sleep_atleast(0.01)
# record stop
qc.print_c('>> Stop requested. Copying buffer', 'G')
buffers, times = sr.get_buffer()
signals = buffers
events = None
# channels = total channels from amp, including trigger channel
data = {
'signals': signals,
'timestamps': times,
'events': events,
'sample_rate': sr.get_sample_rate(),
'channels': sr.get_num_channels(),
'ch_names': sr.get_channel_names()
}
qc.print_c('Saving raw data ...', 'W')
qc.save_obj(filename, data)
print('Saved to %s\n' % filename)
qc.print_c('Converting raw file into a fif format.', 'W')
pcl2fif(filename)
def record(recordState, amp_name, amp_serial, record_dir, eeg_only, recordLogger=logger, queue=None):
redirect_stdout_to_queue(recordLogger, queue, 'INFO')
# set data file name
timestamp = time.strftime('%Y%m%d-%H%M%S', time.localtime())
pcl_file = "%s/%s-raw.pcl" % (record_dir, timestamp)
eve_file = '%s/%s-eve.txt' % (record_dir, timestamp)
recordLogger.info('>> Output file: %s' % (pcl_file))
# test writability
try:
qc.make_dirs(record_dir)
open(pcl_file, 'w').write('The data will written when the recording is finished.')
except:
raise RuntimeError('Problem writing to %s. Check permission.' % pcl_file)
# start a server for sending out data pcl_file when software trigger is used
outlet = start_server('StreamRecorderInfo', channel_format='string',\
source_id=eve_file, stype='Markers')
# connect to EEG stream server
sr = StreamReceiver(buffer_size=0, amp_name=amp_name, amp_serial=amp_serial, eeg_only=eeg_only)
# start recording
recordLogger.info('\n>> Recording started (PID %d).' % os.getpid())
qc.print_c('\n>> Press Enter to stop recording', 'G')
tm = qc.Timer(autoreset=True)
next_sec = 1
while recordState.value == 1:
sr.acquire()
if sr.get_buflen() > next_sec:
duration = str(datetime.timedelta(seconds=int(sr.get_buflen())))
recordLogger.info('RECORDING %s' % duration)
next_sec += 1
tm.sleep_atleast(0.001)
# record stop
recordLogger.info('>> Stop requested. Copying buffer')
buffers, times = sr.get_buffer()
signals = buffers
events = None
# channels = total channels from amp, including trigger channel
data = {'signals':signals, 'timestamps':times, 'events':events,
'sample_rate':sr.get_sample_rate(), 'channels':sr.get_num_channels(),
'ch_names':sr.get_channel_names(), 'lsl_time_offset':sr.lsl_time_offset}
recordLogger.info('Saving raw data ...')
qc.save_obj(pcl_file, data)
recordLogger.info('Saved to %s\n' % pcl_file)
# automatically convert to fif and use event file if it exists (software trigger)
if os.path.exists(eve_file):
recordLogger.info('Found matching event file, adding events.')
else:
eve_file = None
recordLogger.info('Converting raw file into fif.')
pcl2fif(pcl_file, external_event=eve_file)
class RecordingFromHardWare():
def __init__(self):
self.start_recording = False
self.new_data = []
self.sr = StreamReceiver(buffer_size=0)
self.record_dir = '%s/records' % os.getcwd()
self.current_window = np.ndarray([])
self.current_time_stamps = np.ndarray([])
self.MRCP_window_size = 6
print("I RUMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN")
# =============================================================================
# def runInfinitecording(self):
# while self.start_recording:
# self.sr.acquire()
# if self.sr.get_buflen() > 20:
# duration = str(datetime.timedelta(seconds=int(self.sr.get_buflen())))
# #recordLogger.info('RECORDING %s' % duration)
# #next_sec += 1
# buffers, times = self.sr.get_buffer()
# signals = buffers
# events = None
#
# # channels = total channels from amp, including trigger channel
# data = {'signals':signals, 'timestamps':times, 'events':events,
# 'sample_rate':self.sr.get_sample_rate(), 'channels':self.sr.get_num_channels(),
# 'ch_names':self.sr.get_channel_names(), 'lsl_time_offset':self.sr.lsl_time_offset}
# print(data)
# self.new_data.append(data)
# =============================================================================
def startRecording(self):
# do some stuff
self.start_recording = True
#download_thread = threading.Thread(target=self.runInfinitecording)
recordLogger = logger
thread = threading.Thread(target=self.record)
thread.start()
def stopRecording(self):
self.start_recording = False
#Write into file
#self.new_data = []
def isRecordingIsRunning(self):
return self.start_recording
def set_MRCP_window_size(self, MRCP_window_size):
self.MRCP_window_size = MRCP_window_size
def record(self):
recordLogger = logger
#redirect_stdout_to_queue(recordLogger, 'INFO')
# set data file name
timestamp = time.strftime('%Y%m%d-%H%M%S', time.localtime())
pcl_file = "%s/%s-raw.pcl" % (self.record_dir, timestamp)
eve_file = '%s/%s-eve.txt' % (self.record_dir, timestamp)
recordLogger.info('>> Output file: %s' % (pcl_file))
# test writability
try:
qc.make_dirs(self.record_dir)
open(pcl_file, 'w').write(
'The data will written when the recording is finished.')
except:
raise RuntimeError('Problem writing to %s. Check permission.' %
pcl_file)
# start a server for sending out data pcl_file when software trigger is used
outlet = start_server('StreamRecorderInfo', channel_format='string',\
source_id=eve_file, stype='Markers')
# connect to EEG stream server
#sr = StreamReceiver(buffer_size=0, eeg_only=eeg_only)
# start recording
recordLogger.info('\n>> Recording started (PID %d).' % os.getpid())
qc.print_c('\n>> Press Enter to stop recording', 'G')
tm = qc.Timer(autoreset=True)
next_sec = 1
while self.start_recording:
self.sr.acquire()
if self.sr.get_buflen() > next_sec:
duration = str(
datetime.timedelta(seconds=int(self.sr.get_buflen())))
#recordLogger.info('RECORDING %s' % duration)
next_sec += 1
#current_buffer, current_times = self.sr.get_buffer()
self.sr.set_window_size(self.MRCP_window_size)
self.current_window, self.current_time_stamps = self.sr.get_window(
)
#print("window shape: {} time stamps shape: {}".format(self.current_window.shape, self.current_time_stamps.shape))
tm.sleep_atleast(0.001)
# record stop
recordLogger.info('>> Stop requested. Copying buffer')
buffers, times = self.sr.get_buffer()
signals = buffers
events = None
# channels = total channels from amp, including trigger channel
data = {
'signals': signals,
'timestamps': times,
'events': events,
'sample_rate': self.sr.get_sample_rate(),
'channels': self.sr.get_num_channels(),
'ch_names': self.sr.get_channel_names(),
'lsl_time_offset': self.sr.lsl_time_offset
}
print("data length : {}".format(data['signals'].shape))
self.new_data = data['signals']
recordLogger.info('Saving raw data ...')
qc.save_obj(pcl_file, data)
recordLogger.info('Saved to %s\n' % pcl_file)
# automatically convert to fif and use event file if it exists (software trigger)
if os.path.exists(eve_file):
recordLogger.info('Found matching event file, adding events.')
else:
eve_file = None
recordLogger.info('Converting raw file into fif.')
pcl2fif(pcl_file, external_event=eve_file)