def __init__(self): self.duration = None # duration in ms self.amplitude = None self.table = None # numpy array of samples self.chunks = None # table split into a list of chunks self.trigger = None self.nsamples = None self.padded = False # whether or not the sound was padded with zeros when chunked self.continuous = False self.fs = jackclient.FS self.blocksize = jackclient.BLOCKSIZE self.server = jackclient.SERVER self.q = jackclient.QUEUE self.q_lock = jackclient.Q_LOCK self.play_evt = jackclient.PLAY self.stop_evt = jackclient.STOP self.continuous_flag = jackclient.CONTINUOUS self.continuous_q = jackclient.CONTINUOUS_QUEUE self.continuous_loop = jackclient.CONTINUOUS_LOOP self.quitting = threading.Event() self.initialized = False self.buffered = False self.buffered_continuous = False self.logger = init_logger(self)
def __init__(self): # type: () -> None QtWidgets.QWidget.__init__(self) self.logger = init_logger(self) # We should get passed a list of pilots to keep ourselves in order after initing self.pilots = None # Dict to store handles to plot windows by pilot self.plots = {} # Main Layout self.layout = QtWidgets.QVBoxLayout(self) self.layout.setContentsMargins(0, 0, 0, 0) self.layout.setSpacing(0) # Plot Selection Buttons # TODO: Each plot bar should have an option panel, because different tasks have different plots #self.plot_select = self.create_plot_buttons() # Create empty plot container self.plot_layout = QtWidgets.QVBoxLayout() # Assemble buttons and plots #self.layout.addWidget(self.plot_select) self.layout.addLayout(self.plot_layout) self.setLayout(self.layout) self.setContentsMargins(0, 0, 0, 0)
def __init__(self, pilot, x_width=50, parent=None): """ Args: pilot (str): The name of our pilot x_width (int): How many trials in the past should we plot? """ #super(Plot, self).__init__(QtOpenGL.QGLFormat(QtOpenGL.QGL.SampleBuffers), parent) super(Plot, self).__init__() self.logger = init_logger(self) self.parent = parent self.layout = None self.infobox = None self.n_trials = None self.session_trials = 0 self.info = {} self.plot = None self.xrange = None self.plot_params = {} self.data = { } # Keep a dict of the data we are keeping track of, will be instantiated on start self.plots = {} self.state = "IDLE" self.continuous = False self.last_time = 0 self.video = None self.videos = [] self.invoker = get_invoker() # The name of our pilot, used to listen for events self.pilot = pilot # Set initial x-value, will update when data starts coming in self.x_width = x_width self.last_trial = self.x_width # Inits the basic widget settings self.init_plots() ## Station # Start the listener, subscribes to terminal_networking that will broadcast data self.listens = { 'START': self.l_start, # Receiving a new task 'DATA': self.l_data, # Receiving a new datapoint 'CONTINUOUS': self.l_data, 'STOP': self.l_stop, 'PARAM': self.l_param, # changing some param 'STATE': self.l_state } self.node = Net_Node(id='P_{}'.format(self.pilot), upstream="T", port=prefs.get('MSGPORT'), listens=self.listens, instance=True)
def __init__(self, name=None, **kwargs): if name: self.name = name else: try: self.name = self.get_name() except: Warning('wasnt passed name and couldnt find from prefs for object: {}'.format(self.__str__)) self.name = None self.logger = init_logger(self) self.listens = {} self.node = None
def __init__(self, name='jack_client'): """ Args: name: """ super(JackClient, self).__init__() # TODO: If global client variable is set, just return that one. self.name = name #self.pipe = pipe self.q = mp.Queue() self.q_lock = mp.Lock() self.play_evt = mp.Event() self.stop_evt = mp.Event() self.quit_evt = mp.Event() # we make a client that dies now so we can stash the fs and etc. self.client = jack.Client(self.name) self.blocksize = self.client.blocksize self.fs = self.client.samplerate self.zero_arr = np.zeros((self.blocksize, 1), dtype='float32') # a few objects that control continuous/background sound. # see descriptions in module variables self.continuous = mp.Event() self.continuous_q = mp.Queue(maxsize=1024) self.continuous_loop = mp.Event() self.continuous.clear() self.continuous_loop.clear() self.continuous_started = False # store the frames of the continuous sound and cycle through them if set in continous mode self.continuous_cycle = None # store a reference to us and our values in the module globals()['SERVER'] = self globals()['FS'] = copy(self.fs) globals()['BLOCKSIZE'] = copy(self.blocksize) globals()['QUEUE'] = self.q globals()['Q_LOCK'] = self.q_lock globals()['PLAY'] = self.play_evt globals()['STOP'] = self.stop_evt globals()['CONTINUOUS'] = self.continuous globals()['CONTINUOUS_QUEUE'] = self.continuous_q globals()['CONTINUOUS_LOOP'] = self.continuous_loop self.logger = init_logger(self)
def __init__(self, transform, operation: str = "trigger", return_id='T', return_key=None, stage_block=None, value_subset=None, **kwargs): """ Args: transform: operation (str): either * "trigger", where the last transform is a :class:`~autopilot.transform.transforms.Condition` and a trigger is returned to sender only when the return value of the transformation changes, or * "stream", where each result of the transformation is returned to sender return_id: stage_block: value_subset (str): Optional - subset a value from from a dict/list sent to :meth:`.l_process` **kwargs: """ assert operation in ('trigger', 'stream', 'debug') self.operation = operation self._last_result = None if return_key is None: self.return_key = self.operation.upper() else: self.return_key = return_key self.return_id = return_id self.stage_block = stage_block self.stages = cycle([self.noop]) # self.input_q = LifoQueue() self.input_q = deque(maxlen=1) self.value_subset = value_subset self.logger = init_logger(self) self.process_thread = threading.Thread(target=self._process, args=(transform, )) self.process_thread.daemon = True self.process_thread.start()
def __init__(self, *args, **kwargs): # Task management self.stage_block = None # a threading.Event used by the pilot to manage stage transitions self.punish_stim = False #self.running = None # Event used to exit the run thread self.stages = None # Some generator that continuously returns the next stage of the trial self.triggers = {} self.stim_manager = None self.trial_counter = None # will be init'd by the subtask because will use the current trial # Hardware self.hardware = {} # dict to store references to hardware self.pin_id = {} # pin numbers back to pin lettering self.punish_block = threading.Event() self.punish_block.set() #self.running = threading.Event() # try to get logger self.logger = init_logger(self)
def __init__(self): # type: () -> None super(Terminal, self).__init__() # store instance globals()['_TERMINAL'] = self # networking self.node = None self.networking = None self.heartbeat_dur = 10 # check every n seconds whether our pis are around still # data self.subjects = {} # Dict of our open subject objects # gui self.layout = None self.widget = None self.file_menu = None self.tool_menu = None self.control_panel = None self.data_panel = None self.logo = None # property private attributes self._pilots = None # logging self.logger = init_logger(self) # Listen dictionary - which methods to call for different messages # Methods are spawned in new threads using handle_message self.listens = { 'STATE': self.l_state, # A Pi has changed state 'PING': self.l_ping, # Someone wants to know if we're alive 'DATA': self.l_data, 'CONTINUOUS': self.l_data, # handle continuous data same way as other data 'STREAM': self.l_data, 'HANDSHAKE': self.l_handshake # a pi is making first contact, telling us its IP } # Make invoker object to send GUI events back to the main thread # self.invoker = Invoker() self.invoker = get_invoker() # prefs.add('INVOKER', self.invoker) self.initUI() # Start Networking # Networking is in two parts, # "internal" networking for messages sent to and from the Terminal object itself # "external" networking for messages to and from all the other components, # The split is so the external networking can run in another process, do potentially time-consuming tasks # like resending & confirming message delivery without blocking or missing messages self.node = Net_Node(id="_T", upstream='T', port=prefs.get('MSGPORT'), listens=self.listens) self.logger.info("Net Node Initialized") # Start external communications in own process # Has to be after init_network so it makes a new context self.networking = Terminal_Station(self.pilots) self.networking.start() self.logger.info("Station object Initialized") # send an initial ping looking for our pilots self.node.send('T', 'INIT') # start beating ur heart # self.heartbeat_timer = threading.Timer(self.heartbeat_dur, self.heartbeat) # self.heartbeat_timer.daemon = True # self.heartbeat_timer.start() #self.heartbeat(once=True) self.logger.info('Terminal Initialized')
def __init__(self, splash=True): if splash: with open( os.path.join(os.path.dirname(os.path.dirname(__file__)), 'setup', 'welcome_msg.txt'), 'r') as welcome_f: welcome = welcome_f.read() print('') for line in welcome.split('\n'): print(line) print('') sys.stdout.flush() self.name = prefs.get('NAME') if prefs.get('LINEAGE') == "CHILD": self.child = True self.parentid = prefs.get('PARENTID') else: self.child = False self.parentid = 'T' self.logger = init_logger(self) self.logger.debug('pilot logger initialized') # Locks, etc. for threading self.running = threading.Event() # Are we running a task? self.stage_block = threading.Event( ) # Are we waiting on stage triggers? self.file_block = threading.Event() # Are we waiting on file transfer? self.quitting = threading.Event() self.quitting.clear() # init pigpiod process self.init_pigpio() # Init audio server if prefs.get('AUDIOSERVER') or 'AUDIO' in prefs.get('CONFIG'): self.init_audio() # Init Station # Listen dictionary - what do we do when we receive different messages? self.listens = { 'START': self.l_start, # We are being passed a task and asked to start it 'STOP': self.l_stop, # We are being asked to stop running our task 'PARAM': self.l_param, # A parameter is being changed 'CALIBRATE_PORT': self.l_cal_port, # Calibrate a water port 'CALIBRATE_RESULT': self.l_cal_result, # Compute curve and store result 'BANDWIDTH': self.l_bandwidth # test our bandwidth } # spawn_network gives us the independent message-handling process self.networking = Pilot_Station() self.networking.start() self.node = Net_Node(id="_{}".format(self.name), upstream=self.name, port=prefs.get('MSGPORT'), listens=self.listens, instance=False) self.logger.debug('pilot networking initialized') # if we need to set pins pulled up or down, do that now self.pulls = [] if prefs.get('PULLUPS'): for pin in prefs.get('PULLUPS'): self.pulls.append( gpio.Digital_Out(int(pin), pull='U', polarity=0)) if prefs.get('PULLDOWNS'): for pin in prefs.get('PULLDOWNS'): self.pulls.append( gpio.Digital_Out(int(pin), pull='D', polarity=1)) self.logger.debug('pullups and pulldowns set') # check if the calibration file needs to be updated # Set and update state self.state = 'IDLE' # or 'Running' self.update_state() # Since we're starting up, handshake to introduce ourselves self.ip = self.get_ip() self.handshake() self.logger.debug('handshake sent')