Analogue fix

.gitignore

@@ -9,3 +9,5 @@ Data/
 >>>>>>> 73c6c9b7133534e9970e82c3c355c6f2e3fd1194
 TestData/020217_right_25_2_export_final.mat
 TrialBanks/
+Controllers/dist
+Controllers/build

Controllers/QueueControl.py

@@ -4,6 +4,7 @@
 from PyPulse import PulseInterface
 import scipy.io as sio
 import numpy as np
+from datetime import datetime
 
 
 class QueueWorker(QtCore.QObject):
@@ -29,44 +30,86 @@ def trial(self):
                 hardware_params = self.get_hardware_params()
                 global_params = self.get_global_params()
                 export_params = self.get_export_params()
-
+                invert_valves = []
+                if global_params['inverted_blank_off_state']:
+                    invert_valves = global_params['inverted_blank_valves']
                 pulses, t = PulseInterface.make_pulse(hardware_params['samp_rate'],
                                                       global_params['global_onset'],
                                                       global_params['global_offset'],
-                                                      trial_params)
+                                                      trial_params, invert_chan_list=invert_valves)
 
+                if hardware_params['control_carrier']:
+                    while len(pulses) < hardware_params['digital_channels']:
+                        pulses = np.append(pulses, np.zeros((1, pulses.shape[1])), axis=0)
+                    carrier_control = np.append(np.ones(pulses.shape[1]-0), np.zeros(0))
+                    pulses = np.append(pulses, carrier_control[np.newaxis], axis=0)
                 # in standard configuration we want to run each trial sequentially
                 if not self.parent.trigger_state():
-                    self.trial_daq = daq.DoAiMultiTask(hardware_params['analog_dev'], hardware_params['analog_channels'],
-                                                       hardware_params['digital_dev'], hardware_params['samp_rate'],
-                                                       len(t) / hardware_params['samp_rate'], pulses,
-                                                       hardware_params['sync_clock'])
-
-                    self.analog_data = self.trial_daq.DoTask()
+                    if hardware_params['analog_channels'] > 0:
+                        self.trial_daq = daq.DoAiMultiTask(hardware_params['analog_dev'], hardware_params['analog_channels'],
+                                                           hardware_params['digital_dev'], hardware_params['samp_rate'],
+                                                           len(t) / hardware_params['samp_rate'], pulses,
+                                                           hardware_params['sync_clock'])
+
+                        self.analog_data = self.trial_daq.DoTask()
+                    else:
+                        self.trial_daq = daq.DoCoTask(hardware_params['digital_dev'], '', hardware_params['samp_rate'],
+                                                      len(t) / hardware_params['samp_rate'], pulses)
+                        self.trial_daq.DoTask()
+                        # close_valves= daq.DoCoTask(hardware_params['digital_dev'], '', hardware_params['samp_rate'],
+                        #                               len(t) / hardware_params['samp_rate'], np.zeros((len(pulses), 10)))
+                        # close_valves.DoTask()
+                        self.analog_data = []
                 # unless the 'wait for trigger' box is checked, in which case we want to wait for our trigger in
                 else:
