def run_game_loop(self): self.frame_rendered(0) self.timer = RepeatedTimer(0.1, self.tick) while self.loop: key = self.kp.read_single_keypress().lower() if key == 'a': self.move_paddle(0, -1) elif key == 's': self.move_paddle(0, 1) elif key == 'k': self.move_paddle(1, -1) elif key == 'l': self.move_paddle(1, 1) elif key == 'r': self.init_game() elif not config.HAS_GUI and key == 'q': break self.led_strip.register_callback( self.led_strip.CALLBACK_FRAME_RENDERED, None) self.timer.stop() self.kp.stop()
def on_complete(self): self.animation_loader.on_complete() self.interval_animation.stop() if os.path.isfile(self.NODE_JS_BINARY_TARFILE_FULL_PATH): os.remove(self.NODE_JS_BINARY_TARFILE_FULL_PATH) node_js = NodeJS() npm = NPM() self.animation_loader = AnimationLoader([ "[= ]", "[ = ]", "[ = ]", "[ = ]", "[ =]", "[ = ]", "[ = ]", "[ = ]" ], 0.067, "Installing npm dependencies ") self.interval_animation = RepeatedTimer(self.animation_loader.sec, self.animation_loader.animate) try: npm.getCurrentNPMVersion(True) except Exception as e: print("Error: " + traceback.format_exc()) try: npm.install_all() except Exception as e: #print("Error: "+traceback.format_exc()) pass self.animation_loader.on_complete() self.interval_animation.stop() if node_js.getCurrentNodeJSVersion(True) == self.NODE_JS_VERSION: sublime.active_window().status_message( "Node.js " + self.NODE_JS_VERSION + " installed correctly! NPM version: " + npm.getCurrentNPMVersion(True)) else: sublime.active_window().status_message( "Can't install Node.js! Something went wrong during installation." )
def start(self): self.thread = threading.Thread(target=self.download, name="DownloadNodeJS") self.thread.setDaemon(True) self.thread.start() if self.animation_loader: self.interval_animation = RepeatedTimer( self.animation_loader.sec, self.animation_loader.animate)
def initializeTimerTask(self): # 1 - Timer essential properties self._timerInterval = 1 # 2 - Start Timer self._rt = RepeatedTimer( self._timerInterval, self.doTimerTask) # it auto-starts, no need of rt.start()
def __init__(self, exmoApiModel): self.__exmoApiModel = exmoApiModel self.__timer = RepeatedTimer(self.REFRESH_INTERVAL_SEC, self.__step) self.__data = [] self.__lastOperation = self.OPERATION_NONE self.__math = SimpleMath() self.__currentRate = 0 self.__lastRate = 0 self.__printCurrentBalance()
def run_spread_logger(seconds_interval=60): header_row = ["Timestamp", "Currency", "Buy Exchange", "Profit", "Return"] with open('./spread_logger.csv', 'a') as f: w = csv.writer(f) w.writerow(header_row) print("starting...\n") RepeatedTimer(seconds_interval, fetch_price_spread, seconds_interval)
def __init__(self, estimation: ComplementarityEstimation, cluster: Cluster, update_interval=60): self.queue = [] self.estimation = estimation self.cluster = cluster self._timer = RepeatedTimer(update_interval, self.update_estimation) self.scheduler_lock = Lock() self.started_at = None self.stopped_at = None self.print_estimation = False
def start_asteroid_creation_timer(ai_settings, screen, stats, sb, ship, asteroids): if stats.level >= stats.MIN_HARD_LEVEL: timer = RepeatedTimer( ai_settings.base_asteroids_timer_interval / stats.level, create_asteroid, ai_settings, screen, asteroids, ) timer.start() return timer return None
def __init__(self, ui, timer_secs, use_timer, sim_mode, competition_mode): super(Referee, self).__init__() # Setup my UI self.ui = RefereeUI(ui, sim_mode, use_timer, competition_mode) # Connect to ROS things ball_topic = '/ball/truth' if sim_mode else 'vision/ball' rospy.Subscriber(ball_topic, Pose2D, self._handle_vision_ball) self.pub_game_state = rospy.Publisher('game_state', GameState, queue_size=10, latch=True) self.sim_mode = sim_mode self.game_started = False # Create a GameState msg that will be continually updated and published self.game_state = GameState() self.ballIsStillInGoal = False # Set up a 100ms timer event loop self.timer = RepeatedTimer(0.1, self._timer_handler) self.ui.reset_timer(timer_secs) # Populate team names into comboboxes. If sim_mode, these will come from # the catkin_ws packages. If not, these need to come from .. a YAML? self.ui.populate_team_names(sim_mode) # Connect Qt Buttons self.ui.btn_play.clicked.connect(self._btn_play) self.ui.btn_reset_field.clicked.connect(self._btn_reset_field) self.ui.btn_next_half.clicked.connect(self._btn_next_half) self.ui.btn_reset_clock.clicked.connect(self._btn_reset_clock) self.ui.btn_start_game.clicked.connect(self._btn_start_game) # Penalty buttons self.ui.btn_home_penalty.clicked.connect( lambda: self._handle_penalty(home=True)) self.ui.btn_away_penalty.clicked.connect( lambda: self._handle_penalty(home=False)) # Score +/- buttons self.ui.btn_home_inc_score.clicked.connect( lambda: self._handle_score(home=True, inc=True)) self.ui.btn_home_dec_score.clicked.connect( lambda: self._handle_score(home=True, inc=False)) self.ui.btn_away_inc_score.clicked.connect( lambda: self._handle_score(home=False, inc=True)) self.ui.btn_away_dec_score.clicked.connect( lambda: self._handle_score(home=False, inc=False))
def __init__(self, estimation: ComplementarityEstimation, cluster: Cluster, update_interval=60): self.queue = [] self.estimation = estimation self.cluster = cluster self._timer = RepeatedTimer(update_interval, self.update_estimation) self.scheduler_lock = Lock() self.started_at = None self.stopped_at = None self.print_estimation = False self.waiting_time = {} self.scheduled_apps_num = 0 self.jobs_to_peek = self.jobs_to_peek_arg self.random_arrival_rate = [0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 1, 0, 2, 0, 2, 1, 0, 2, 2, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0]
def __init__(self, ipcon, key_queue): if not config.UID_DUAL_BUTTON_BRICKLET[0]: print("Not Configured: Dual Button 1") if not config.UID_DUAL_BUTTON_BRICKLET[1]: print("Not Configured: Dual Button 2") self.key_queue = key_queue self.ipcon = ipcon if config.UID_DUAL_BUTTON_BRICKLET[0]: self.db1 = DualButton(config.UID_DUAL_BUTTON_BRICKLET[0], self.ipcon) else: self.db1 = None if config.UID_DUAL_BUTTON_BRICKLET[1]: self.db2 = DualButton(config.UID_DUAL_BUTTON_BRICKLET[1], self.ipcon) else: self.db2 = None if self.db1: try: self.db1.get_button_state() print("Found: Dual Button 1 ({0})").format( config.UID_DUAL_BUTTON_BRICKLET[0]) except: self.db1 = None print("Not Found: Dual Button 1 ({0})").format( config.UID_DUAL_BUTTON_BRICKLET[0]) if self.db2: try: self.db2.get_button_state() print("Found: Dual Button 2 ({0})").format( config.UID_DUAL_BUTTON_BRICKLET[1]) except: self.db2 = None print("Not Found: Dual Button 2 ({0})").format( config.UID_DUAL_BUTTON_BRICKLET[1]) if self.db1: self.db1.register_callback(self.db1.CALLBACK_STATE_CHANGED, self.cb_state_changed1) if self.db2: self.db2.register_callback(self.db2.CALLBACK_STATE_CHANGED, self.cb_state_changed2) self.press_timer = RepeatedTimer(0.1, self.press_tick)
def play(self, sound_file): """ Play a file and configure the rest of the window accordingly. """ # (But first check if there's a timer # currently running and if so, stop it.) if hasattr(self, 'timer'): self.timer.stop() self.position_slider.set(0) self.controller.sound_object.play(sound_file) self.current_time.move_timer(0) self.total_time.move_timer(self.controller.sound_object.get_length()) self.time_left.move_timer(self.controller.sound_object.get_length()) self.timer = RepeatedTimer(1, self.increment_timers) self.button_pause["state"] = "normal" self.button_pause.config(relief=tk.RAISED) self.paused = False self.song_now_playing = sound_file self.path_now_playing = self.file_display.get_current_path()
def updateNPMDependencies(): npm = NPM() try: npm.getCurrentNPMVersion(True) except Exception as e: print("Error: " + traceback.format_exc()) return animation_loader = AnimationLoader([ "[= ]", "[ = ]", "[ = ]", "[ = ]", "[ =]", "[ = ]", "[ = ]", "[ = ]" ], 0.067, "Updating npm dependencies ") interval_animation = RepeatedTimer(animation_loader.sec, animation_loader.animate) try: npm.update_all(False) except Exception as e: pass animation_loader.on_complete() interval_animation.stop()
def __init__(self, ipcon, key_queue): if not config.UID_MULTI_TOUCH_BRICKLET: print("Not Configured: Multi Touch") return self.key_queue = key_queue self.ipcon = ipcon self.mt = MultiTouch(config.UID_MULTI_TOUCH_BRICKLET, self.ipcon) try: self.mt.get_electrode_sensitivity() print("Found: Multi Touch ({0})").format( config.UID_MULTI_TOUCH_BRICKLET) except: print("Not Found: Multi Touch ({0})").format( config.UID_MULTI_TOUCH_BRICKLET) return self.mt.set_electrode_sensitivity(100) self.mt.register_callback(self.mt.CALLBACK_TOUCH_STATE, self.cb_touch_state) self.touch_timer = RepeatedTimer(0.1, self.touch_tick)
def __init__(self, serverId, addr, peers, dataDir): super() if not os.path.exists(dataDir): os.makedirs(dataDir) self.serverId = serverId self.addr = addr self.database = DBEngine(dataDir) self.miner = MinerThreading() self.daemonTimer = RepeatedTimer(0.5, self.daemon) self.peers = peers self.stubs = [] for peer in self.peers: logging.info('added peer {}'.format(peer)) channel = grpc.insecure_channel(peer) self.stubs.append(db_pb2_grpc.BlockChainMinerStub(channel)) self.stubs[-1].addr = peer self.miner.daemon = True self.miner.start() self.daemonTimer.start()
def updateNPMDependencies(): npm = NPM() try: npm.getCurrentNPMVersion(True) except Exception as e: if node_variables.NODE_JS_OS == "win": sublime.active_window().status_message( "Can't use \"npm\"! To use features that requires \"npm\", you must install it! Download it from https://nodejs.org site" ) print("Error: " + traceback.format_exc()) return animation_loader = AnimationLoader([ "[= ]", "[ = ]", "[ = ]", "[ = ]", "[ =]", "[ = ]", "[ = ]", "[ = ]" ], 0.067, "Updating npm dependencies ") interval_animation = RepeatedTimer(animation_loader.sec, animation_loader.animate) try: npm.update_all(False) except Exception as e: pass animation_loader.on_complete() interval_animation.stop()
def on_complete(self): self.animation_loader.on_complete() self.interval_animation.stop() if os.path.isfile(self.NODE_JS_BINARY_TARFILE_FULL_PATH): os.remove(self.NODE_JS_BINARY_TARFILE_FULL_PATH) node_js = NodeJS() npm = NPM() self.animation_loader = AnimationLoader([ "[= ]", "[ = ]", "[ = ]", "[ = ]", "[ =]", "[ = ]", "[ = ]", "[ = ]" ], 0.067, "Installing npm dependencies ") self.interval_animation = RepeatedTimer(self.animation_loader.sec, self.animation_loader.animate) try: npm.getCurrentNPMVersion() except Exception as e: if node_variables.NODE_JS_OS == "win": sublime.error_message( "Can't use \"npm\"! To use features that requires \"npm\", you must install it! Download it from https://nodejs.org site" ) print(e) try: npm.install_all() except Exception as e: pass self.animation_loader.on_complete() self.interval_animation.stop() if node_js.getCurrentNodeJSVersion() == self.NODE_JS_VERSION: sublime.active_window().status_message( "Node.js " + self.NODE_JS_VERSION + " installed correctly! NPM version: " + npm.getCurrentNPMVersion()) else: sublime.active_window().status_message( "Can't install Node.js! Something went wrong during installation." )
def pause(self): """ Toggle between a "paused" and "non-paused" state. """ if self.paused: self.button_pause.config(relief=tk.RAISED) # Theoretically, if the user pauses and unpauses # many times during the same song, the timers # could get thrown off. So adjust the timers. if not self.jump_pending: self.current_time.move_timer( self.controller.sound_object.get_position()) self.time_left.move_timer( self.controller.sound_object.get_length() - self.controller.sound_object.get_position()) self.position_slider.set( self.current_time.timer_seconds / self.controller.sound_object.get_length() * 100) self.jump_pending = False self.controller.sound_object.unpause() self.timer = RepeatedTimer(1, self.increment_timers) else: self.button_pause.config(relief=tk.SUNKEN) self.controller.sound_object.pause() self.timer.stop() self.paused = not self.paused
tlc_serial = oasis_serial.OasisSerial("/dev/ttyS2", debug_mode=DEBUG_MODE, debug_tx_port=TLC_TX_PORT, debug_rx_port=TLC_RX_PORT) tlc = TLC(tlc_serial) rover = roverio.Rover(packet_manager, fm) laser = laserio.Laser(oasis_serial=rover_serial) spectrometer = spectrometerio.Spectrometer(serial=rover_serial, file_manager=fm) def log_timer_callback(): """This is the callback function that repeatedly logs the current status to the status log.""" status_array = rover.get_status_array(laser.states_laser, spectrometer.states_spectrometer, tlc.get_temperatures(), tlc.get_duty_cycles(), active_errors, past_two_commands[1]) fm.log_status(status_array, 0) log_data_timer = RepeatedTimer(LOGGING_INTERVAL, log_timer_callback) log_data_timer.start() while True: main_loop() packet_manager.running = False
def main(): global _motion_timer _motion_timer = RepeatedTimer(_motion_timer_period, _handle_motion_timer) _motion_timer.start() global _odom_timer _odom_timer = RepeatedTimer(_odom_timer_period, _handle_odom_timer) _odom_timer.start() global _ctrl_timer _ctrl_timer = RepeatedTimer(_ctrl_timer_period, _handle_ctrl_timer) _ctrl_timer.start() use_rcv3 = os.environ['USE_RCV3'] == 'true' w.init(use_rcv3=use_rcv3) # TODO: Okay, so Controller.init(None) will automagically load in some PID # values for each of the x, y, theta position controllers. However, since # `teleop` is run in real life on different robots, really it should read # the correct YAML robot config file and load in the PID constants and # pass them into Controller.init(gains) as in the controller_node.py. # Two ways to do this: (1) do like os.environ['USE_RCV3'], where the odroid_setup.bash # script loads up the PID constants as environment variables (this seems messy). # (2) find a python YAML reading library and just read the file directly from here # based on which robot this is (you can use os.environ['ROBOT']) Controller.init() print 'Started.' global _velocities, _set_speed, _smooth, _odom_on, _previous_action, _ctrl_on while(1): action = get_action() if action == 'UP': _set_speed = True _velocities = (0, _vy, 0) elif action == 'DOWN': _set_speed = True _velocities = (0, -_vy, 0) elif action == 'RIGHT': _set_speed = True _velocities = (_vx, 0, 0) elif action == 'LEFT': _set_speed = True _velocities = (-_vx, 0, 0) elif action == 'SPIN_CW': _set_speed = True _velocities = (0, 0, _w) elif action == 'SPIN_CCW': _set_speed = True _velocities = (0, 0, -_w) elif action == 'SET_HOME': Odometry.init() elif action == 'GO_HOME': _motion_timer.stop() motion.stop() time.sleep(1) _go_home() time.sleep(1) _set_speed = True _velocities = (0, 0, 0) _motion_timer.start() elif action == 'GO_TO_POINT': _toggle_timers(False) motion.stop() time.sleep(1) _ask_for_point() time.sleep(1) _ctrl_on = True _odom_on = True _toggle_timers(True) elif action == 'TOGGLE_CNTRL': _ctrl_on = not _ctrl_on print("Controller: {}".format(_ctrl_on)) elif action == 'TOGGLE_SMOOTH': _smooth = not _smooth print("Smooth: {}".format(_smooth)) elif action == 'TOGGLE_ODOM': _odom_on = not _odom_on print("Odom: {}".format(_odom_on)) elif action == 'BATTERY': print("\n\r*** Battery: {} ***\n\r".format(get_battery())) elif action == 'BREAKPOINT': _toggle_timers(False) import ipdb; ipdb.set_trace() _toggle_timers(True) elif action == 'CALIBRATION_MODE': _toggle_timers(False) _deal_with_calibration() time.sleep(1) _toggle_timers(True) elif action == 'DIE': _toggle_timers(False) motion.stop() w.kill() return sys.exit(0) else: _set_speed = True _velocities = (0, 0, 0) # handle stopping before changing directions if _action_requires_stop(action): _set_speed = False motion.stop() time.sleep(0.4) _set_speed = True _previous_action = action print "{}\r".format(_velocities)
def __init__(self, app, interval): self._app = app self._timer = RepeatedTimer(interval, self._sample)
def fun_reminder(): user = users.find() current_time = datetime.datetime.now().time() day = weekday_now(datetime.date.today().weekday() + 1) for i in user: _id = i['_id'] if current_time.hour == i['daily_warn_time'][ 'h'] and current_time.minute == i['daily_warn_time']['m']: time = timers.find_one({'_id': _id}) if time: time = time.get(day) if time: send_reminder_mess(_id, {day: time}) rt_warnings = RepeatedTimer(60, fun_warnings) rt_reminders = RepeatedTimer(60, fun_reminder) print('Work hard, play hard!') #Обработка команды старт. @bot.message_handler(commands=['start']) def send_start(message): try: _id = message.chat.id user_id = {'_id': _id} if not dict_users.get(_id): dict_users[_id] = User(id=_id) if not users.find_one(user_id): user_id.update({
def video_start(): t.start() def video_stop(): #cap.release() t.stop() #================================Functions================================================== #================================Main Program=============================================== cap = cv2.VideoCapture(0) Gray_1 = cv2.cvtColor(cap.read()[1], cv2.COLOR_BGR2GRAY) t = RepeatedTimer(0.01, video) Values = [0 for x in range(100)] #=========================================================================================== #=================================GUI Section============================================= root = Tk() root.geometry('1000x700') f = Figure(figsize=(4, 4), dpi=50) axis = f.add_subplot(111) canvas = FigureCanvasTkAgg(f, master=root) canvas.get_tk_widget().place(x=10, y=30) frame2 = Frame(root) frame2.place(x=20, y=300) X_Axis = pylab.arange(0, 100, 1) plotFigure = Figure(figsize=(4, 4), dpi=50)
def start(self, GAME_KEEPER): self.TASKS.append(RepeatedTimer(20, GAME_KEEPER.create_games_for_queue)) self.TASKS.append(RepeatedTimer(10, GAME_KEEPER.check_current_games))
def start(self): self.thread = create_and_start_thread(self.download, "DownloadNodeJS") if self.animation_loader: self.interval_animation = RepeatedTimer( self.animation_loader.sec, self.animation_loader.animate)
clock = pygame.time.Clock() icon = pygame.image.load('icon.png') pygame.display.set_icon(icon) screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) pygame.display.set_caption('Insofar') exit = False player = Player() lasers = [] asteroids = [] stars_x = random.sample(range(0, SCREEN_WIDTH), NUM_STARS) stars_y = random.sample(range(0, SCREEN_HEIGHT), NUM_STARS) asteroid_timer = RepeatedTimer(ASTEROID_SPAWN_RATE, spawn, asteroids) death = False death_text = CenterText('You died!', (255, 255, 0)) while exit is False: joystick_count = pygame.joystick.get_count() if joystick_count == 0: print('Missing joystick!') exit = True else: move_joystick = pygame.joystick.Joystick(0) move_joystick.init()
print ("GATT application ip address %s" % ip_address, flush=True) ble_app.services[SYSTEM_SERVICE_INDEX].set_ip_address(ip_address) def shouldShutdown(): if not shutdown_button.value: print('Should shutdown system..', flush=True) shutdown() # execution ble_app = BleApplication() ble_app.add_service(WeatherService(WEATHER_SERVICE_INDEX)) ble_app.add_service(RgbColorService(RGB_COLOR_SERVICE_INDEX)) ble_app.add_service(SystemService(SYSTEM_SERVICE_INDEX)) ble_app.register() ble_adv = WeatherStationAdvertisement(0) ble_adv.register() timer_update = RepeatedTimer(DELAY_WEATHER_REQUEST, updateWeather) timer_system = RepeatedTimer(DELAY_DETECT_MANUAL_SHUTDOWN, shouldShutdown) try: print('GATT application running') fetchIpAddress() ble_app.run() except KeyboardInterrupt: ble_app.quit() pass stop()
def start_timer(self): self.threading_timer = RepeatedTimer(3, self.refresh) self.threading_timer.start()
def run(self): # get the first pending update_id, this is so we can skip over it in case # we get an "Unauthorized" exception. try: self.update_id = self.bot.get_updates()[0].update_id except IndexError: self.update_id = None # Create repeated timer to check for new file if self.bot_log_enabled: new_file_timer = RepeatedTimer(self.check_file_ts, self.new_file_timer_callback) new_file_timer.start() line_count = 0 info_ready = False info_msg = "" loss_list = [] # Loop checking for user message and new useful log line while True: try: if self.log_file_found and self.bot_log_enabled: logging.info("Check log") message = "" figure_name = "" while len(message) < 100 * 40: where = self.log_file.tell() line = self.log_file.readline() if line: if line_count < 35: #TODO: check if line == "Done!" for support network with different layers number info_msg += line line_count += 1 if line_count > 34: try: self.bot.sendMessage( self.chat_id, info_msg) except: logging.info( "Failed to send INFO message!") else: # Check if the row match the ITER lane data_match = re.findall(self.line_regex, line) if data_match: # Lane report ITER result data_match = data_match[0] iter_n = int(data_match[0]) loss_v = float(data_match[1]) loss_list.append(loss_v) logging.info("ITERATION NUMBER: " + str(iter_n)) if iter_n == 1 or ( iter_n % self.log_evry_iter) == 0: loss_np = np.asarray(loss_list, dtype=np.float32) # Create training loss graph figure_name = self.bkup_folder + "/iter" + data_match[ 0] + ".png" plt.clf() plt.plot(loss_np, 'o-') plt.title('Iteration: ' + data_match[0]) plt.ylabel('Loss') plt.xlabel('Iteration') #plt.show() plt.savefig(figure_name, bbox_inches='tight') message += "|----> ITER " + data_match[ 0] + "\n" message += "| |--> loss " + data_match[ 1] + "\n" message += "| |--> avg " + data_match[ 2] + "\n" message += "| |--> sec " + data_match[ 4] + "\n" message += "| '--> img " + data_match[ 5] + "\n" else: self.log_file.seek(where) if len(message) > 0: logging.info("Sending ITERATION message!") try: self.bot.sendMessage(self.chat_id, message) except: logging.info( "Iteratino message skipped can not send!" ) break time.sleep(1) logging.info("check file in backup folder") try: self.echo() except NetworkError: logging.info("NETWORK ERROR") sleep(1) except Unauthorized: # The user has removed or blocked the bot. logging.info("UNAUTHORIZED") update_id += 1 except KeyboardInterrupt: # TODO: maybe add a big could be needed to ensure all file are loaded logging.info("ctrl C caught terminating") break new_file_timer.stop() self.log_file.close()
def start_reception(self): self.timer = RepeatedTimer(1, self.receive_signal)