def __init__(self, index: int = 0, log_handlers: [StreamHandler] = None): self._logger = getLogger(__name__) if log_handlers: for h in log_handlers: self._logger.addHandler(h) self._logger.debug("Initializing") self.index = index self._tracker = FPSTracker() self._internal_frame_q = InternalFrameQueue() self._running = TEvent() self._running.clear() self._lock = Lock() self._closing_flag = Event() self._timeout_limit = 0 self._stream = VideoCapture(index, defs.cap_backend) self.set_resolution(self.get_resolution()) self._fps_test_status = 0 self._fps_target = 30 self._spf_target = 1 / self._fps_target self._buffer = 5 self._use_limiter = False self._finalized = False self._end = TEvent() self._end.clear() self._err_event = Event() self._num_frms = 0 self._start = time() self._loop = get_event_loop() self._logger.debug("Initialized")
def __init__(self, cam_index: int = 0, lang: LangEnum = LangEnum.ENG, log_handlers: [StreamHandler] = None): self._logger = getLogger(__name__) if log_handlers: for h in log_handlers: self._logger.addHandler(h) self._logger.debug("Initializing") self.cam_index = cam_index cam_name = "CAM_" + str(self.cam_index) view = CamView(cam_name, log_handlers) super().__init__(view) self.view.show_initialization() self.view.set_config_active(False) # TODO: Get logging in here. See https://docs.python.org/3/howto/logging-cookbook.html find multiprocessing. self._model_msg_pipe, msg_pipe = Pipe() # For messages/commands. self._model_image_pipe, img_pipe = Pipe(False) # For images. self._model = Process(target=CamModel, args=(msg_pipe, img_pipe, self.cam_index)) self._switcher = { defs.ModelEnum.FAILURE: self.err_cleanup, defs.ModelEnum.CUR_FPS: self._update_view_fps, defs.ModelEnum.CUR_RES: self._update_view_resolution, defs.ModelEnum.CLEANUP: self._set_model_cleaned, defs.ModelEnum.STOP: self._set_saved, defs.ModelEnum.STAT_UPD: self._show_init_progress, defs.ModelEnum.START: self._finalize } self._stop = TEvent() self._loop = get_running_loop() self._model_cleaned = Event() self._ended = Event() self._executor = ThreadPoolExecutor(2) self._loop.run_in_executor(self._executor, self._handle_pipe) self._update_feed_flag = TEvent() self._update_feed_flag.set() self._handle_pipe_flag = TEvent() self._handle_pipe_flag.set() self._model.start() self.send_msg_to_model((defs.ModelEnum.INITIALIZE, None)) self.set_lang(lang) self._res_list = list() self._setup_handlers() self._exp_info_for_later = [str(), str(), 0] # path, cond_name, block_num self._create_exp_later_task = None self._start_exp_later_task = None self._cleaning = False self._initialized = Event() self._running = False self._logger.debug("Initialized")
def _execute_power_calibration(self): self.graph = self._graph_factory() # s, _ = g.new_series() # po = g.plots[0] # g.add_aux_axis(po, s) # if self.parent is not None: self._open_graph() self.data_manager = dm = H5DataManager() if self.parameters.use_db: dw = DataWarehouse(root=os.path.join(self.parent.db_root, 'power_calibration')) dw.build_warehouse() directory = dw.get_current_dir() else: directory = os.path.join(paths.data_dir, 'power_calibration') _dn = dm.new_frame(directory=directory, base_frame_name='power_calibration') table = dm.new_table('/', 'calibration', table_style='PowerCalibration') callback = lambda p, r, t: self._write_data(p, r, t) self._stop_signal = TEvent() self._iterate(self.parameters, self.graph, True, callback, table) self._finish_calibration() if self._alive: self._alive = False self._save_to_db() self._apply_calibration()
def __init__(self, demo_manager, client, admin=None, duration=None): """ Starts an agent that will start a server-side demo for the given client. :param demo_manager: DemoManager object asking for the demo :param client: Client object for the player to take the demo of :param admin: optional Client object for the admin who ordered the demo :param duration: optional duration in second the demo must last (ignored if a demo was already recording that player) :return: None """ self.demo_manager = demo_manager self.plugin = demo_manager.plugin self.client = client self.admin = admin self.duration = duration self._cancel_event = TEvent() # will be used to give up trying self._try_event = TEvent() # will be used to trigger another try Thread.__init__(self, name="DemoStarter(%s)" % client.name)
def t2(): COUNT = 100000000 event = TEvent() thread1 = Thread(target=countdown, args=(COUNT // 2, event)) thread2 = Thread(target=countdown, args=(COUNT // 2, event)) thread1.start() thread2.start() thread1.join() thread2.join()
def t4(): COUNT = 100000000 event = TEvent() thread1 = Thread(target=countdown, args=(COUNT, event)) thread2 = Thread(target=io_op, args=(COUNT, event, 'thread.txt')) thread1.start() thread2.start() thread1.join() thread2.join()
def _execute_power_calibration_check(self): """ """ g = Graph() g.new_plot() g.new_series() g.new_series(x=[0, 100], y=[0, 100], line_style='dash') do_later(self._open_graph, graph=g) self._stop_signal = TEvent() callback = lambda pi, r: None self._iterate(self.check_parameters, g, False, callback)
def start_measure_grain_mask(self): self._measure_grain_evt = evt = TEvent() def _measure_grain_mask(): ld = self.lumen_detector masks = [] while not evt.is_set(): l, m = ld.lum(copy(self.video.get_cached_frame())) masks.append(l) evt.wait(1) self.grain_masks = masks self._measure_grain_t = Thread(target=_measure_grain_mask) self._measure_grain_t.start()
def run_and_view_log(run_callable, level=logging.DEBUG): log_queue = Queue() finished_event = TEvent() root = Tk() app = MessageViewer(log_queue, finished_event, master=root) fmt = logging.Formatter(logging.BASIC_FORMAT, None) hdlr = QueuePutHandler(log_queue) hdlr.setFormatter(fmt) logging.root.addHandler(hdlr) logging.root.setLevel(level) def business(): log = logging.getLogger('run_and_view_log thread') try: run_callable() finished_event.set() except: log.exception('Something went wrong') Thread(target=business).start() app.mainloop() root.destroy()
def passive_focus(self, block=False, **kw): self._evt_autofocusing = TEvent() self._evt_autofocusing.clear() # manager = self.laser_manager oper = self.parameters.operator self.info('passive focus. operator = {}'.format(oper)) g = self.graph if not g: g = Graph(plotcontainer_dict=dict(padding=10), window_x=0.70, window_y=20, window_width=325, window_height=325, window_title='Autofocus') self.graph = g g.clear() g.new_plot(padding=[40, 10, 10, 40], xtitle='Z (mm)', ytitle='Focus Measure ({})'.format(oper)) g.new_series() g.new_series() invoke_in_main_thread(self._open_graph) target = self._passive_focus self._passive_focus_thread = Thread(name='autofocus', target=target, args=(self._evt_autofocusing, ), kwargs=kw) self._passive_focus_thread.start() if block: # while 1: # if not self._passive_focus_thread.isRunning(): # break # time.sleep(0.25) self._passive_focus_thread.join()
def _parse_config(self): """ Parse the YML config file and add components to the Car. """ logger.info('Parsing config file to add car components...') if 'parallel' in self.config and self.config['parallel'] == 'process': self.parallel_process = True self.stop_event = PEvent() logger.info('Using process level parallel for components.') else: self.parallel_process = False self.stop_event = TEvent() for component in self.config['components']: comp_module = str(component) pwd = os.path.abspath('.') if pwd.endswith('src'): pwd = os.path.abspath('components') else: pwd = os.path.abspath('src/components') with open(pwd + '/' + comp_module + '.py', 'r') as f: source = '\n'.join(f.readlines()) p = ast.parse(source) classes = [ node.name for node in ast.walk(p) if isinstance(node, ast.ClassDef) ] if len(classes) == 0: raise ValueError( "submodule '{}' contains no component class!".format( comp_module)) if len(classes) == 1: # only 1 class defined self._add_component(component, classes[0]) else: for cls in classes: # multiple classes within module if cls in self.config['components'][component]: self._add_component(component, cls)
def start_measure_grain_polygon(self): self._measure_grain_evt = evt = TEvent() def _measure_grain_polygon(): ld = self.lumen_detector dim = self.stage_map.g_dimension ld.pxpermm = self.pxpermm self.debug('Starting measure grain polygon') masks = [] display_image = self.autocenter_manager.display_image mask_dim = dim * 1.05 mask_dim_mm = mask_dim * self.pxpermm ld.grain_measuring = True while not evt.is_set(): src = self._get_preprocessed_src() if src is not None: targets = ld.find_targets( display_image, src, dim, mask=mask_dim, search={'start_offset_scalar': 1}) if targets: t = time.time() targets = [(t, mask_dim_mm, ti.poly_points.tolist()) for ti in targets] masks.extend(targets) sleep(0.1) ld.grain_measuring = False self.grain_polygons = (m for m in masks) self.debug('exiting measure grain') self._measure_grain_t = QThread(target=_measure_grain_polygon) self._measure_grain_t.start() return True
class Application(Frame): #Global Variables# rawCommand = "" collisionState = False baxter_enabler = None collisionSubs = None #baxter globals lLimb = None rLimb = None lGripper = None rGripper = None # Text to speech engine g;obals t2s = pyttsx.init() voices = t2s.getProperty('voices') t2s.setProperty('voice', 'english') t2s.setProperty('rate', 150) #mic globals r = None m = None # Environment Tracking Booleans env = ({ 'fridgeOpen': False, 'hasBottle': False, 'bottleOnTable': False, 'microwaveOpen': False, 'holdingSomething': False, 'microwaveOn': False, 'foodInMicrowave': False }) slow = .02 # m/s fast = .2 # m/s command = "" newCommand = "" lastCommand = "" pause_event = TEvent() def createWidgets(self): #Dialog title self.dialog_label = Label(self, text="Dialog", fg="black", bg="light blue", width=60, height=2, font=("Ariel", 20)) self.dialog_label.pack() #Dialog box self.dialog_box = Label(self, bg="white", padx=10, pady=10, borderwidth=1, relief=SOLID, anchor="nw", width=100, height=4, font=("Ariel", 15)) self.dialog_content = StringVar() self.dialog_content.set("Listening...") self.dialog_box["textvariable"] = self.dialog_content self.dialog_box.pack(fill=X) #command label self.command_box = Label(self, fg="black", bg="lightgrey", bd=1, relief=SOLID, width=60, height=2, font=("Ariel", 20)) self.curr_command = StringVar() self.curr_command.set("Waiting...") self.command_box["textvariable"] = self.curr_command self.command_box.pack() #blank label separator self.blank = Label(self, width=60, height=2) self.blank.pack() #environment title self.env_label = Label(self, text="Environment", fg="black", bg="light blue", width=60, height=2, font=("Ariel", 20)) self.env_label.pack() #environment tokens self.env1 = Label(self, text="ENV-1", bg="dark grey", bd=1, relief=SOLID, width=60, height=5, font=("Ariel", 20)) self.env1.pack() self.env2 = Label(self, text="ENV-2", bg="dark grey", bd=1, relief=SOLID, width=60, height=5, font=("Ariel", 20)) self.env2.pack() self.env3 = Label(self, text="ENV-3", bg="dark grey", bd=1, relief=SOLID, width=60, height=5, font=("Ariel", 20)) self.env3.pack() self.env4 = Label(self, text="ENV-4", bg="dark grey", bd=1, relief=SOLID, width=60, height=5, font=("Ariel", 20)) self.env4.pack() #end of create widgets def update_command_box(self, command): self.curr_command.set(command) self.command_box["bg"] = "green" # clamping function to constrain arm movement #move to helpers? def clamp(self, n, minn, maxn): return max(min(maxn, n), minn) # callback function when audio data is obtained def heard(self, recognizer, audio): # Defining self.Commands to be accepted if self.lastAliveStatus and not self.task.is_alive(): self.t2s.say(" ") self.t2s.say(" ") self.t2s.say(" ") self.t2s.say(" ") # clear text to speech queue self.t2s.say(" Done with " + self.lastAliveName) self.t2s.runAndWait() self.lastAliveStatus = False self.curr_command.set("Waiting..") self.command_box["bg"] = "light grey" credsJson = "" with open('baxter-helper-bot-gspeechcreds.json', 'r') as gspeechcreds: credsJson = gspeechcreds.read() print("in heard") sens = 1 commands = [ "move", "arm", "forward", "backward", "left", "right", "up", "down", "higher", "lower", "close", "hand", "open", "stop", "stop", "stop", "faster", "slower", "fridge", "zero", "get", "water bottle", "fridge", "place on", "table", "fridge is open", "holding something", "fridge is closed", "hand is empty", "microwave", "start", "turn off", "continue", "cook", "put", "food", "is open", "get the food" ] print('trying to recognize') try: commandIter = [command[0] for command in commands] self.rawCommand = recognizer.recognize_google_cloud( audio_data=audio, language='en-US', credentials_json=credsJson, preferred_phrases=commands) self.dialog_content.set(self.rawCommand) print(self.rawCommand) self.run_commands() except sr.UnknownValueError: #if self.rawCommand == "": print("listening") self.dialog_content.set("Listening...") pass #print("could not understand audio") # pass except sr.RequestError as e: print("Recognition error; {}".format(e)) #move to helpers? def collisionDetection(self, data): collisionState = data.collision_state if collisionState: self.rawCommand = "" def terminate_thread(self, thread): """Terminates a python thread from another thread. :param thread: a threading.Thread instance """ if not thread.isAlive(): return exc = ctypes.py_object(KeyboardInterrupt) res = ctypes.pythonapi.PyThreadState_SetAsyncExc( ctypes.c_long(thread.ident), exc) if res == 0: raise ValueError("nonexistent thread id") elif res > 1: # """if it returns a number greater than one, you're in trouble, # and you should call it again with exc=NULL to revert the effect""" ctypes.pythonapi.PyThreadState_SetAsyncExc(thread.ident, None) raise SystemError("PyThreadState_SetAsyncExc failed") #baxter setup def setup_baxter(self): print "setting up baxter" rospy.init_node('speechControl') self.lLimb = baxter.Limb('left') self.rLimb = baxter.Limb('right') self.lGripper = baxter.Gripper('left') self.rGripper = baxter.Gripper('right') self.baxter_enabler = baxter.RobotEnable(versioned=True) self.baxter_enabler.enable() # Set up subscriber for collision detection self.collisionSubs = rospy.Subscriber( name='/robot/limb/left/collision_detection_state', data_class=CollisionDetectionState, callback=self.collisionDetection, buff_size=100) if not self.lGripper.calibrate(): print("left gripper did not calibrate") sys.exit() # amp up gripper holding force self.lGripper.set_holding_force(100) self.lGripper.set_moving_force(100) self.rGripper.set_holding_force(100) self.rGripper.set_moving_force(100) self.lLimb.set_joint_position_speed(.5) self.lLimb.set_command_timeout(2) strtPose = self.lLimb.endpoint_pose() #end setup baxter #speech recognition setup def setup_speech_recognition(self): self.r = sr.Recognizer() self.m = sr.Microphone() self.r.pause_threshold = .5 self.r.dynamic_energy_threshold = False #r.dynamic_energy_adjustment_damping = 0.5 #r.dynamic_energy_adjustment_ratio = 2 with self.m as source: self.r.adjust_for_ambient_noise(source, 1) #end speech recognition setup def get_command(self): self.move_to_zero() self.lastAliveStatus = False self.lastAliveName = "" self.stopListening = self.r.listen_in_background(self.m, self.heard, phrase_time_limit=4) print("raw self.command is", self.rawCommand) #print("in get self.command, calling run") #self.run_commands() def move_to_zero(self): #Move to Zero position self.task = Thread(target=moveToDownward, args=(self.lLimb, self.rLimb, self.pause_event), name="movingToZero") print(self.task.name) self.task.daemon = True self.task.start() self.lastAliveStatus = True def run_commands(self): # Check if self.task has ended print "in run self.command" self.newCommand = self.rawCommand # Check if self.command has changed if self.command != self.newCommand: if self.newCommand != "": self.speed = self.slow self.command = self.newCommand orient = self.lLimb.endpoint_pose()['orientation'] print("last: {}, this: {}".format(self.lastCommand, self.command)) if self.collisionState: print "Can't Move Here" if self.task and self.task.is_alive(): self.rawCommand = "stop" #### Directional self.Commands ##### if 'move arm forward' in self.command: self.terminate_thread(self.task) self.task = Thread(target=moveOnAxis, args=(self.lLimb, 'y', 4, self.speed, self.pause_event), name="movingForward") print(self.task.name) self.pause_event.clear() self.task.daemon = True self.task.start() self.rawCommand = "" if 'move arm backward' in self.command: self.terminate_thread(self.task) self.task = Thread(target=moveOnAxis, args=(self.lLimb, 'y', -4, self.speed, self.pause_event), name="movingBackward") print(self.task.name) self.pause_event.clear() self.task.daemon = True self.task.start() self.rawCommand = "" if 'move arm left' in self.command: self.terminate_thread(self.task) self.task = Thread(target=moveOnAxis, args=(self.lLimb, 'x', -4, self.speed, self.pause_event), name="movingLeft") print(self.task.name) self.pause_event.clear() self.task.daemon = True self.task.start() self.rawCommand = "" if 'move arm right' in self.command: self.terminate_thread(self.task) self.task = Thread(target=moveOnAxis, args=(self.lLimb, 'x', 4, self.speed, self.pause_event), name="movingRight") print(self.task.name) self.pause_event.clear() self.task.daemon = True self.task.start() self.rawCommand = "" if 'arm' in self.command and ('higher' in self.command or 'up' in self.command): self.terminate_thread(self.task) self.task = Thread(target=moveOnAxis, args=(self.lLimb, 'z', 4, self.speed, self.pause_event), name="movingHigher") print(self.task.name) self.pause_event.clear() self.task.daemon = True self.task.start() self.rawCommand = "" if 'arm' in self.command and ('lower' in self.command or 'down' in self.command): self.terminate_thread(self.task) self.task = Thread(target=moveOnAxis, args=(self.lLimb, 'z', -4, self.speed, self.pause_event), name="movingLower") print(self.task.name) self.pause_event.clear() self.task.daemon = True self.task.start() self.rawCommand = "" ### End Directional self.Commands ### ### Gripper Direct self.Commands ### if 'close' in self.command and ('hand' in self.command or 'gripper' in self.command): self.terminate_thread(self.task) self.lGripper.close() self.rawCommand = "" if 'open' in self.command and ('hand' in self.command or 'gripper' in self.command): self.terminate_thread(self.task) self.lGripper.open() self.rawCommand = "" ### End Gripper Direct self.Commands ### ### Stop and continue self.Commands ### if 'stop' in self.command: self.rawCommand = "" self.pause_event.set() if 'continue' in self.command: self.rawCommand = "" self.pause_event.clear() ### End Stop and continue self.commands ### ### Begin self.speed self.commands ### if 'go faster' in self.command: self.terminate_thread(self.task) self.speed = fast self.command = lastCommand self.rawCommand = lastCommand if 'go slower' in self.command: self.terminate_thread(self.task) self.speed = slow self.command = lastCommand self.rawCommand = lastCommand ### End self.speed self.commands ### # Begin fridge commands # if 'open' in self.command and 'the fridge' in self.command: self.terminate_thread(self.task) #if not env['fridgeOpen']: if not False: self.task = Thread(target=openFridge, args=(self.lLimb, self.rLimb, self.pause_event), name="openingFridge") self.pause_event.clear() self.task.daemon = True self.task.start() print(self.task.name) self.rawCommand = "" self.update_command_box("Opening Fridge") ''' if 'get' in self.command and 'water bottle' in self.command: terminate_thread(self.task) if not env['fridgeOpen'] and not env['hasBottle']: task = Thread(target=getBottleFromStart, args=(lLimb, rLimb,lGripper, pause_event), name="gettingBottleFromStart") pause_event.clear() task.daemon = True task.start() print(task.name) if env['fridgeOpen'] and not env['hasBottle']: task = Thread(target=pickBottleFromOpenFridge, args=(lLimb, rLimb,lGripper, pause_event), name="gettingBottleFromOpenFridge") pause_event.clear() task.daemon = True task.start() print(task.name) if env['fridgeOpen'] and env['hasBottle']: pass rawCommand = "" if 'close' in command and 'the fridge' in command: terminate_thread(task) if env['fridgeOpen'] and not env['holdingSomething']: task = Thread(target=closeFridge, args=(lLimb, rLimb, pause_event), name="closingFridge") pause_event.clear() task.daemon = True task.start() print(task.name) rawCommand = "" if 'place' in command and 'table' in command: terminate_thread(task) if env['hasBottle']: task = Thread(target=moveToTableAfterRetrieve, args=(lLimb, rLimb,lGripper, pause_event), name="placingOnTable") pause_event.clear() task.daemon = True task.start() print(task.name) else: print("I don't have the bottle right now") print(task.name) rawCommand = "" if 'put' in command and 'water bottle' in command and 'table' in command: terminate_thread(task) if not env['fridgeOpen'] and not env['hasBottle']: task = Thread(target=getBottleFull, args=(lLimb, rLimb,lGripper,pause_event), name="gettingBottlePlacingOnTable") pause_event.clear() task.daemon = True task.start() print(task.name) elif env['fridgeOpen'] and not env['hasBottle']: task = Thread(target=bottleOnTableAfterOpenFridge, args=(lLimb, rLimb, lGripper, pause_event), name="gettingBottleFromOpenFridgeAndPlacingOnTable") pause_event.clear() task.daemon = True task.start() print(task.name) elif env['fridgeOpen'] and env['hasBottle']: task = Thread(target=moveToTableAfterRetrieve, args=(lLimb, rLimb,lGripper, pause_event), name="placingOnTable") pause_event.clear() task.daemon = True task.start() print(task.name) rawCommand = "" ''' # End Fridge task commands # ### miscellaneous commands ### if 'move to zero' in self.command: ''' self.terminate_thread(self.task) self.task = Thread(target=moveToDownward, args=(self.lLimb, self.rLimb, self.pause_event), name="movingToZero") print(self.task.name) self.pause_event.clear() self.task.daemon = True self.task.start() self.update_command_box("Moving to zero") self.rawCommand = "" ''' runMoveZero(self.task, self.lLimb, self.rLimb, self.pause_event) self.rawCommand = "" self.update_command_box("Moving to zero") self.lastAliveStatus = self.task.is_alive() self.lastAliveName = self.task.name #at the end self.newCommand = "" self.lastCommand = self.command time.sleep(.01) #set env variables # def set_env_variables(self): def run(self): print "running program" self.setup_baxter() self.setup_speech_recognition() self.get_command() #initialize the app def __init__(self, master=None): Frame.__init__(self, master) self.pack() self.createWidgets() self.run()
def _start_delay_timer(self): self._ready_signal = TEvent() self._ready_signal.clear() self._delay_timer = Timer(self.delay, self.set_ready, args=(True, )) # self._start_timeout_timer() self._delay_timer.start()
def __init__(self): super().__init__() self.ready = TEvent()
def __init__(self, *args, **kwargs): self.event = TEvent(*args, **kwargs)
def t1(COUNT=100000000): event = TEvent() thread1 = Thread(target=countdown, args=(COUNT, event)) thread1.start() thread1.join()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._pid = os.getpid() self.__stop = TEvent()
'fridgeOpen': False, 'hasBottle': False, 'bottleOnTable': False, 'bottleInFridge': True, 'microwaveOpen': False, 'holdingSomething': False, 'microwaveOn': False, 'foodInMicrowave': False, 'foodInFridge': True, 'foodOnTable': False, 'robotlocalized': False, 'mobileBaseActivated': False }) # Event for pausing the current task pause_event = TEvent() #interface widgets# #Dialog title root = Tk() root['bg'] = "#ccefff" dialog_label = Label(root, text="Dialog", fg="black", bg="light blue", width=60, height=2, font=("Ariel", 20)) dialog_label.pack() #Dialog box dialog_box = Label(root,