-                    self.trial_daq = daq.DoAiTriggeredMultiTask(hardware_params['analog_dev'],
+                    if hardware_params['analog_channels'] > 0 :
+                        self.trial_daq = daq.DoAiTriggeredMultiTask(hardware_params['analog_dev'],
                                                                 hardware_params['analog_channels'],
                                                                 hardware_params['digital_dev'],
                                                                 hardware_params['samp_rate'],
                                                                 len(t) / hardware_params['samp_rate'], pulses,
                                                                 hardware_params['sync_clock'],
                                                                 hardware_params['trigger_source'])
 
-                    self.analog_data = self.trial_daq.DoTask()
+                        self.analog_data = self.trial_daq.DoTask()
+                    else:
+                        self.trial_daq= daq.DoTriggeredCoTask(hardware_params['digital_dev'], '', hardware_params['samp_rate'], len(t) / hardware_params['samp_rate'],
+                                                              pulses, hardware_params['trigger_source'])
+                        self.trial_daq.DoTask()
+                        self.analog_data = []
 
                 # Save data
-                save_string = export_params['export_path'] + str(self.experiment.current_trial) + \
-                              export_params['export_suffix'] + '.mat'
-                sio.savemat(save_string, {'analog_data': self.analog_data, 'pulses': pulses, 't': t})
+                if export_params['save_pulses']:
+                    save_string = export_params['export_path'] + str(self.experiment.current_trial) + \
+                                  export_params['pulse_suffix'] + '.mat'
+                    sio.savemat(save_string, {'analog_data': self.analog_data, 'pulses': pulses, 't': t})
+
 
                 if self.experiment.total_trials() - self.experiment.current_trial == 1:
-                    self.parent.should_run = False
                     self.experiment.reset_trials()
-
-                if self.parent.should_run:
+                    if export_params['save_names']:
+                        names = [i[-1] for i in self.experiment.arraydata]
+                        date = datetime.today().strftime('%Y-%m-%d')
+                        time = datetime.today().strftime('%H:%M:%S')
+                        f = open(export_params['export_path']+date+export_params['trial_suffix']+'.txt', 'a')
+                        f.write(time)
+                        f.write('\n')
+                        f.write('\n'.join(names))
+                        f.write('\n')
+                        f.close()
+                    self.parent.repeats_done += 1
+                    print('repeats done ', self.parent.repeats_done)
+                    if self.parent.repeats_done == global_params['repeats']:
+                        self.parent.should_run = False
+                        self.parent.repeats_done = 0
+                    else:
+                        if global_params['shuffle_repeats']:
+                            self.experiment.randomise_trials(global_params)
+
+                elif self.parent.should_run:
                     self.experiment.advance_trial()
 
+
                 self.finished.emit()
 
 
@@ -80,6 +123,7 @@ def __init__(self, experiment, get_global_params, get_hardware_params, get_expor
         self.get_hardware_params = get_hardware_params
         self.get_export_params = get_export_params
         self.prepare_thread()
+        self.repeats_done = 0
 
         self.should_run = False
         self.trigger_control = trigger_control
@@ -95,6 +139,7 @@ def prepare_thread(self):
         self.thread.start()
 
     def start(self):
+
         if not self.should_run:
             self.should_run = True
 
@@ -108,6 +153,8 @@ def stop(self):
             self.should_run = False
 
         self.experiment.reset_trials()
+        self.repeats_done = 0
+
 
     def run_selected(self, trial):
         if not self.should_run:
@@ -116,9 +163,14 @@ def run_selected(self, trial):
             sleep(0.05)
             self.should_run = False
 
+    def run_from_selected(self, trial):
+        if not self.should_run:
+            self.should_run = True
+            self.experiment.current_trial = trial
+
+
     def finished(self):
         print("not implemented")
 
     def trigger_state(self):
         return self.trigger_control.isChecked()
-

Controllers/main.py

@@ -1,15 +1,23 @@
 import sys
+sys.path.append('C:\\Users\\warnert\\Documents\\GitHub')
+sys.path.append('C:\\Users\\warnert\\Documents\\GitHub\\PulseBoy_updated\\PulseBoy')
+sys.path.append('C:\\Users\\warnert\\Documents\\GitHub\\PulseBoy')
 
 from PyPulse import PulseInterface
 import numpy as np
 from PyQt5 import QtWidgets
-
 import Models.Experiment as Experiment
 from Controllers import QueueControl, QueueControl
+from multiprocessing import Queue, Process, Manager
 from Designs import mainDesign
 from Models import PBWidgets
+try:
+    from vipulse import StreamNSave
+except ImportError:
+    print('No camera!')
 import pickle as pickle
 import os.path
+import daqface.DAQ as daq
 
 
 # noinspection PyBroadException
@@ -44,6 +52,7 @@ def __init__(self):
         self.removeTrialButton.clicked.connect(self.remove_trial)
         self.moveUpButton.clicked.connect(self.move_trial_up)
         self.moveDownButton.clicked.connect(self.move_trial_down)
+        self.randomiseTrialsButton.clicked.connect(self.randomise_trials)
 
         self.actionSave.triggered.connect(self.save)
         self.actionLoad.triggered.connect(self.load)
@@ -58,21 +67,44 @@ def __init__(self):
         self.stopQueueButton.clicked.connect(self.queue_controller.stop)
         self.pauseQueueButton.clicked.connect(self.queue_controller.pause)
         self.runSelectedButton.clicked.connect(lambda x: self.queue_controller.run_selected(self.trialBankTable.selectionModel().selectedRows()[0].row()))
+        self.startQueueFromSelectedButton.clicked.connect(lambda x: self.queue_controller.run_from_selected(self.trialBankTable.selectionModel().selectedRows()[0].row()))
+
+        ## Camera code
+        camera_params = Manager().dict()
+        self.cameraParams = camera_params
+        self.launchCameraButton.clicked.connect(self.startStream)
+
+        self.get_camera_params()
+        self.closeCamerasButton.clicked.connect(self.terminateCameraStream)
+        self.updateCamerasButton.clicked.connect(self.get_camera_params)
+        self.closeValvesButton.clicked.connect(self.reset_all_chans)
+
+        ## Saving pulses
+        self.savePulseButton.clicked.connect(self.save_all_pulses)
+
 
     def add_valve(self, v_type='Simple', params=None):
+        position = len(self.valveBankContents.children()) - 1
         if v_type == 'Simple':
-            new_valve = PBWidgets.SimpleValveWidget(self.valveBankContents)
+            new_valve = PBWidgets.SimpleValveWidget(self.valveBankContents, position)
         elif v_type == 'Noise':
-            new_valve = PBWidgets.NoiseValveWidget(self.valveBankContents)
+            new_valve = PBWidgets.NoiseValveWidget(self.valveBankContents, position)
         elif v_type == 'Plume':
-            new_valve = PBWidgets.PlumeValveWidget(self.valveBankContents)
+            new_valve = PBWidgets.PlumeValveWidget(self.valveBankContents, position)
+        elif v_type == 'Anti Plume':
+            new_valve = PBWidgets.AntiPlumeValveWidget(self.valveBankContents, position)
+        elif v_type == 'Binary':
+            new_valve = PBWidgets.BinaryPlumeValveWidget(self.valveBankContents, position)
         else:
-            new_valve = PBWidgets.SimpleValveWidget(self.valveBankContents)
+            new_valve = PBWidgets.SimpleValveWidget(self.valveBankContents, position)
 
         if params is not None:
             new_valve.set_parameters(params)
         self.valveBankContents.layout().addWidget(new_valve)
 
+    def reset_all_chans(self):
+        daq.closeValves(self.get_hardware_params()['digital_dev'])
+
     def add_trial(self):
         n_valves = 0
         all_params = list()
@@ -120,17 +152,27 @@ def move_trial_down(self):
         if idx < len(self.trialBankModel.arraydata):
             self.select_trial(idx + 1)
 
+    def randomise_trials(self):
+        glob_params = self.get_global_params()
+        self.trialBankModel.randomise_trials(glob_params)
+
     def trial_selected(self):
         try:
             selected_trial = self.trialBankTable.selectionModel().selectedRows()[0].row()
         except:
             selected_trial = 0
 
         trial_params = self.trialBankModel.arraydata[selected_trial][1]
-
+        invert_valves = []
+        if self.invertBlankcheckBox.isChecked():
+            try:
+                invert_valves = [int(i) for i in self.blankValveEdit.text().split(',')]
+            except ValueError:
+                print('Unable to invert channels, did not understand input "%s' % self.blankValveEdit.text())
+
         pulses, t = PulseInterface.make_pulse(float(self.sampRateEdit.text()),
                                               float(self.globalOnsetEdit.text()),
-                                              float(self.globalOffsetEdit.text()), trial_params)
+                                              float(self.globalOffsetEdit.text()), trial_params, invert_chan_list=invert_valves)
 
         self.graphicsView.plotItem.clear()
         for p, pulse in enumerate(pulses):
@@ -211,26 +253,85 @@ def get_hardware_params(self):
         params['sync_clock'] = self.syncClockEdit.text()
         params['samp_rate'] = float(self.sampRateEdit.text())
         params['trigger_source'] = self.triggerInEdit.text()
+        params['control_carrier'] = self.carrierControlBox.isChecked()
+#        params['carrier_chan'] = int(self.carrierDeviceEdit.text())
 
         return params
 
     def get_global_params(self):
         params = dict()
         params['global_onset'] = float(self.globalOnsetEdit.text())
         params['global_offset'] = float(self.globalOffsetEdit.text())
+        params['repeats'] = float(self.repeatsBox.text())
+        #params['repeats_done'] = 0
+        params['shuffle_repeats'] = bool(self.shuffleRepeatsBox.isChecked())
+        params['inverted_blank_off_state'] = bool(self.invertBlankcheckBox.isChecked())
+        if params['inverted_blank_off_state']:
+            params['inverted_blank_valves'] = [int(i) for i in self.blankValveEdit.text().split(',')]
+        else:
+            params['inverted_blank_valves'] = None
 
+        params['shuffle_offset'] = int(self.shuffleOffsetlineEdit.text())
+        params['shuffle_group_size'] = int(self.shuffleGrouplineEdit.text())
+        params['shuffle_back_offset'] = int(self.shuffleBackOffsetlineEdit.text())
         return params
 
     def get_export_params(self):
         params = dict()
+        params['save_names'] = bool(self.trialNameCheckBox.isChecked())
+        params['save_pulses'] = bool(self.pulseCheckBox.isChecked())
         params['export_path'] = str(self.exportPathEdit.text())
-        params['export_suffix'] = str(self.exportSuffixEdit.text())
+        params['pulse_suffix'] = str(self.pulseSuffixEdit.text())
+        params['trial_suffix'] = str(self.trialNameSuffixEdit.text())
 
         return params
 
     def set_export_path(self):
         path = QtWidgets.QFileDialog.getExistingDirectory(self, "Choose Export Path")
         self.exportPathEdit.setText(path + '/')
+
+
+    def startStream(self):
+        self.get_camera_params()
+        self.cameraParams['runStream'] = True
+        self.cameraProcess = Process(target=StreamNSave.stream_and_save, 
+                                     args=(self.cameraParams,))
+        self.cameraProcess.daemon = True
+        self.cameraProcess.start()
+    def terminateCameraStream(self):
+        self.cameraParams['runStream'] = False
+        #self.cameraProcess.terminate()
+
+    def get_camera_params(self):
+        self.cameraParams['saveStream'] = bool(self.saveCameraVideocheckBox.isChecked())
+        self.cameraParams['showStream'] = bool(self.showStreamcheckBox.isChecked())
+        self.cameraParams['outDir'] = str(self.exportPathEdit.text())
+        self.cameraParams['cams'] = int(self.numberCamerasEdit.text())
+        self.cameraParams['cameraSuffix'] = str(self.cameraSuffixEdit.text())
+        self.cameraParams['inter_stream_interval'] = float(self.cameraSaveIntervalEdit.text())
+        self.cameraParams['recording_ind'] = bool(self.cameraSaveIconBox.isChecked())
+
+    def save_all_pulses(self):
+        global_params = self.get_global_params()
+        hardware_params = self.get_hardware_params()
+        export_params = self.get_export_params()
+        invert_valves = []
+        all_pulses = {}
+        for trial_params in self.trialBankModel.arraydata:
+            pulses, t = PulseInterface.make_pulse(hardware_params['samp_rate'],
+                                                      global_params['global_onset'],
+                                                      global_params['global_offset'],
+                                                      trial_params[1])
+            save_string = export_params['export_path'] + trial_params[-1] + '_'+export_params['pulse_suffix'] + '.npy'
+            np.save(save_string, pulses)
+            all_pulses[trial_params[-1]] = pulses
+        save_string = export_params['export_path'] + export_params['pulse_suffix'] + '.pkl'
+        #pickle.dump(all_pulses, open(save_string, 'wb'), protocol=pickle.HIGHEST_PROTOCOL)
+
+
+
+
+
 
 # Back up the reference to the exceptionhook
 sys._excepthook = sys.excepthook