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_timer(self):
self.threading_timer = RepeatedTimer(3, self.refresh)
self.threading_timer.start()
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)
