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,
