class DatDashSampler: def __init__(self, app, interval): self._app = app self._timer = RepeatedTimer(interval, self._sample) def stop(self): self._timer.stop() def name(self): """ Child class implements this function """ return "UnknownSampler" def sample(self): """ Child class implements this function """ return {} def _send_event(self, widget_id, body): body["id"] = widget_id body["updateAt"] = \ datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S +0000") formatted_json = "data: %s\n\n" % (json.dumps(body)) self._app.last_events[widget_id] = formatted_json for event_queue in self._app.events_queue.values(): event_queue.put(formatted_json) def _sample(self): data = self.sample() if data: self._send_event(self.name(), data)
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." )
class DashieSampler(object): def __init__(self, app, interval): self._app = app self._timer = RepeatedTimer(interval, self._sample) def stop(self): self._timer.stop() def name(self): ''' Child class implements this function ''' return 'UnknownSampler' def sample(self): ''' Child class implements this function ''' return {} def _send_event(self, widget_id, body): body['id'] = widget_id body['updateAt'] = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S +0000') formatted_json = 'data: %s\n\n' % (json.dumps(body)) self._app.last_events[widget_id] = formatted_json for event_queue in self._app.events_queue.values(): event_queue.put(formatted_json) def _sample(self): data = self.sample() if data: self._send_event(self.name(), data)
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 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 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)
class MultiTouchInput: current_state = 0 current_state_counter = [0] * 12 touch_timer = None 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 stop(self): if self.touch_timer is not None: self.touch_timer.stop() def state_to_queue(self, state): for item in config.KEYMAP_MULTI_TOUCH.items(): if state & (1 << item[0]): self.key_queue.put(item[1]) def touch_tick(self): state = 0 for i in range(12): if self.current_state & (1 << i): self.current_state_counter[i] += 1 else: self.current_state_counter[i] = 0 if self.current_state_counter[i] > 5: state |= (1 << i) if state != 0: self.state_to_queue(state) def cb_touch_state(self, state): changed_state = self.current_state ^ state self.current_state = state self.state_to_queue(changed_state & self.current_state)
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()
class MultiTouchInput: current_state = 0 current_state_counter = [0]*12 touch_timer = None 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 stop(self): if self.touch_timer is not None: self.touch_timer.stop() def state_to_queue(self, state): for item in config.KEYMAP_MULTI_TOUCH.items(): if state & (1 << item[0]): self.key_queue.put(item[1]) def touch_tick(self): state = 0 for i in range(12): if self.current_state & (1 << i): self.current_state_counter[i] += 1 else: self.current_state_counter[i] = 0 if self.current_state_counter[i] > 5: state |= (1 << i) if state != 0: self.state_to_queue(state) def cb_touch_state(self, state): changed_state = self.current_state ^ state self.current_state = state self.state_to_queue(changed_state & self.current_state)
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 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: 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("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 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 if not config.IS_LED_STRIP_V2: self.led_strip.register_callback(self.led_strip.CALLBACK_FRAME_RENDERED, None) else: self.led_strip.register_callback(self.led_strip.CALLBACK_FRAME_STARTED, None) self.timer.stop() self.kp.stop()
def run_game_loop(self): self.frame_rendered(0) self.drop_timer = RepeatedTimer(1.0, self.drop_tetromino) while self.loop: key = self.kp.read_single_keypress() if key == 'a': self.speaker.beep_input() self.move_tetromino(0, -1, self.tetromino_form) elif key == 'd': self.speaker.beep_input() self.move_tetromino(0, 1, self.tetromino_form) elif key == 's': self.speaker.beep_input() self.move_tetromino(1, 0, self.tetromino_form) elif key == 'k': self.speaker.beep_input() self.move_tetromino(0, 0, (self.tetromino_form-1) % 4) elif key == 'l': self.speaker.beep_input() self.move_tetromino(0, 0, (self.tetromino_form+1) % 4) elif key == 'r': self.init_game() elif not config.HAS_GUI and key == 'q': break if not config.IS_LED_STRIP_V2: self.led_strip.register_callback(self.led_strip.CALLBACK_FRAME_RENDERED, None) else: self.led_strip.register_callback(self.led_strip.CALLBACK_FRAME_STARTED, None) self.drop_timer.stop() self.kp.stop()
def __init__(self, *args, **kwargs): tk.Tk.__init__(self, *args, **kwargs) tk.Tk.title(self, 'OpenSlides') tk.Tk.resizable(self, width=False, height=False) self.protocol('WM_DELETE_WINDOW', self.on_close_app) self.root = tk.Frame(self, bg=self.cget('bg')) self.root.pack(side="top", fill="both", expand = True) self.btn_settings = None self.btn_db_backup = None self.btn_sync_db = None self.btn_reset_admin = None self.chb_auto_svr = None self.btn_server = None self.backup_timer = RepeatedTimer(self.on_backup_timer) self.lbl_host = None self.lbl_port = None if not self.initialize_gui(): self.quit() self.createMenuBar() self.createMainframe()
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 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: 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 __init__(self, msg_func, master): self.msg_func = msg_func self.master = master self.child_process = None self.output_queue = queue.Queue() self.output_read_thread = None self.output_mutex = threading.RLock() self.update_timer = RepeatedTimer(self.on_update_timer) self._exitcode = None
def start(self, info): logging.info('Master Starts') self.last_wake_time = datetime.datetime.utcnow() self.is_started = True self.pop_forever_handler = threading.Thread(target=self.start_popping_tasks) self.pop_forever_handler.start() self.repeated_timer = RepeatedTimer(self.clean_time_gap, self.notice_refresh, None)
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 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 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
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 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 __init__(self): # GPIO番号でピンを指定 # ServoBlasterの起動(rootで実行する必要あり) # 50%指定時の中間位置を--maxで調整する。--max=200がちょうどよかった os.system('sudo /home/pi/PiBits/ServoBlaster/user/servod --idle-timeout=2000 --max=200') self.servos = [] for index in RPiServoblasterController.PIN_MAP.iterkeys(): pin = RPiServoblasterController.PIN_MAP[index] # サーボを作る self.servos.append(SG90Servoblaster(pin, self.getPartName(index))) # self.positionの内容を定期的にcommit()を使ってservoblasterで反映する self.positions = [] self.timer = RepeatedTimer(RPiServoblasterController.COMMIT_INTERVAL_SEC, self.commit) self.timer.start()
def __init__(self, address=0x40): # I2C経由でのコントロール用ライブラリ # https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code.git self.pwm = Adafruit_PCA9685.PCA9685(address, busnum=1) self.pwm.set_pwm_freq(SG90PCA9685.PWM_FREQ) self.servos = [] for index in RPiPCA9685Controller.PIN_MAP.iterkeys(): pin = RPiPCA9685Controller.PIN_MAP[index] # サーボを作る self.servos.append(SG90PCA9685(pin, self.getPartName(index), self.pwm)) # self.positionの内容を定期的にcommit()を使ってservoblasterで反映する self.positions = [] self.timer = RepeatedTimer(RPiPCA9685Controller.COMMIT_INTERVAL_SEC, self.commit) self.timer.start()
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 __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, app, interval): self._app = app self._timer = RepeatedTimer(interval, self._sample)
class DownloadNodeJS(object): def __init__(self, node_version): self.NODE_JS_VERSION = node_version self.NODE_JS_TAR_EXTENSION = ".zip" if node_variables.NODE_JS_OS == "win" else ".tar.gz" self.NODE_JS_BINARY_URL = "https://nodejs.org/dist/" + self.NODE_JS_VERSION + "/node-" + self.NODE_JS_VERSION + "-" + node_variables.NODE_JS_OS + "-" + node_variables.NODE_JS_ARCHITECTURE + self.NODE_JS_TAR_EXTENSION self.NODE_JS_BINARY_TARFILE_NAME = self.NODE_JS_BINARY_URL.split( '/')[-1] self.NODE_JS_BINARY_TARFILE_FULL_PATH = os.path.join( node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM, self.NODE_JS_BINARY_TARFILE_NAME) self.animation_loader = AnimationLoader([ "[= ]", "[ = ]", "[ = ]", "[ = ]", "[ =]", "[ = ]", "[ = ]", "[ = ]" ], 0.067, "Downloading: " + self.NODE_JS_BINARY_URL + " ") self.interval_animation = None self.thread = None if not os.path.exists(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM): os.makedirs(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) def download(self): try: request = urllib.request.Request(self.NODE_JS_BINARY_URL) request.add_header( 'User-agent', r'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.1 (KHTML, like Gecko) Chrome/22.0.1207.1 Safari/537.1' ) with urllib.request.urlopen(request) as response: with open(self.NODE_JS_BINARY_TARFILE_FULL_PATH, 'wb') as out_file: shutil.copyfileobj(response, out_file) except Exception as err: traceback.print_exc() self.on_error(err) return self.extract() self.on_complete() 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 extract(self): if self.NODE_JS_TAR_EXTENSION != ".zip": with tarfile.open(self.NODE_JS_BINARY_TARFILE_FULL_PATH, "r:gz") as tar: for member in tar.getmembers(): if member.name.endswith("/bin/node"): member.name = node_variables.NODE_JS_PATH_EXECUTABLE tar.extract( member, node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) break else: with zipfile.ZipFile(self.NODE_JS_BINARY_TARFILE_FULL_PATH, "r") as zip_file: for member in zip_file.namelist(): if member.endswith("/node.exe"): with zip_file.open(member) as node_file: with open( os.path.join( node_variables. NODE_JS_BINARIES_FOLDER_PLATFORM, "node.exe"), "wb") as target: shutil.copyfileobj(node_file, target) break def on_error(self, err): self.animation_loader.on_complete() self.interval_animation.stop() sublime.active_window().status_message( "Can't install Node.js! Check your internet connection!") 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() if node_js.getCurrentNodeJSVersion() == self.NODE_JS_VERSION: sublime.active_window().status_message("Node.js " + self.NODE_JS_VERSION + " installed correctly!") else: sublime.active_window().status_message( "Can't install Node.js! Something during installation went wrong." )
class Master: def msg_callback(self, ch, method, properties, body): callback_set = {'SUCCESS': self.success, 'FAIL': self.fail, 'AWAKE': self.update_slave_response_time, 'STOP': self.stop, 'ADD_SLAVE': self.add_slave, 'KILL_SLAVE': self.kill_slave, 'RESTART_SLAVE': self.restart_slave, 'STAT': self.stat, 'START': self.start, 'RECONFIGURE': self.configure, 'REFRESH': self.refresh } try: command = body[:body.find(' ')] info = body[body.find(' ')+1:] if command in callback_set: callback_set[command](ujson.loads(info)) else: logging.debug(" [x] Unknown command %r" % (str(body),)) except KeyError as e: if str(e) == "'Queue.DeclareOk'": logging.debug("Queue.DelcareOk at %r" % (str(body),)) else: logging.error("Unknown KeyError at %r:" % (str(body),)) except RuntimeError as e: if 'recursion' in str(e): logging.error('MAXIMUM RECURSION ERROR') def __init__(self, conf_file): self.config = ConfigParser.ConfigParser(allow_no_value=True) self.clean_time_gap = None self.wait_time_for_slave = None self.master_queue_name = None self.task_queue_name = None self.task_queue_size_limit = None self.task_file_name = None self.task_counter_file = None self.ssh_key = None self.s3_bucket = None self.s3_folder = None self.slave_num_every_packup = None self.slave_max_sec_each_task = None self.slave_python_version = None self.master_ip = None self.slaves_ip = None self.slave_awake_frequency = None self.configure(conf_file) self.last_wake_time = None self.repeated_timer = None self.is_started = False self.pop_forever_handler = None logging.info('Starting task manager...') self.task_manager = TaskManager(self.task_file_name, self.task_counter_file) logging.info('Starting slave manager...') self.slave_manager = SlaveManager(master_ip=self.master_ip, slaves_ip=self.slaves_ip, ssh_key=self.ssh_key, s3_bucket=self.s3_bucket, s3_folder=self.s3_folder, slave_num_every_packup=self.slave_num_every_packup, slave_max_sec_each_task=self.slave_max_sec_each_task, slave_python_version=self.slave_python_version, slave_awake_frequency=self.slave_awake_frequency, slave_buffer_size=1) logging.info('Starting connection manager...') self.message_connection = ConnectionManager(queue_name=self.master_queue_name, durable=False, callback=self.msg_callback, no_ack=True) def run(self): logging.info(' [*] Waiting for messages. To exit press CTRL+C') try: self.message_connection.start_accepting_message() except KeyboardInterrupt: logging.info('Stopping master...') master.stop(None) except EOFError: logging.info('Download finishes. Shutting down master.') master.stop(None) # except Exception as e: # logging.info(str(e)) # logging.info('Stopping master...') # TODO: write all configuration in one file def configure(self, conf_file): self.config.read(conf_file) self.clean_time_gap = self.config.getint('main', 'clean_time_gap') self.wait_time_for_slave = self.config.getint('main', 'wait_time_for_slave') self.slave_awake_frequency = self.config.get('main', 'slave_awake_frequency') self.master_ip = self.config.get('main', 'master_private_ip') self.slaves_ip = self.config.get('main', 'slaves_private_ip') self.master_queue_name = self.config.get('main', 'master_queue_name') self.task_queue_name = self.config.get('main', 'task_queue_name') self.task_file_name = self.config.get('main', 'task_file') self.task_queue_size_limit = int(self.config.get('main', 'task_queue_size_limit')) self.task_counter_file = self.config.get('main', 'task_counter_file') self.ssh_key = self.config.get('main', 'ssh_key') self.s3_bucket = self.config.get('main', 's3_bucket') self.s3_folder = self.config.get('main', 's3_folder') self.slave_num_every_packup = self.config.get('main', 'slave_num_every_packup') self.slave_max_sec_each_task = self.config.get('main', 'slave_max_sec_each_task') self.slave_python_version = self.config.get('main', 'slave_python_version') def add_slave(self, slave_info): if self.slave_manager.exist_slave(slave_info): logging.info('Slave ' + slave_info['host'] + ' already exists.') return logging.info('master: add slave' + str(slave_info)) new_slave_info = self.slave_manager.add_slave(slave_info) self.slave_manager.run_slave(new_slave_info) # TODO: def kill_slave(self, slave_info): if not self.slave_manager.exist_slave(slave_info): return logging.info('kill slave ' + str(slave_info)) self.slave_manager.kill_slave(slave_info) def restart_slave(self, slave_info): logging.info(slave_info['host']) logging.info('restart_slave' + str(slave_info)) self.kill_slave(slave_info) self.add_slave(slave_info) def start(self, info): logging.info('Master Starts') self.last_wake_time = datetime.datetime.utcnow() self.is_started = True self.pop_forever_handler = threading.Thread(target=self.start_popping_tasks) self.pop_forever_handler.start() self.repeated_timer = RepeatedTimer(self.clean_time_gap, self.notice_refresh, None) def pop_forever(self): self.start_popping_tasks() def get_task_queue_size(self): pass # TODO: There is a bottle neck here def start_popping_tasks(self): task_connection = ConnectionManager(queue_name=self.task_queue_name, durable=True, no_ack=False) eof_reached = False while self.is_started and not eof_reached: current_task_queue_size = task_connection.get_task_queue_size() while self.is_started and current_task_queue_size < self.task_queue_size_limit: task = self.task_manager.pop_task() if task is None: # TODO: Don't use Error. Just break and handle the case later in this function logging.info('EOF Reached') eof_reached = True break message = 'WORK ' + ujson.dumps(task) task_connection.publish(message) current_task_queue_size += 1 task_connection.stop() def fail(self, slave_task_info): self.task_manager.add_task(slave_task_info['task']) self.slave_manager.update_last_response(slave_task_info) def success(self, slave_task_info): slave_info = self.slave_manager.update_last_response(slave_task_info) def update_slave_response_time(self, slave_task_info): slave_info = self.slave_manager.update_last_response(slave_task_info) def stop(self, info): self.is_started = False self.notice_slaves_stop() if self.pop_forever_handler is not None: self.pop_forever_handler.join() if self.repeated_timer is not None: self.repeated_timer.stop() self.slave_manager.stop() self.task_manager.stop() self.message_connection.stop() def notice_slaves_stop(self): task_connection = ConnectionManager(queue_name=self.task_queue_name, durable=True, no_ack=False) screen_list = [key for key in self.slave_manager.slave_dict.keys()] for screen in screen_list: task_connection.publish('STOP {}') # task_connection.broadcast_task('STOP {}') task_connection.stop() def refresh(self, info): cur_progress, total_task = self.task_manager.get_progress() logging.info('downloading {}/{} files'.format(cur_progress, total_task)) if not self.is_started: return # if time interval met, check failed slave if self.last_wake_time is None: self.last_wake_time = datetime.datetime.utcnow() if self.last_wake_time + datetime.timedelta( seconds=self.clean_time_gap) > datetime.datetime.utcnow(): return failed_slaves = self.slave_manager.get_failed_slaves(self.wait_time_for_slave) if len(failed_slaves) != 0: logging.info('Finding failed slaves... ' + str(failed_slaves)) for slave in failed_slaves: self.restart_slave(slave) self.last_wake_time = datetime.datetime.utcnow() def notice_refresh(self, info): try: self.message_connection.publish('REFRESH {}') except IndexError: logging.critical('INDEX_ERROR') def stat(self, info): logging.info('=====================================') logging.info('Num of slave: ', self.slave_manager.get_num_slaves()) logging.info('=====================================') if len(info) > 0: for slave in self.slave_manager.slave_list: if slave['last_response'] is None: delta = 'new slave' else: delta = datetime.datetime.utcnow() - slave['last_response'] logging.info(slave['host'], '|', slave['queue'], '|', delta) logging.info('====================================')
class RPiServoblasterController: # ServoBlasterへの反映間隔 COMMIT_INTERVAL_SEC = 0.1 # ./servodを実行した時のピン番号を使う(GPIOの番号でも、物理位置番号でもない) WAIST_SERVO_PIN = 7 BOOM_SERVO_PIN = 6 ARM_SERVO_PIN = 5 CRAW_SERVO_PIN = 4 # 操作対象とピン番号のマップ PIN_MAP = { 0: WAIST_SERVO_PIN, 1: BOOM_SERVO_PIN, 2: ARM_SERVO_PIN, 3: CRAW_SERVO_PIN, } def __init__(self): # GPIO番号でピンを指定 # ServoBlasterの起動(rootで実行する必要あり) # 50%指定時の中間位置を--maxで調整する。--max=200がちょうどよかった os.system('sudo /home/pi/PiBits/ServoBlaster/user/servod --idle-timeout=2000 --max=200') self.servos = [] for index in RPiServoblasterController.PIN_MAP.iterkeys(): pin = RPiServoblasterController.PIN_MAP[index] # サーボを作る self.servos.append(SG90Servoblaster(pin, self.getPartName(index))) # self.positionの内容を定期的にcommit()を使ってservoblasterで反映する self.positions = [] self.timer = RepeatedTimer(RPiServoblasterController.COMMIT_INTERVAL_SEC, self.commit) self.timer.start() # 直接同期的にservoblasterを呼ぶのではなく、 # 一度内容をインスタンス変数に格納しておき、定期的にservoblasterで反映させる def apply(self, positions): self.positions = positions def shutdown(self): # if self.timer is not None: self.timer.cancel() def getIndexes(self): return RPiServoblasterController.PIN_MAP.keys() def switchDebugPosition(self): for index in RPiServoblasterController.PIN_MAP.iterkeys(): self.servos[index].switchDebugPosition() # マルチスレッド下でタイマーから実行される def commit(self): if 0 == len(self.positions): return for index in RPiServoblasterController.PIN_MAP.iterkeys(): degree = self.positions[index] self.servos[index].rotateTo(degree) def getPartName(self, index): if(0 == index): return 'WAIST' elif(1 == index): return 'BOOM' elif(2 == index): return 'ARM' elif(3 == index): return 'CRAW' else: return 'unknown'
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 start_timer(self): self.threading_timer = RepeatedTimer(3, self.refresh) self.threading_timer.start()
class Tetris: FIELD_ROWS = config.LED_ROWS+4 # 22 rows in playfield, with only 20 columns visible and 2 coloms border FIELD_COLS = config.LED_COLS+2 # 10 columns in playfield, 2 column border FIELD_ROW_START = 2 FIELD_COL_START = 4 COLORS = [ ( 10, 10, 10), # grey (255, 0, 0), # red (255, 80, 0), # orange (255, 255, 0), # yellow ( 0, 255, 0), # green ( 0, 0, 255), # blue (255, 0, 150), # violet (255, 0, 40), # purple ] TETROMINOS = { None: [[[0], [0], [0], [0]]], 'I': [[[0,0,0,0], [0,0,2,0], [0,0,0,0], [0,2,0,0]], [[2,2,2,2], [0,0,2,0], [0,0,0,0], [0,2,0,0]], [[0,0,0,0], [0,0,2,0], [2,2,2,2], [0,2,0,0]], [[0,0,0,0], [0,0,2,0], [0,0,0,0], [0,2,0,0]]], 'J': [[[6,0,0], [0,6,6], [0,0,0], [0,6,0]], [[6,6,6], [0,6,0], [6,6,6], [0,6,0]], [[0,0,0], [0,6,0], [0,0,6], [6,6,0]]], 'L': [[[0,0,5], [0,5,0], [0,0,0], [5,5,0]], [[5,5,5], [0,5,0], [5,5,5], [0,5,0]], [[0,0,0], [0,5,5], [5,0,0], [0,5,0]]], 'O': [[[0,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0]], [[0,1,1,0], [0,1,1,0], [0,1,1,0], [0,1,1,0]], [[0,1,1,0], [0,1,1,0], [0,1,1,0], [0,1,1,0]]], 'S': [[[0,3,3], [0,3,0], [0,0,0], [3,0,0]], [[3,3,0], [0,3,3], [0,3,3], [3,3,0]], [[0,0,0], [0,0,3], [3,3,0], [0,3,0]]], 'T': [[[0,7,0], [0,7,0], [0,0,0], [0,7,0]], [[7,7,7], [0,7,7], [7,7,7], [7,7,0]], [[0,0,0], [0,7,0], [0,7,0], [0,7,0]]], 'Z': [[[4,4,0], [0,0,4], [0,0,0], [0,4,0]], [[0,4,4], [0,4,4], [4,4,0], [4,4,0]], [[0,0,0], [0,4,0], [0,4,4], [4,0,0]]] } GAME_OVER_TEXT = [ "GameOverGameOverGameOverGameOverGameOverGameOverGameOve", " ", " GGGG OO ", " G GG O O ", " G aaa mmm mm ee O O v v ee rr ", " G GG a m m m e e O O v v e e r r ", " G G aaaa m m m eeee O O v v eeee r ", " G G a a m m m e O O v v e r ", " GGGG aaaa m m m eee OO v eee r ", " ", " ", "GameOverGameOverGameOverGameOverGameOverGameOverGameOve" ] GAME_OVER_COLORS = { ' ': 0, 'G': 1, 'a': 2, 'm': 3, 'e': 4, 'O': 5, 'v': 6, 'r': 7 } drop_timer = None tetromino_current = 'O' tetromino_form = 0 tetromino_pos_row = FIELD_ROW_START tetromino_pos_col = FIELD_COL_START playfield = [x[:] for x in [[0]*FIELD_COLS]*FIELD_ROWS] random_bag = ['O', 'I', 'S', 'Z', 'L', 'J', 'T'] random_bag_index = len(random_bag)-1 game_over_position = 0 is_game_over = False loop = True def __init__(self, ipcon): self.okay = False self.ipcon = ipcon if not config.UID_LED_STRIP_BRICKLET: print("Not Configured: LED Strip or LED Strip V2 (required)") return if not config.IS_LED_STRIP_V2: self.led_strip = LEDStrip(config.UID_LED_STRIP_BRICKLET, self.ipcon) else: self.led_strip = LEDStripV2(config.UID_LED_STRIP_BRICKLET, self.ipcon) try: self.led_strip.get_frame_duration() if not config.IS_LED_STRIP_V2: print("Found: LED Strip ({0})".format(config.UID_LED_STRIP_BRICKLET)) else: print("Found: LED Strip V2 ({0})".format(config.UID_LED_STRIP_BRICKLET)) except: if not config.IS_LED_STRIP_V2: print("Not Found: LED Strip ({0})".format(config.UID_LED_STRIP_BRICKLET)) else: print("Not Found: LED Strip V2({0})".format(config.UID_LED_STRIP_BRICKLET)) return self.kp = KeyPress(self.ipcon) self.display = TetrisSegmentDisplay(self.ipcon) self.speaker = TetrisSpeaker(self.ipcon) self.okay = True self.led_strip.set_frame_duration(40) if not config.IS_LED_STRIP_V2: self.led_strip.register_callback(self.led_strip.CALLBACK_FRAME_RENDERED, self.frame_rendered) else: self.led_strip.register_callback(self.led_strip.CALLBACK_FRAME_STARTED, self.frame_rendered) self.led_strip.set_channel_mapping(config.CHANNEL_MAPPING) self.init_game() def init_game(self): self.tetromino_current = 'O' self.tetromino_form = 0 self.tetromino_pos_row = self.FIELD_ROW_START self.tetromino_pos_col = self.FIELD_COL_START # Add border to playfield self.playfield = [x[:] for x in [[0]*self.FIELD_COLS]*self.FIELD_ROWS] self.playfield[0] = [255]*self.FIELD_COLS self.playfield[-1] = [255]*self.FIELD_COLS for col in self.playfield[1:-1]: col[0] = 255 col[-1] = 255 # initialize current tetronimo randomly self.tetromino_current = self.get_random_tetromino() self.is_game_over = False if self.drop_timer: self.drop_timer.interval = 1 def frame_rendered(self, length): self.write_playfield() # See http://tetris.wikia.com/wiki/Random_Generator for # details of random bag implementation according to tetris specification def get_random_tetromino(self): self.random_bag_index += 1 if self.random_bag_index >= len(self.random_bag): self.random_bag_index = 0 random.shuffle(self.random_bag) return self.random_bag[self.random_bag_index] def add_tetromino_to_field(self, field, pos_row, pos_col, tetromino, form): for index_col, col in enumerate(self.TETROMINOS[tetromino]): for index_row, color in enumerate(col[form]): if color != 0: row = pos_row + index_row col = pos_col + index_col if row >= 0 and row < self.FIELD_ROWS and col >= 0 and col < self.FIELD_COLS: field[row][col] = color def tetromino_fits(self, field, pos_row, pos_col, tetromino, form): for index_col, col in enumerate(self.TETROMINOS[tetromino]): for index_row, color in enumerate(col[form]): if color != 0: row = pos_row + index_row col = pos_col + index_col if row >= 0 and row < self.FIELD_ROWS and col >= 0 and col < self.FIELD_COLS: if field[row][col] != 0: return False return True def write_playfield(self): if not self.okay: return field = copy.deepcopy(self.playfield) if not self.is_game_over: self.add_tetromino_to_field(field, self.tetromino_pos_row, self.tetromino_pos_col, self.tetromino_current, self.tetromino_form) # Reorder LED data into R, G and B channel r = [] g = [] b = [] frame = [] for row in reversed(range(3, self.FIELD_ROWS-1)): col_range = range(1, self.FIELD_COLS-1) if row % 2 == 0: col_range = reversed(col_range) for col in col_range: r.append(self.COLORS[field[row][col]][0]) g.append(self.COLORS[field[row][col]][1]) b.append(self.COLORS[field[row][col]][2]) frame.append(self.COLORS[field[row][col]][0]) frame.append(self.COLORS[field[row][col]][1]) frame.append(self.COLORS[field[row][col]][2]) if not config.IS_LED_STRIP_V2: # Make chunks of size 16 r_chunk = [r[i:i+16] for i in range(0, len(r), 16)] g_chunk = [g[i:i+16] for i in range(0, len(g), 16)] b_chunk = [b[i:i+16] for i in range(0, len(b), 16)] for i in range(len(r_chunk)): length = len(r_chunk[i]) # Fill up chunks with zeros r_chunk[i].extend([0]*(16-len(r_chunk[i]))) g_chunk[i].extend([0]*(16-len(g_chunk[i]))) b_chunk[i].extend([0]*(16-len(b_chunk[i]))) try: self.led_strip.set_rgb_values(i*16, length, r_chunk[i], g_chunk[i], b_chunk[i]) except: break else: try: self.led_strip.set_led_values(0, frame) except: return def clear_lines(self, rows_to_clear): if not self.okay: return self.drop_timer.stop() rows_save = {} for to_clear in rows_to_clear: rows_save[to_clear] = self.playfield[to_clear] self.display.increase_line_count(len(rows_to_clear)) self.speaker.beep_delete_line(len(rows_to_clear)) for i in range(6): if i % 2 == 0: for to_clear in rows_to_clear: self.playfield[to_clear] = [255] + [0]*(self.FIELD_COLS-2) + [255] else: for to_clear in rows_to_clear: self.playfield[to_clear] = rows_save[to_clear] time.sleep(0.1) for to_clear in rows_to_clear: for row in reversed(range(1, to_clear+1)): self.playfield[row] = self.playfield[row-1] self.playfield[1] = [255] + [0]*(self.FIELD_COLS-2) + [255] self.drop_timer.start() def check_for_lines_to_clear(self): rows_to_clear = [] for row_index, col in enumerate(self.playfield[1:-1]): to_clear = True for color in col[1:-1]: if color == 0: to_clear = False break if to_clear: rows_to_clear.append(row_index+1) if len(rows_to_clear) > 0: self.clear_lines(rows_to_clear) def new_tetromino(self): self.add_tetromino_to_field(self.playfield, self.tetromino_pos_row, self.tetromino_pos_col, self.tetromino_current, self.tetromino_form) self.tetromino_current = None self.check_for_lines_to_clear() self.tetromino_current = self.get_random_tetromino() self.tetromino_pos_row = self.FIELD_ROW_START self.tetromino_pos_col = self.FIELD_COL_START self.tetromino_form = 0 if not self.tetromino_fits(self.playfield, self.tetromino_pos_row, self.tetromino_pos_col, self.tetromino_current, self.tetromino_form): self.is_game_over = True self.game_over_position = 0 self.drop_timer.interval = 0.15 def next_game_over_step(self): for row in range(len(self.GAME_OVER_TEXT)): for col in range(config.LED_COLS): k = (self.game_over_position+col) % len(self.GAME_OVER_TEXT[0]) self.playfield[7+row][1+col] = self.GAME_OVER_COLORS[self.GAME_OVER_TEXT[row][k]] self.game_over_position += 1 def drop_tetromino(self): if self.is_game_over: self.next_game_over_step() return if self.tetromino_fits(self.playfield, self.tetromino_pos_row+1, self.tetromino_pos_col, self.tetromino_current, self.tetromino_form): self.tetromino_pos_row += 1 else: self.new_tetromino() def move_tetromino(self, row, col, form): if self.is_game_over: return if self.tetromino_fits(self.playfield, self.tetromino_pos_row+row, self.tetromino_pos_col+col, self.tetromino_current, form): self.tetromino_pos_row += row self.tetromino_pos_col += col self.tetromino_form = form if row > 0: # restart drop timer, so we don't drop two tetrominos in a row self.drop_timer.stop() self.drop_timer.start() elif row == 1: # user is at bottom and hits button to go down again self.new_tetromino() def run_game_loop(self): self.frame_rendered(0) self.drop_timer = RepeatedTimer(1.0, self.drop_tetromino) while self.loop: key = self.kp.read_single_keypress() if key == 'a': self.speaker.beep_input() self.move_tetromino(0, -1, self.tetromino_form) elif key == 'd': self.speaker.beep_input() self.move_tetromino(0, 1, self.tetromino_form) elif key == 's': self.speaker.beep_input() self.move_tetromino(1, 0, self.tetromino_form) elif key == 'k': self.speaker.beep_input() self.move_tetromino(0, 0, (self.tetromino_form-1) % 4) elif key == 'l': self.speaker.beep_input() self.move_tetromino(0, 0, (self.tetromino_form+1) % 4) elif key == 'r': self.init_game() elif not config.HAS_GUI and key == 'q': break if not config.IS_LED_STRIP_V2: self.led_strip.register_callback(self.led_strip.CALLBACK_FRAME_RENDERED, None) else: self.led_strip.register_callback(self.led_strip.CALLBACK_FRAME_STARTED, None) self.drop_timer.stop() self.kp.stop()
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)
class OpenSlides(tk.Tk): cmd_runner = None server_running = False gui_settings_path = None gui_initialized = False backupdb_enabled = False backupdb_destination = "" backupdb_interval = 15 backupdb_interval_unit = "minutes" last_backup = None backup_timer = None _host = "0.0.0.0" _port = "8000" def __init__(self, *args, **kwargs): tk.Tk.__init__(self, *args, **kwargs) tk.Tk.title(self, 'OpenSlides') tk.Tk.resizable(self, width=False, height=False) self.protocol('WM_DELETE_WINDOW', self.on_close_app) self.root = tk.Frame(self, bg=self.cget('bg')) self.root.pack(side="top", fill="both", expand = True) self.btn_settings = None self.btn_db_backup = None self.btn_sync_db = None self.btn_reset_admin = None self.chb_auto_svr = None self.btn_server = None self.backup_timer = RepeatedTimer(self.on_backup_timer) self.lbl_host = None self.lbl_port = None if not self.initialize_gui(): self.quit() self.createMenuBar() self.createMainframe() def initialize_gui(self): # Set path for gui settings to default user data according to the # OpenSlides type. This does not depend on any argument the user might # type in. openslides_type = detect_openslides_type() try: default_user_data_path = get_default_user_data_path(openslides_type) except PortableDirNotWritable: messagebox.showerror( _("Error: Portable directory not writable"), _("The portable directory is not writable. Please copy the " "openslides portable to a writeable location and start it " "again from there") ) return False self.gui_settings_path = os.path.join( default_user_data_path, 'openslides', 'gui_settings.json') self.load_gui_settings() self.apply_backup_settings() return True def load_gui_settings(self): if self.gui_settings_path is None: return try: f = open(self.gui_settings_path, "r", encoding="utf-8") except IOError as e: if e.errno == errno.ENOENT: return raise with f: settings = json.load(f) def setattr_unless_none(attr, value): if not value is None: setattr(self, attr, value) backup_settings = settings.get("database_backup", {}) setattr_unless_none("backupdb_enabled", backup_settings.get("enabled")) setattr_unless_none( "backupdb_destination", backup_settings.get("destination")) setattr_unless_none( "backupdb_interval", backup_settings.get("interval")) setattr_unless_none( "backupdb_interval_unit", backup_settings.get("interval_unit")) last_backup = backup_settings.get("last_backup") if not last_backup is None: self.last_backup = datetime.datetime.strptime( last_backup, "%Y-%m-%d %H:%M:%S") server_settings = settings.get("server_settings", {}) setattr_unless_none("_host", server_settings.get("host")) setattr_unless_none("_port", server_settings.get("port")) def save_gui_settings(self): if self.last_backup is None: last_backup = None else: last_backup = self.last_backup.strftime("%Y-%m-%d %H:%M:%S") settings = { "database_backup": { "enabled": self.backupdb_enabled, "destination": self.backupdb_destination, "internal": self.backupdb_interval, "interval_unit": self.backupdb_interval_unit, "last_backup": last_backup }, "server_settings": { "host": self.host, "port": self.port, }, } dp = os.path.dirname(self.gui_settings_path) if not os.path.exists(dp): os.makedirs(dp) with open(self.gui_settings_path, "w", encoding="utf-8") as f: json.dump(settings, f, ensure_ascii=False, indent=4) def createMenuBar(self): menubar = tk.Menu(self) appmenu = tk.Menu(menubar, name='apple') menubar.add_cascade(menu=appmenu) appmenu.add_command(label='About OpenSlides', command=self.about_dialog) appmenu.add_separator() self['menu'] = menubar def createMainframe(self): button_frame = ttk.Frame(self.root) button_frame.grid(row=0, column=1, sticky='WENS') lfb = ttk.LabelFrame(button_frame, text='Actions') lfb.pack() self.btn_db_backup = ttk.Button(lfb, text="Backup databse...", command=self.db_backup_dialog) self.btn_db_backup.grid(row=0, column=1, sticky='WENS') self.btn_sync_db = ttk.Button(lfb, text="Sync databse", command=self.on_sync_database) self.btn_sync_db.grid(row=1, column=1, sticky='WENS') self.btn_reset_admin = ttk.Button(lfb, text="Reset admin", command=self.on_reset_admin) self.btn_reset_admin.grid(row=2, column=1, sticky='WENS') settings_frame = ttk.Frame(self.root) settings_frame.grid(row=0, column=0, sticky='WENS') lf = ttk.LabelFrame(settings_frame, text='Server Settings') lf.pack() self.lbl_host = ttk.Label(lf, text=_("Host: {0}").format(self.host)) self.lbl_host.grid(row=0, column=0, sticky='W') self.lbl_port = ttk.Label(lf, text=_("Port: {0}").format(self.port)) self.lbl_port.grid(row=0, column=1, sticky='W') self.btn_settings = ttk.Button(lf, text="Settings", command=self.settings_dialog) self.btn_settings.grid(row=0, column=4) self.auto_start_svr = tk.BooleanVar() self.auto_start_svr.set(True) self.chb_auto_svr = ttk.Checkbutton(lf, text='Automatically open browser', variable=self.auto_start_svr, onvalue=True, offvalue=False) self.chb_auto_svr.grid(row=1) self.btn_server = ttk.Button(lf, text="Start Server", command=self.on_start_server) self.btn_server.grid(row=2, columnspan=5, sticky='NSEW') text_frame = ttk.Frame(self.root) text_frame.grid(row=1, columnspan=2) lft = ttk.LabelFrame(text_frame, text='Server Logs') lft.pack() xscrollbar = ttk.Scrollbar(lft, orient=tk.HORIZONTAL) xscrollbar.grid(row=1, column=0, sticky=tk.N+tk.S+tk.E+tk.W) yscrollbar = ttk.Scrollbar(lft) yscrollbar.grid(row=0, column=1, sticky=tk.N+tk.S+tk.E+tk.W) text = TextControl(lft, wrap=tk.NONE, state='disabled', xscrollcommand=xscrollbar.set, yscrollcommand=yscrollbar.set) text.grid(row=0, column=0) xscrollbar.config(command=text.xview) yscrollbar.config(command=text.yview) self.root.bind("<<EVT_CMD_START>>", self.on_cmd_start) self.root.bind("<<EVT_CMD_STOP>>", self.on_cmd_stop) self.cmd_runner = CommandRunner(text.append_message, self.root) @property def host(self): return self._host @host.setter def host(self, host): self._host = host self.lbl_host.config(text=_("Host: {0}").format(host)) @property def port(self): return self._port @port.setter def port(self, port): self._port = port self.lbl_port.config(text=_("Port: {0}").format(port)) @property def backup_interval_seconds(self): factor = 0 if self.backupdb_interval_unit == "seconds": factor = 1 elif self.backupdb_interval_unit == "minutes": factor = 60 elif self.backupdb_interval_unit == "hours": factor = 3600 return self.backupdb_interval * factor def db_backup_dialog(self): dialog = DbBackupDialog(self.root, enabled=self.backupdb_enabled, destination=self.backupdb_destination, interval=self.backupdb_interval, interval_unit=self.backupdb_interval_unit) if dialog.result: self.backupdb_enabled = dialog.result['enabled'] self.backupdb_destination = dialog.result['destination'] self.backupdb_interval = dialog.result['interval'] self.backupdb_interval_unit = dialog.result['interval_unit'] self.apply_backup_settings() def settings_dialog(self): dialog = SettingsDialog(self.root, title='Settings', host=self.host, port=self.port) if dialog.result: self.host = dialog.result['host'] self.port = dialog.result['port'] def about_dialog(self): AboutDialog(self.root) def on_sync_database(self): self.cmd_runner.append_message(_("Syncing database...")) self.cmd_runner.run_command("migrate") def on_reset_admin(self): self.cmd_runner.append_message(_("Resetting admin user...")) self.cmd_runner.run_command("createsuperuser") def on_start_server(self): if self.server_running: self.cmd_runner.cancel_command() return args = ["{0}:{1}".format(self.host, self.port)] if not self.auto_start_svr.get(): args.append("--no-browser") self.server_running = True self.cmd_runner.run_command("start", *args) # initiate backup_timer if backup is enabled self.apply_backup_settings() self.btn_server.config(text='Stop Server') def on_backup_timer(self): if not self.backupdb_enabled: return self.do_backup() self.backup_timer.start(1000 * self.backup_interval_seconds) def on_close_app(self): self.cmd_runner.cancel_command() self.save_gui_settings() self.destroy() def apply_backup_settings(self): if self.backupdb_enabled and self.server_running: now = datetime.datetime.utcnow() delta = datetime.timedelta(seconds=self.backup_interval_seconds) ref = self.last_backup if ref is None: ref = now ref += delta d = ref - now seconds = d.days * 86400 + d.seconds if seconds < 1: seconds = 30 # avoid backup immediatly after start self.backup_timer.start(seconds * 1000) else: self.backup_timer.stop() def do_backup(self): cmd = [ sys.executable, "-u", "-m", "openslides", "backupdb", self.backupdb_destination, ] p = subprocess.Popen( cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) p.stdin.close() output = p.stdout.read().strip() exitcode = p.wait() if output: self.cmd_runner.append_message(output) time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") if exitcode == 0: self.cmd_runner.append_message(_("{0}: Database backup successful.").format(time)) else: self.cmd_runner.append_message(_("{0}: Database backup failed!").format(time)) self.last_backup = datetime.datetime.utcnow() def on_cmd_start(self, event): self.btn_settings.config(state='disabled') self.btn_db_backup.config(state='disabled') self.btn_sync_db.config(state='disabled') self.btn_reset_admin.config(state='disabled') self.chb_auto_svr.config(state='disabled') def on_cmd_stop(self, event): if self.server_running: self.btn_server.config(text='Start Server') self.server_running = False self.backup_timer.stop() if self.backupdb_enabled: self.do_backup() else: if self.cmd_runner.exitcode == 0: text = _("Operation successfully completed.") else: text = _("Operation failed (exit code = {0})").format(self.cmd_runner.exitcode) self.cmd_runner.append_message(text) self.btn_settings.config(state='normal') self.btn_db_backup.config(state='normal') self.btn_sync_db.config(state='normal') self.btn_reset_admin.config(state='normal') self.chb_auto_svr.config(state='normal')
class DownloadNodeJS(object): def __init__(self, node_version): self.NODE_JS_VERSION = node_version self.NODE_JS_TAR_EXTENSION = ".zip" if node_variables.NODE_JS_OS == "win" else ".tar.gz" self.NODE_JS_BINARY_URL = "https://nodejs.org/dist/"+self.NODE_JS_VERSION+"/node-"+self.NODE_JS_VERSION+"-"+node_variables.NODE_JS_OS+"-"+node_variables.NODE_JS_ARCHITECTURE+self.NODE_JS_TAR_EXTENSION self.NODE_JS_BINARY_TARFILE_NAME = self.NODE_JS_BINARY_URL.split('/')[-1] self.NODE_JS_BINARY_TARFILE_FULL_PATH = os.path.join(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM, self.NODE_JS_BINARY_TARFILE_NAME) self.animation_loader = AnimationLoader(["[= ]", "[ = ]", "[ = ]", "[ = ]", "[ =]", "[ = ]", "[ = ]", "[ = ]"], 0.067, "Downloading: "+self.NODE_JS_BINARY_URL+" ") self.interval_animation = None self.thread = None def download(self): try : if os.path.exists(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM): shutil.rmtree(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) os.makedirs(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) else : os.makedirs(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) if os.path.exists(node_variables.NODE_MODULES_PATH): shutil.rmtree(node_variables.NODE_MODULES_PATH) request = urllib.request.Request(self.NODE_JS_BINARY_URL) request.add_header('User-agent', r'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.1 (KHTML, like Gecko) Chrome/22.0.1207.1 Safari/537.1') with urllib.request.urlopen(request) as response : with open(self.NODE_JS_BINARY_TARFILE_FULL_PATH, 'wb') as out_file : shutil.copyfileobj(response, out_file) except Exception as err : traceback.print_exc() self.on_error(err) return self.extract() self.on_complete() 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) def extract(self): sep = os.sep if self.NODE_JS_TAR_EXTENSION != ".zip" : with tarfile.open(self.NODE_JS_BINARY_TARFILE_FULL_PATH, "r:gz") as tar : for member in tar.getmembers() : member.name = sep.join(member.name.split(sep)[1:]) tar.extract(member, node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) else : with zipfile.ZipFile(self.NODE_JS_BINARY_TARFILE_FULL_PATH, "r") as zip_file : for member in zip_file.namelist() : if member.endswith("/node.exe") : with zip_file.open(member) as node_file: with open(os.path.join(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM, "node.exe"), "wb") as target : shutil.copyfileobj(node_file, target) break def on_error(self, err): self.animation_loader.on_complete() self.interval_animation.stop() sublime.active_window().status_message("Can't install Node.js! Check your internet connection!") 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: 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("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.")
class HandCockpit: MIN_VALUE = 0 MAX_VALUE = 1 INITIAL_SET = 0 SCAN_INTERVAL_SEC = 0.1 # 操作対象用インデックス WAIST = 0 # 左右に回転する部分 BOOM = 1 # 台座から伸びる部分。left servo ARM = 2 # boomからcrawまでの部分。right servo CRAW = 3 # バケットに相当する部分。先端の爪 # 物理的な可動範囲[min, max] 0〜180の範囲内であること # サンプルを参考にする # see: https://www.mearm.com/blogs/news/74739717-mearm-on-the-raspberry-pi-work-in-progress RANGE = ( (0, 180), # waist (60, 165), # boom (40, 180), # arm (60, 180), # craw ) # コントローラーの感度係数 SENSITIVITY = ( -50.0, # waist -50.0, # boom 50.0, # arm 50.0, # craw ) # 定義済み位置(WAIST, BOOM, ARM, CRAW) 0〜180の範囲 PRESET = ( (90, 112, 90, 60), # initial position (20, 30, 40, 50), # topキー用 ) def __init__(self, controller, pad): # initial servo position self.position = list(HandCockpit.PRESET[HandCockpit.INITIAL_SET]) # controllerはapplyメソッドを持っている必要がある self.controller = controller self.pad = pad self.lastUpdateAt = time.time() self.isStartedAxisScanThread = False self.isEnabledDebugPad = True # 初期位置設定 self._apply() def update(self, powerList, delay): for index in self.controller.getIndexes(): self.position[index] += powerList[index] * delay * HandCockpit.SENSITIVITY[index] if self.position[index] < HandCockpit.RANGE[index][HandCockpit.MIN_VALUE]: self.position[index] = HandCockpit.RANGE[index][HandCockpit.MIN_VALUE] elif self.position[index] > HandCockpit.RANGE[index][HandCockpit.MAX_VALUE]: self.position[index] = HandCockpit.RANGE[index][HandCockpit.MAX_VALUE] self._apply() def usePreset(self, number): self.position = list(HandCockpit.PRESET[number]) self._apply() def _apply(self): self.controller.apply(self.position) def startAxisScanThread(self): pygame.event.set_blocked(pygame.JOYAXISMOTION) self.axisScanThread = RepeatedTimer(HandCockpit.SCAN_INTERVAL_SEC, self.scanAxis) self.axisScanThread.start() self.isStartedAxisScanThread = True def stopAxisScanThread(self): if True == self.isStartedAxisScanThread: self.isStartedAxisScanThread = False self.axisScanThread.cancel() pygame.event.set_blocked(None) def scanAxis(self): now = time.time() delay = now - self.lastUpdateAt self.lastUpdateAt = now x1 = self.pad.getAnalog(PS3PadPygame.L3_AX) y1 = self.pad.getAnalog(PS3PadPygame.L3_AY) x2 = self.pad.getAnalog(PS3PadPygame.R3_AX) y2 = self.pad.getAnalog(PS3PadPygame.R3_AY) if self.isEnabledDebugPad: log = ('delay: %.3f, x1: %.3f, y1: %.3f, x2: %.3f, y2: %.3f' % (delay, x1, y1, x2, y2)) print log # バックホーの操作レバー割当はJIS方式だと以下のようになっている # (左レバー) (右レバー) # アーム伸ばし ブーム下げ # 左旋回 ○ 右旋回 バケット掘削 ○ バケット開放 # アーム曲げ ブーム上げ # よってバケットをクローに置き換えて # (WAIST, BOOM, ARM, CRAW)の順に整理する self.update((x1, y1, y2, x2), delay) def consumeEvents(self): events = self.pad.getEvents() # print 'events: ' + str(len(events)) for e in events: if e.type == pygame.locals.JOYBUTTONDOWN: if self.pad.isPressed(PS3PadPygame.START): print 'start button pressed. exit.' return False elif self.pad.isPressed(PS3PadPygame.TOP): # pre-set 1 print 'top button pressed.' self.usePreset(1) elif self.pad.isPressed(PS3PadPygame.CIRCLE): self.switchDebugPad() elif self.pad.isPressed(PS3PadPygame.BOX): self.controller.switchDebugPosition() elif False == self.isStartedAxisScanThread and e.type == pygame.locals.JOYAXISMOTION: self.scanAxis() return True def switchDebugPad(self): self.isEnabledDebugPad = not self.isEnabledDebugPad
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)
class CommandRunner: UPDATE_INTERVAL = 5 def __init__(self, msg_func, master): self.msg_func = msg_func self.master = master self.child_process = None self.output_queue = queue.Queue() self.output_read_thread = None self.output_mutex = threading.RLock() self.update_timer = RepeatedTimer(self.on_update_timer) self._exitcode = None def _read_output(self): while True: # NOTE: don't use iterator interface since it uses an # internal buffer and we don't see output in a timely fashion line = self.child_process.stdout.readline() if not line: break self.output_queue.put(line) def is_alive(self): if self.child_process is None: return False return self.child_process.poll() is None def run_command(self, *args): if self.is_alive(): raise ValueError("already running a command") cmd = [sys.executable, "-u", "-m", "openslides"] cmd.extend(args) creationflags = getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0) self._exitcode = None self.child_process = subprocess.Popen( cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, creationflags=creationflags) self.child_process.stdin.close() self.output_read_thread = threading.Thread(target=self._read_output) self.output_read_thread.start() self.update_timer.run(self.UPDATE_INTERVAL) self.master.event_generate("<<EVT_CMD_START>>", when="tail") def cancel_command(self): if not self.is_alive(): return self.msg_func("Stopping server...\n") # hard-kill the spawned process tree # TODO: offer the server the chance for a clean shutdown proc = psutil.Process(self.child_process.pid) kill_procs = [proc] kill_procs.extend(proc.children(recursive=True)) for p in kill_procs: p.kill() def on_update_timer(self): is_alive = self.is_alive() if not is_alive: # join thread to make sure everything was read self.output_read_thread.join(5) if self.output_read_thread.is_alive(): self.msg_func("Internal error: failed to join output reader thread") self.output_read_thread = None for line_no in itertools.count(): try: data = self.output_queue.get(block=False) except queue.Empty: break else: # XXX: check whether django uses utf-8 or locale for # it's cli output text = data.decode("utf-8", errors="replace") with self.output_mutex: self.msg_func(text) # avoid waiting too long here if child is still alive if is_alive and line_no > 10: break if not is_alive: self._exitcode = self.child_process.returncode self.update_timer.stop() self.child_process = None self.master.event_generate("<<EVT_CMD_STOP>>", when="tail") def append_message(self, text, newline="\n"): with self.output_mutex: self.msg_func(text + newline) @property def exitcode(self): return self._exitcode
class DownloadNodeJS(object): def __init__(self, node_version): self.NODE_JS_VERSION = node_version self.NODE_JS_TAR_EXTENSION = ".zip" if node_variables.NODE_JS_OS == "win" else ".tar.gz" self.NODE_JS_BINARY_URL = "https://nodejs.org/dist/"+self.NODE_JS_VERSION+"/node-"+self.NODE_JS_VERSION+"-"+node_variables.NODE_JS_OS+"-"+node_variables.NODE_JS_ARCHITECTURE+self.NODE_JS_TAR_EXTENSION self.NODE_JS_BINARY_TARFILE_NAME = self.NODE_JS_BINARY_URL.split('/')[-1] self.NODE_JS_BINARY_TARFILE_FULL_PATH = os.path.join(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM, self.NODE_JS_BINARY_TARFILE_NAME) self.animation_loader = AnimationLoader(["[= ]", "[ = ]", "[ = ]", "[ = ]", "[ =]", "[ = ]", "[ = ]", "[ = ]"], 0.067, "Downloading: "+self.NODE_JS_BINARY_URL+" ") self.interval_animation = None self.thread = None def download(self): try : if os.path.exists(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM): self.rmtree(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) os.makedirs(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) else : os.makedirs(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) if os.path.exists(node_variables.NODE_MODULES_PATH): self.rmtree(node_variables.NODE_MODULES_PATH) request = urllib.request.Request(self.NODE_JS_BINARY_URL) request.add_header('User-agent', r'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.1 (KHTML, like Gecko) Chrome/22.0.1207.1 Safari/537.1') with urllib.request.urlopen(request) as response : with open(self.NODE_JS_BINARY_TARFILE_FULL_PATH, 'wb') as out_file : shutil.copyfileobj(response, out_file) except Exception as err : traceback.print_exc() self.on_error(err) return self.extract() self.on_complete() 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) def extract(self): sep = os.sep if self.NODE_JS_TAR_EXTENSION != ".zip" : with tarfile.open(self.NODE_JS_BINARY_TARFILE_FULL_PATH, "r:gz") as tar : for member in tar.getmembers() : member.name = sep.join(member.name.split(sep)[1:]) tar.extract(member, node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) else : if node_variables.NODE_JS_OS == "win" : import string from ctypes import windll, c_int, c_wchar_p UNUSUED_DRIVE_LETTER = "" for letter in string.ascii_uppercase: if not os.path.exists(letter+":") : UNUSUED_DRIVE_LETTER = letter+":" break if not UNUSUED_DRIVE_LETTER : sublime.message_dialog("Can't install node.js and npm! UNUSUED_DRIVE_LETTER not found.") return DefineDosDevice = windll.kernel32.DefineDosDeviceW DefineDosDevice.argtypes = [ c_int, c_wchar_p, c_wchar_p ] DefineDosDevice(0, UNUSUED_DRIVE_LETTER, node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) try: with zipfile.ZipFile(self.NODE_JS_BINARY_TARFILE_FULL_PATH, "r") as zip_file : for member in zip_file.namelist() : if not member.endswith("/") : with zip_file.open(member) as node_file: with open(UNUSUED_DRIVE_LETTER + "\\"+ member.replace("node-"+self.NODE_JS_VERSION+"-"+node_variables.NODE_JS_OS+"-"+node_variables.NODE_JS_ARCHITECTURE+"/", ""), "wb+") as target : shutil.copyfileobj(node_file, target) elif not member.endswith("node-"+self.NODE_JS_VERSION+"-"+node_variables.NODE_JS_OS+"-"+node_variables.NODE_JS_ARCHITECTURE+"/"): os.mkdir(UNUSUED_DRIVE_LETTER + "\\"+ member.replace("node-"+self.NODE_JS_VERSION+"-"+node_variables.NODE_JS_OS+"-"+node_variables.NODE_JS_ARCHITECTURE+"/", "")) except Exception as e: print("Error: "+traceback.format_exc()) finally: DefineDosDevice(2, UNUSUED_DRIVE_LETTER, node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) def rmtree(self, path) : if node_variables.NODE_JS_OS == "win" : import string from ctypes import windll, c_int, c_wchar_p UNUSUED_DRIVE_LETTER = "" for letter in string.ascii_uppercase: if not os.path.exists(letter+":") : UNUSUED_DRIVE_LETTER = letter+":" break if not UNUSUED_DRIVE_LETTER : sublime.message_dialog("Can't remove node.js! UNUSUED_DRIVE_LETTER not found.") return DefineDosDevice = windll.kernel32.DefineDosDeviceW DefineDosDevice.argtypes = [ c_int, c_wchar_p, c_wchar_p ] DefineDosDevice(0, UNUSUED_DRIVE_LETTER, path) try: shutil.rmtree(UNUSUED_DRIVE_LETTER) except Exception as e: print("Error: "+traceback.format_exc()) finally: DefineDosDevice(2, UNUSUED_DRIVE_LETTER, path) else : shutil.rmtree(path) def on_error(self, err): self.animation_loader.on_complete() self.interval_animation.stop() sublime.active_window().status_message("Can't install Node.js! Check your internet connection!") 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.")
class Pong: PADDLE_SIZE = 3 # Antialased ball? # PONG_COLOR_INDEX_BALL_TOP = 8 # PONG_COLOR_INDEX_BALL_LEFT = 9 # PONG_COLOR_INDEX_BALL_RIGHT = 10 # PONG_COLOR_INDEX_BALL_BOTTOM = 11 COLORS = [ ( 0, 0, 0), # off # ( 10, 10, 10), # grey (255, 0, 0), # red (255, 80, 0), # orange (255, 255, 0), # yellow ( 0, 255, 0), # green ( 0, 0, 255), # blue (255, 0, 150), # violet (255, 0, 40), # purple ( 0, 0, 0), # ball top ( 0, 0, 0), # ball left ( 0, 0, 0), # ball right ( 0, 0, 0) # ball bottom ] SCORE_FONT = { 0: ["222", "202", "202", "202", "222"], 1: ["020", "020", "020", "020", "020"], 2: ["222", "002", "222", "200", "222"], 3: ["222", "002", "222", "002", "222"], 4: ["202", "202", "222", "002", "002"], 5: ["222", "200", "222", "002", "222"], 6: ["222", "200", "222", "202", "222"], 7: ["222", "002", "002", "002", "002"], 8: ["222", "202", "222", "202", "222"], 9: ["222", "202", "222", "002", "002"], } playfield = [x[:] for x in [[0]*config.LED_COLS]*config.LED_ROWS] score = [0, 0] paddle_position_x = [4, 15] paddle_position_y = [3, 3] ball_position = [10, 5] ball_direction = [0.1, 0.2] timer = None loop = True def __init__(self, ipcon): self.okay = False self.ipcon = ipcon if not config.UID_LED_STRIP_BRICKLET: print("Not Configured: LED Strip or LED Strip V2 (required)") return if not config.IS_LED_STRIP_V2: self.led_strip = LEDStrip(config.UID_LED_STRIP_BRICKLET, self.ipcon) else: self.led_strip = LEDStripV2(config.UID_LED_STRIP_BRICKLET, self.ipcon) try: self.led_strip.get_frame_duration() if not config.IS_LED_STRIP_V2: print("Found: LED Strip ({0})".format(config.UID_LED_STRIP_BRICKLET)) else: print("Found: LED Strip V2 ({0})".format(config.UID_LED_STRIP_BRICKLET)) except: if not config.IS_LED_STRIP_V2: print("Not Found: LED Strip ({0})".format(config.UID_LED_STRIP_BRICKLET)) else: print("Not Found: LED Strip V2({0})".format(config.UID_LED_STRIP_BRICKLET)) return self.kp = KeyPress(self.ipcon) self.speaker = PongSpeaker(self.ipcon) self.okay = True self.led_strip.set_frame_duration(40) if not config.IS_LED_STRIP_V2: self.led_strip.register_callback(self.led_strip.CALLBACK_FRAME_RENDERED, self.frame_rendered) else: self.led_strip.register_callback(self.led_strip.CALLBACK_FRAME_STARTED, self.frame_rendered) self.led_strip.set_channel_mapping(config.CHANNEL_MAPPING) self.init_game() def init_game(self): self.new_ball() self.paddle_position_y = [3, 3] self.score = [0, 0] def frame_rendered(self, length): self.write_playfield() def write_playfield(self): if not self.okay: return field = copy.deepcopy(self.playfield) self.add_score_to_playfield(field) self.add_paddles_to_playfield(field) self.add_ball_to_playfield(field) # Reorder LED data into R, G and B channel r = [] g = [] b = [] frame = [] for row in range(config.LED_ROWS): col_range = range(config.LED_COLS) if row % 2 == 0: col_range = reversed(col_range) for col in col_range: r.append(self.COLORS[field[row][col]][0]) g.append(self.COLORS[field[row][col]][1]) b.append(self.COLORS[field[row][col]][2]) frame.append(self.COLORS[field[row][col]][0]) frame.append(self.COLORS[field[row][col]][1]) frame.append(self.COLORS[field[row][col]][2]) if not config.IS_LED_STRIP_V2: # Make chunks of size 16 r_chunk = [r[i:i+16] for i in range(0, len(r), 16)] g_chunk = [g[i:i+16] for i in range(0, len(g), 16)] b_chunk = [b[i:i+16] for i in range(0, len(b), 16)] for i in range(len(r_chunk)): length = len(r_chunk[i]) # Fill up chunks with zeros r_chunk[i].extend([0]*(16-len(r_chunk[i]))) g_chunk[i].extend([0]*(16-len(g_chunk[i]))) b_chunk[i].extend([0]*(16-len(b_chunk[i]))) try: self.led_strip.set_rgb_values(i*16, length, r_chunk[i], g_chunk[i], b_chunk[i]) except: break else: try: self.led_strip.set_led_values(0, frame) except: return def add_score_to_playfield(self, field): for row in range(3): for col in range(5): field[row][col+1] = int(self.SCORE_FONT[self.score[0]][col][row]) field[row+17][col+1] = int(self.SCORE_FONT[self.score[1]][col][row]) def add_ball_to_playfield(self, field): x = max(0, min(19, int(self.ball_position[0]))) y = max(0, min(9, int(self.ball_position[1]))) field[x][y] = config.PONG_COLOR_INDEX_BALL # Antialased ball? # x = max(0, min(19, self.ball_position[0])) # y = max(0, min(9, self.ball_position[1])) # ix = int(x) # iy = int(y) # field[ix][iy] = config.PONG_COLOR_INDEX_BALL # if ix + 1 < config.LED_ROWS: # field[ix+1][iy] = PONG_COLOR_INDEX_BALL_RIGHT # if ix - 1 > 0: # field[ix-1][iy] = PONG_COLOR_INDEX_BALL_LEFT # if iy + 1 < config.LED_COLS: # field[ix][iy+1] = PONG_COLOR_INDEX_BALL_TOP # if iy - 1 > 0: # field[ix][iy-1] = PONG_COLOR_INDEX_BALL_BOTTOM # # dx = x - int(x) # dy = x - int(x) # self.COLORS[PONG_COLOR_INDEX_BALL_RIGHT] = (0, 255*dx/64, 0) # self.COLORS[PONG_COLOR_INDEX_BALL_LEFT] = (0, 255*(1-dx)/64, 0) # self.COLORS[PONG_COLOR_INDEX_BALL_TOP] = (0, 255*dy/64, 0) # self.COLORS[PONG_COLOR_INDEX_BALL_BOTTOM] = (0, 255*(1-dy)/64, 0) def add_paddles_to_playfield(self, field): for player in range(2): for i in range(self.PADDLE_SIZE): field[self.paddle_position_x[player]][self.paddle_position_y[player]+i] = config.PONG_COLOR_INDEX_PLAYER[player] def move_paddle(self, player, change): new_pos = self.paddle_position_y[player] + change if new_pos >= 0 and new_pos <= config.LED_COLS - self.PADDLE_SIZE: self.paddle_position_y[player] = new_pos def new_ball(self): self.ball_position = [(config.LED_ROWS - 1.0) / 2.0, (config.LED_COLS - 1.0) / 2.0] self.ball_direction = [random.choice([-0.2, 0.2]), random.choice([random.randrange(1, 9)/10.0, random.randrange(-9, -1)/10.0])] def tick(self): # Move ball for i in range(2): self.ball_position[i] += self.ball_direction[i] # Wall collision top/bottom if self.ball_position[1] < 0 or self.ball_position[1] >= config.LED_COLS: self.ball_direction[1] = -self.ball_direction[1] # Wall collision left/right def hit_left_right(player): self.speaker.beep_sirene() self.new_ball() self.score[player] += 1 if self.score[player] > 9: self.score[player] = 0 if self.ball_position[0] < 0: hit_left_right(1) if self.ball_position[0] >= config.LED_ROWS: hit_left_right(0) # Paddle collision def hit_paddle(skew): self.speaker.beep_paddle_hit() self.ball_direction[0] = -self.ball_direction[0] self.ball_direction[1] -= skew for i in range(2): self.ball_direction[i] *= 1.1 # Increase speed if self.ball_direction[0] < 0: if self.paddle_position_x[0] + 0.5 <= self.ball_position[0] <= self.paddle_position_x[0] + 1.5: if self.paddle_position_y[0] - 0.5 <= self.ball_position[1] <= self.paddle_position_y[0] + self.PADDLE_SIZE + 0.5: paddle_skew = (self.paddle_position_y[0] + self.PADDLE_SIZE/2.0 - self.ball_position[1])/10.0 hit_paddle(paddle_skew) if self.ball_direction[0] > 0: if self.paddle_position_x[1] - 0.5 <= self.ball_position[0] <= self.paddle_position_x[1] + 0.5: if self.paddle_position_y[1] - 0.5 <= self.ball_position[1] <= self.paddle_position_y[1] + self.PADDLE_SIZE + 0.5: paddle_skew = (self.paddle_position_y[1] + self.PADDLE_SIZE/2.0 - self.ball_position[1])/10.0 hit_paddle(paddle_skew) 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 if not config.IS_LED_STRIP_V2: self.led_strip.register_callback(self.led_strip.CALLBACK_FRAME_RENDERED, None) else: self.led_strip.register_callback(self.led_strip.CALLBACK_FRAME_STARTED, None) self.timer.stop() self.kp.stop()
class BettingDisplay(): def __init__(self, parent, meeting): self.parent = parent self.display_type = 'odds' self.date = datetime.date.today().strftime("%Y-%m-%d") #Currently will need to be restarted each day self.meeting = meeting #PLACEHOLDER self.schedule = Schedule(self.date, self.meeting) self.races = self.schedule.meetings[0].races self.next_race = None self.set_next_race() self.odds_var = StringVar() self.title_var = StringVar() self.dets_var = StringVar() self.build_display() self.start_timer() print("STARTED SUCCESSFULLY") def set_next_race(self): next_race = None found = False for race in self.races: cur_time = int(datetime.datetime.now().strftime("%H%M%S")) race_time = int(re.sub('[:]', '', race.time)) if race_time > cur_time and not found: next_race = race found = True if next_race is not self.next_race: self.next_race = next_race def start_timer(self): self.threading_timer = RepeatedTimer(3, self.refresh) self.threading_timer.start() def refresh(self): if self.display_type == 'odds': self.set_next_race() self.next_race.load_odds() #---TEMP---# horse_nums = ['']*20 for i in range(min(20, len(self.next_race.entries))): horse_nums[i] = str(self.next_race.entries[i].number) horse_names = ['']*20 for i in range(min(20, len(self.next_race.entries))): horse_names[i] = str(self.next_race.entries[i].name) win_odds = ['']*20 for i in range(min(20, len(self.next_race.entries))): win_odds[i] = str(self.next_race.entries[i].odds_win) lst = horse_nums + horse_names + win_odds odds_str = TEST_TEMPLATE.format(lst) title_str = TITLE_TEMPLATE.format(name=self.next_race.name) dets_str = TIME_TEMPLATE.format(time=self.next_race.time, venue=self.next_race.meeting.venue, meet_no=self.next_race.meeting.number, country=self.next_race.meeting.country) self.title_var.set(title_str) self.dets_var.set(dets_str) self.odds_var.set(odds_str) #---TEMP END---# elif self.display_type == 'test': self.title_var.set('test') self.dets_var.set('') self.odds_var.set('') def build_display(self): #----TEMP---- self.cur_race_name = StringVar() self.cur_race_time = StringVar() self.title_text = Label(self.parent, fg="white", bg="black", font=("Courier", 40, "bold"), textvariable=self.title_var) self.title_text.place(relx = 0.5, rely = 0, anchor=N, height = 80, width=1100) self.dets_text = Label(self.parent, textvariable=self.dets_var, fg="white", bg="black", font=("Courier", 20, "bold")) self.dets_text.place(relx = 0.5, y = 80, anchor=N, height = 30, width=1100) self.odds_text = Label(self.parent, textvariable=self.odds_var, fg="white", bg="black", font=("Courier", 20, "bold")) self.odds_text.place(relx = 0.5, y = 110, anchor=N, width=1100, height = 600) self.quitbutton = Button(self.parent, text='quit', command=self.quitclick) self.quitbutton.place(relx = 0.5, rely = 1, anchor=S) #---TEMP END ---# def quitclick(self): self.threading_timer.stop() self.parent.destroy()
class BettingDisplay(): def __init__(self, parent, meeting): self.parent = parent self.display_type = 'odds' self.date = datetime.date.today().strftime( "%Y-%m-%d") #Currently will need to be restarted each day self.meeting = meeting #PLACEHOLDER self.schedule = Schedule(self.date, self.meeting) self.races = self.schedule.meetings[0].races self.next_race = None self.set_next_race() self.odds_var = StringVar() self.title_var = StringVar() self.dets_var = StringVar() self.build_display() self.start_timer() print("STARTED SUCCESSFULLY") def set_next_race(self): next_race = None found = False for race in self.races: cur_time = int(datetime.datetime.now().strftime("%H%M%S")) race_time = int(re.sub('[:]', '', race.time)) if race_time > cur_time and not found: next_race = race found = True if next_race is not self.next_race: self.next_race = next_race def start_timer(self): self.threading_timer = RepeatedTimer(3, self.refresh) self.threading_timer.start() def refresh(self): if self.display_type == 'odds': self.set_next_race() self.next_race.load_odds() #---TEMP---# horse_nums = [''] * 20 for i in range(min(20, len(self.next_race.entries))): horse_nums[i] = str(self.next_race.entries[i].number) horse_names = [''] * 20 for i in range(min(20, len(self.next_race.entries))): horse_names[i] = str(self.next_race.entries[i].name) win_odds = [''] * 20 for i in range(min(20, len(self.next_race.entries))): win_odds[i] = str(self.next_race.entries[i].odds_win) lst = horse_nums + horse_names + win_odds odds_str = TEST_TEMPLATE.format(lst) title_str = TITLE_TEMPLATE.format(name=self.next_race.name) dets_str = TIME_TEMPLATE.format( time=self.next_race.time, venue=self.next_race.meeting.venue, meet_no=self.next_race.meeting.number, country=self.next_race.meeting.country) self.title_var.set(title_str) self.dets_var.set(dets_str) self.odds_var.set(odds_str) #---TEMP END---# elif self.display_type == 'test': self.title_var.set('test') self.dets_var.set('') self.odds_var.set('') def build_display(self): #----TEMP---- self.cur_race_name = StringVar() self.cur_race_time = StringVar() self.title_text = Label(self.parent, fg="white", bg="black", font=("Courier", 40, "bold"), textvariable=self.title_var) self.title_text.place(relx=0.5, rely=0, anchor=N, height=80, width=1100) self.dets_text = Label(self.parent, textvariable=self.dets_var, fg="white", bg="black", font=("Courier", 20, "bold")) self.dets_text.place(relx=0.5, y=80, anchor=N, height=30, width=1100) self.odds_text = Label(self.parent, textvariable=self.odds_var, fg="white", bg="black", font=("Courier", 20, "bold")) self.odds_text.place(relx=0.5, y=110, anchor=N, width=1100, height=600) self.quitbutton = Button(self.parent, text='quit', command=self.quitclick) self.quitbutton.place(relx=0.5, rely=1, anchor=S) #---TEMP END ---# def quitclick(self): self.threading_timer.stop() self.parent.destroy()
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
class DownloadNodeJS(object): def __init__(self, node_version): self.NODE_JS_VERSION = node_version self.NODE_JS_TAR_EXTENSION = ".zip" if node_variables.NODE_JS_OS == "win" else ".tar.gz" self.NODE_JS_BINARY_URL = "https://nodejs.org/dist/" + self.NODE_JS_VERSION + "/node-" + self.NODE_JS_VERSION + "-" + node_variables.NODE_JS_OS + "-" + node_variables.NODE_JS_ARCHITECTURE + self.NODE_JS_TAR_EXTENSION self.NODE_JS_BINARY_TARFILE_NAME = self.NODE_JS_BINARY_URL.split( '/')[-1] self.NODE_JS_BINARY_TARFILE_FULL_PATH = os.path.join( node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM, self.NODE_JS_BINARY_TARFILE_NAME) self.animation_loader = AnimationLoader([ "[= ]", "[ = ]", "[ = ]", "[ = ]", "[ =]", "[ = ]", "[ = ]", "[ = ]" ], 0.067, "Downloading: " + self.NODE_JS_BINARY_URL + " ") self.interval_animation = None self.thread = None def download(self): try: if os.path.exists(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM): self.rmtree(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) os.makedirs(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) else: os.makedirs(node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) if os.path.exists(node_variables.NODE_MODULES_PATH): self.rmtree(node_variables.NODE_MODULES_PATH) request = urllib.request.Request(self.NODE_JS_BINARY_URL) request.add_header( 'User-agent', r'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.1 (KHTML, like Gecko) Chrome/22.0.1207.1 Safari/537.1' ) with urllib.request.urlopen(request) as response: with open(self.NODE_JS_BINARY_TARFILE_FULL_PATH, 'wb') as out_file: shutil.copyfileobj(response, out_file) except Exception as err: traceback.print_exc() self.on_error(err) return self.extract() self.on_complete() 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) def extract(self): sep = os.sep if self.NODE_JS_TAR_EXTENSION != ".zip": with tarfile.open(self.NODE_JS_BINARY_TARFILE_FULL_PATH, "r:gz") as tar: for member in tar.getmembers(): member.name = sep.join(member.name.split(sep)[1:]) tar.extract( member, node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) else: if node_variables.NODE_JS_OS == "win": import string from ctypes import windll, c_int, c_wchar_p UNUSUED_DRIVE_LETTER = "" for letter in string.ascii_uppercase: if not os.path.exists(letter + ":"): UNUSUED_DRIVE_LETTER = letter + ":" break if not UNUSUED_DRIVE_LETTER: sublime.message_dialog( "Can't install node.js and npm! UNUSUED_DRIVE_LETTER not found." ) return DefineDosDevice = windll.kernel32.DefineDosDeviceW DefineDosDevice.argtypes = [c_int, c_wchar_p, c_wchar_p] DefineDosDevice( 0, UNUSUED_DRIVE_LETTER, node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) try: with zipfile.ZipFile(self.NODE_JS_BINARY_TARFILE_FULL_PATH, "r") as zip_file: for member in zip_file.namelist(): if not member.endswith("/"): with zip_file.open(member) as node_file: with open( UNUSUED_DRIVE_LETTER + "\\" + member.replace( "node-" + self.NODE_JS_VERSION + "-" + node_variables.NODE_JS_OS + "-" + node_variables. NODE_JS_ARCHITECTURE + "/", ""), "wb+") as target: shutil.copyfileobj(node_file, target) elif not member.endswith( "node-" + self.NODE_JS_VERSION + "-" + node_variables.NODE_JS_OS + "-" + node_variables.NODE_JS_ARCHITECTURE + "/"): os.mkdir( UNUSUED_DRIVE_LETTER + "\\" + member.replace( "node-" + self.NODE_JS_VERSION + "-" + node_variables.NODE_JS_OS + "-" + node_variables.NODE_JS_ARCHITECTURE + "/", "")) except Exception as e: print("Error: " + traceback.format_exc()) finally: DefineDosDevice( 2, UNUSUED_DRIVE_LETTER, node_variables.NODE_JS_BINARIES_FOLDER_PLATFORM) def rmtree(self, path): if node_variables.NODE_JS_OS == "win": import string from ctypes import windll, c_int, c_wchar_p UNUSUED_DRIVE_LETTER = "" for letter in string.ascii_uppercase: if not os.path.exists(letter + ":"): UNUSUED_DRIVE_LETTER = letter + ":" break if not UNUSUED_DRIVE_LETTER: sublime.message_dialog( "Can't remove node.js! UNUSUED_DRIVE_LETTER not found.") return DefineDosDevice = windll.kernel32.DefineDosDeviceW DefineDosDevice.argtypes = [c_int, c_wchar_p, c_wchar_p] DefineDosDevice(0, UNUSUED_DRIVE_LETTER, path) try: shutil.rmtree(UNUSUED_DRIVE_LETTER) except Exception as e: print("Error: " + traceback.format_exc()) finally: DefineDosDevice(2, UNUSUED_DRIVE_LETTER, path) else: shutil.rmtree(path) def on_error(self, err): self.animation_loader.on_complete() self.interval_animation.stop() sublime.active_window().status_message( "Can't install Node.js! Check your internet connection!") 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 startAxisScanThread(self): pygame.event.set_blocked(pygame.JOYAXISMOTION) self.axisScanThread = RepeatedTimer(HandCockpit.SCAN_INTERVAL_SEC, self.scanAxis) self.axisScanThread.start() self.isStartedAxisScanThread = True
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)