def _process_computer_move(self, message): self.force_leds_off(log=True) # can happen in case of a book move move = message.move ponder = message.ponder self.play_move = move self.play_fen = message.game.fen() self.play_turn = message.game.turn if ponder: game_copy = message.game.copy() game_copy.push(move) self.hint_move = ponder self.hint_fen = game_copy.fen() self.hint_turn = game_copy.turn else: self.hint_move = chess.Move.null() self.hint_fen = None self.hint_turn = None # Display the move side = self._get_clock_side(message.game.turn) beep = self.dgttranslate.bl(BeepLevel.CONFIG) disp = Dgt.DISPLAY_MOVE(move=move, fen=message.game.fen(), side=side, wait=message.wait, maxtime=0, beep=beep, devs={'ser', 'i2c', 'web'}, uci960=self.uci960, lang=self.dgttranslate.language, capital=self.dgttranslate.capital, long=self.dgttranslate.notation) DgtObserver.fire(disp) DgtObserver.fire( Dgt.LIGHT_SQUARES(uci_move=move.uci(), devs={'ser', 'web'})) self.leds_are_on = True
def _exit_display(self, devs=None): if devs is None: # prevent W0102 error devs = {'ser', 'i2c', 'web'} if self.play_move and self.dgtmenu.get_mode() in (Mode.NORMAL, Mode.BRAIN, Mode.REMOTE): side = self._get_clock_side(self.play_turn) beep = self.dgttranslate.bl(BeepLevel.BUTTON) text = Dgt.DISPLAY_MOVE(move=self.play_move, fen=self.play_fen, side=side, wait=True, maxtime=1, beep=beep, devs=devs, uci960=self.uci960, lang=self.dgttranslate.language, capital=self.dgttranslate.capital, long=self.dgttranslate.notation) else: text = None if self._inside_main_menu('dont_care_dev'): text = self.dgtmenu.get_current_text() if text: text.wait = True # in case of "bad pos" message send before else: text = Dgt.DISPLAY_TIME(force=True, wait=True, devs=devs) DgtObserver.fire(text)
def _set_clock(self, side=ClockSide.NONE, devs=None): if devs is None: # prevent W0102 error devs = {'ser', 'i2c', 'web'} time_left, time_right = self.time_control.get_internal_time( flip_board=self.dgtmenu.get_flip_board()) DgtObserver.fire( Dgt.CLOCK_SET(time_left=time_left, time_right=time_right, devs=devs)) DgtObserver.fire(Dgt.CLOCK_START(side=side, wait=True, devs=devs))
def _process_dgt_serial_nr(self): # logging.debug('Serial number {}'.format(message.number)) # actually used for watchdog (once a second) # molli: rolling display if not self._inside_main_menu(): if self.dgtmenu.get_mode() == Mode.PONDER: if self.show_move_or_value >= self.dgtmenu.get_ponderinterval(): if self.hint_move: side = self._get_clock_side(self.hint_turn) beep = self.dgttranslate.bl(BeepLevel.NO) text = Dgt.DISPLAY_MOVE(move=self.hint_move, fen=self.hint_fen, side=side, wait=True, maxtime=1, beep=beep, devs={'ser', 'i2c', 'web'}, uci960=self.uci960, lang=self.dgttranslate.language, capital=self.dgttranslate.capital, long=self.dgttranslate.notation) else: text = self.dgttranslate.text('N10_nomove') else: text = self._combine_depth_and_score() text.wait = True DispatchDgt.fire(text) self.show_move_or_value = (self.show_move_or_value + 1) % (self.dgtmenu.get_ponderinterval() * 2) elif (self.dgtmenu.get_mode() == Mode.BRAIN and self.dgtmenu.get_rolldispbrain()) or (self.dgtmenu.get_mode() == Mode.NORMAL and self.dgtmenu.get_rolldispnorm()): #molli: allow rolling information display (time/score/hint_move) in BRAIN mode according to ## ponder interval if self.play_move == chess.Move.null() and self.c_last_player == 'U': if self.c_time_counter > 2 * self.dgtmenu.get_ponderinterval(): text = self._combine_depth_and_score() text.wait = True DispatchDgt.fire(text) self.c_time_counter = (self.c_time_counter + 1) % (self.dgtmenu.get_ponderinterval() * 3) elif self.c_time_counter > self.dgtmenu.get_ponderinterval(): if self.hint_move: side = self._get_clock_side(self.hint_turn) beep = self.dgttranslate.bl(BeepLevel.NO) text = Dgt.DISPLAY_MOVE(move=self.hint_move, fen=self.hint_fen, side=side, wait=True, maxtime=1, beep=beep, devs={'ser', 'i2c', 'web'}, uci960=self.uci960, lang=self.dgttranslate.language, capital=self.dgttranslate.capital, long=self.dgttranslate.notation) else: text = self.dgttranslate.text('N10_nomove') text.wait = True self.c_time_counter = (self.c_time_counter + 1) % (self.dgtmenu.get_ponderinterval() * 3) DispatchDgt.fire(text) if self.c_time_counter == 2 * self.dgtmenu.get_ponderinterval(): time.sleep(0.3) else: ## molli: standard clock display if self.c_time_counter == 0: time.sleep(0.3) self.c_time_counter = (self.c_time_counter + 1) % (self.dgtmenu.get_ponderinterval() * 3) self._exit_display() if self.c_time_counter == self.dgtmenu.get_ponderinterval(): time.sleep(0.3)
def _process_dgt_serial_nr(self): # logging.debug('Serial number {}'.format(message.number)) # actually used for watchdog (once a second) if self.dgtmenu.get_mode( ) == Mode.PONDER and not self._inside_main_menu('dont_care_dev'): if self.show_move_or_value >= self.dgtmenu.get_ponderinterval(): if self.hint_move: side = self._get_clock_side(self.hint_turn) beep = self.dgttranslate.bl(BeepLevel.NO) text = Dgt.DISPLAY_MOVE(move=self.hint_move, fen=self.hint_fen, side=side, wait=True, maxtime=1, beep=beep, devs={'ser', 'i2c', 'web'}, uci960=self.uci960, lang=self.dgttranslate.language, capital=self.dgttranslate.capital, long=self.dgttranslate.notation) else: text = self.dgttranslate.text('N10_nomove') else: text = self._combine_depth_and_score() text.wait = True DgtObserver.fire(text) self.show_move_or_value = (self.show_move_or_value + 1) % ( self.dgtmenu.get_ponderinterval() * 2)
def _process_new_pv(self, message): self.hint_move = message.pv[0] self.hint_fen = message.game.fen() self.hint_turn = message.game.turn # if message.mode == Mode.ANALYSIS and not self._inside_main_menu('dont_care_dev'): if message.mode == Mode.ANALYSIS: devs = { None if self._inside_main_menu(dev) else dev for dev in {'ser', 'i2c', 'web'} } devs.discard(None) side = self._get_clock_side(self.hint_turn) beep = self.dgttranslate.bl(BeepLevel.NO) disp = Dgt.DISPLAY_MOVE(move=self.hint_move, fen=self.hint_fen, side=side, wait=True, maxtime=0, beep=beep, devs=devs, uci960=self.uci960, lang=self.dgttranslate.language, capital=self.dgttranslate.capital, long=self.dgttranslate.notation) if devs: DgtObserver.fire(disp)
def _exit_display(self): if self.play_move and self.dgtmenu.get_mode() in (Mode.NORMAL, Mode.BRAIN, Mode.REMOTE): side = self._get_clock_side(self.play_turn) beep = self.dgttranslate.bl(BeepLevel.BUTTON) text = Dgt.DISPLAY_MOVE(move=self.play_move, fen=self.play_fen, side=side, wait=True, maxtime=1, beep=beep, devs={'ser', 'i2c', 'web'}, uci960=self.uci960, lang=self.dgttranslate.language, capital=self.dgttranslate.capital) else: text = None if self._inside_main_menu(): text = self.dgtmenu.get_current_text() if text: text.wait = True # in case of "bad pos" message send before else: text = Dgt.DISPLAY_TIME(force=True, wait=True, devs={'ser', 'i2c', 'web'}) DispatchDgt.fire(text)
def _process_button3(self, dev: str): logging.debug('(%s) clock handle button 3 press', dev) if self._inside_updt_menu(dev): DgtObserver.fire( self.dgtmenu.updt_right()) # button3 cant exit the menu elif self._inside_main_menu(dev): DgtObserver.fire( self.dgtmenu.main_right()) # button3 cant exit the menu else: if self.hint_move: side = self._get_clock_side(self.hint_turn) beep = self.dgttranslate.bl(BeepLevel.BUTTON) text = Dgt.DISPLAY_MOVE(move=self.hint_move, fen=self.hint_fen, side=side, wait=False, maxtime=1, beep=beep, devs={'ser', 'i2c', 'web'}, uci960=self.uci960, lang=self.dgttranslate.language, capital=self.dgttranslate.capital, long=self.dgttranslate.notation) else: text = self.dgttranslate.text('B10_nomove') DgtObserver.fire(text) self._exit_display(devs={dev})
def _process_button0(self, dev): logging.debug('(%s) clock handle button 0 press', dev) if self._inside_main_menu(): text = self.dgtmenu.main_up( ) # button0 can exit the menu, so check if text: DispatchDgt.fire(text) else: self._exit_display() elif self._inside_updt_menu(): self.dgtmenu.updt_up(dev) self._exit_display() # button0 always exit the menu else: if self.last_move: side = self._get_clock_side(self.last_turn) beep = self.dgttranslate.bl(BeepLevel.BUTTON) text = Dgt.DISPLAY_MOVE(move=self.last_move, fen=self.last_fen, side=side, wait=False, maxtime=1, beep=beep, devs={'ser', 'i2c', 'web'}, uci960=self.uci960, lang=self.dgttranslate.language, capital=self.dgttranslate.capital, long=self.dgttranslate.notation) else: text = self.dgttranslate.text('B10_nomove') DispatchDgt.fire(text) self._exit_display()
def _stopped_maxtimer(self, dev: str): self.maxtimer_running[dev] = False self.dgtmenu.disable_picochess_displayed(dev) if dev not in self.devices: logging.debug('delete not registered (%s) tasks', dev) self.tasks[dev] = [] return if self.tasks[dev]: logging.debug('processing delayed (%s) tasks: %s', dev, self.tasks[dev]) else: logging.debug( '(%s) max timer finished - returning to time display', dev) DgtDisplay.show( Dgt.DISPLAY_TIME(force=False, wait=True, devs={dev})) while self.tasks[dev]: logging.debug('(%s) tasks has %i members', dev, len(self.tasks[dev])) try: message = self.tasks[dev].pop(0) except IndexError: break with self.process_lock[dev]: self._process_message(message, dev) if self.maxtimer_running[ dev]: # run over the task list until a maxtime command was processed remaining = len(self.tasks[dev]) if remaining: logging.debug('(%s) tasks stopped on %i remaining members', dev, remaining) else: logging.debug('(%s) tasks completed', dev) break
def _setup_serial_port(self): def _success(device: str): self.device = device logging.debug('(ser) board connected to %s', self.device) return True waitchars = ['/', '-', '\\', '|'] if self.watchdog_timer.is_running(): logging.debug('watchdog timer is stopped now') self.watchdog_timer.stop() if self.serial: return True with self.lock: if self.given_device: if self._open_serial(self.given_device): return _success(self.given_device) else: for file in listdir('/dev'): if file.startswith('ttyACM') or file.startswith('ttyUSB') or file == 'rfcomm0': dev = path.join('/dev', file) if self._open_serial(dev): return _success(dev) if self._open_bluetooth(): return _success('/dev/rfcomm123') # text = self.dgttranslate.text('N00_noboard', 'Board' + waitchars[self.wait_counter]) bwait = 'Board' + waitchars[self.wait_counter] text = Dgt.DISPLAY_TEXT(l='no e-' + bwait, m='no' + bwait, s=bwait, wait=True, beep=False, maxtime=0.1, devs={'i2c', 'web'}) MsgDisplay.show(Message.DGT_EBOARD_ERROR(text=text)) self.wait_counter = (self.wait_counter + 1) % len(waitchars) return False
def force_leds_off(self, log=False): """Clear the rev2 lights if they still on.""" if self.leds_are_on: if log: logging.warning('(rev) leds still on') DgtObserver.fire(Dgt.LIGHT_CLEAR(devs={'ser', 'web'})) self.leds_are_on = False
def read_engine_ini(engine_shell=None, engine_path=None): """Read engines.ini and creates a library list out of it.""" config = configparser.ConfigParser() config.optionxform = str try: if engine_shell is None: if not engine_path: program_path = os.path.abspath( os.path.join(os.path.dirname(__file__), os.pardir)) engine_path = program_path + os.sep + 'engines' + os.sep + platform.machine( ) config.read(engine_path + os.sep + 'engines.ini') else: with engine_shell.open(engine_path + os.sep + 'engines.ini', 'r') as file: config.read_file(file) except FileNotFoundError: pass library = [] for section in config.sections(): parser = configparser.ConfigParser() parser.optionxform = str level_dict = {} if engine_shell is None: success = parser.read(engine_path + os.sep + section + '.uci') else: try: with engine_shell.open(engine_path + os.sep + section + '.uci', 'r') as file: parser.read_file(file) success = True except FileNotFoundError: success = False if success: for p_section in parser.sections(): level_dict[p_section] = {} for option in parser.options(p_section): level_dict[p_section][option] = parser[p_section][option] confsect = config[section] text = Dgt.DISPLAY_TEXT(l=confsect['large'], m=confsect['medium'], s=confsect['small'], wait=True, beep=False, maxtime=0, devs={'ser', 'i2c', 'web'}) library.append({ 'file': engine_path + os.sep + section, 'level_dict': level_dict, 'text': text, 'name': confsect['name'], 'elo': confsect['elo'] }) return library
def _process_new_pv(self, message): self.hint_move = message.pv[0] self.hint_fen = message.game.fen() self.hint_turn = message.game.turn if message.mode == Mode.ANALYSIS and not self._inside_main_menu(): side = self._get_clock_side(self.hint_turn) beep = self.dgttranslate.bl(BeepLevel.NO) disp = Dgt.DISPLAY_MOVE(move=self.hint_move, fen=self.hint_fen, side=side, wait=True, maxtime=0, beep=beep, devs={'ser', 'i2c', 'web'}, uci960=self.uci960, lang=self.dgttranslate.language, capital=self.dgttranslate.capital) DispatchDgt.fire(disp)
def get_opening_books(): """Build an opening book lib.""" config = configparser.ConfigParser() config.optionxform = str program_path = os.path.dirname(os.path.realpath(__file__)) + os.sep book_path = program_path + 'books' config.read(book_path + os.sep + 'books.ini') library = [] for section in config.sections(): text = Dgt.DISPLAY_TEXT(l=config[section]['large'], m=config[section]['medium'], s=config[section]['small'], wait=True, beep=False, maxtime=0, devs={'ser', 'i2c', 'web'}) library.append({'file': 'books' + os.sep + section, 'text': text}) return library
def _process_board_message(self, message_id: int, message: tuple, message_length: int): if False: # switch-case pass elif message_id == DgtMsg.DGT_MSG_VERSION: if message_length != 2: logging.warning('illegal length in data') board_version = str(message[0]) + '.' + str(message[1]) logging.debug('(ser) board version %0.2f', float(board_version)) self.write_command([DgtCmd.DGT_SEND_BRD ]) # Update the board => get first FEN if self.device.find('rfc') == -1: text_l, text_m, text_s = 'USB e-Board', 'USBboard', 'ok usb' self.channel = 'USB' else: btname5 = self.bt_name[-5:] if 'REVII' in self.bt_name: text_l, text_m, text_s = 'RevII ' + btname5, 'Rev' + btname5, 'b' + btname5 self.is_revelation = True self.write_command([DgtCmd.DGT_RETURN_LONG_SERIALNR]) elif 'DGT_BT' in self.bt_name: text_l, text_m, text_s = 'DGTBT ' + btname5, 'BT ' + btname5, 'b' + btname5 else: text_l, text_m, text_s = 'BT e-Board', 'BT board', 'ok bt' self.channel = 'BT' self.ask_battery_status() self.bconn_text = Dgt.DISPLAY_TEXT(l=text_l, m=text_m, s=text_s, wait=True, beep=False, maxtime=1.1, devs={'i2c', 'web' }) # serial clock lateron DisplayMsg.show( Message.DGT_EBOARD_VERSION(text=self.bconn_text, channel=self.channel)) self.startup_serial_clock() # now ask the serial clock to answer if self.watchdog_timer.is_running(): logging.warning('watchdog timer is already running') else: logging.debug('watchdog timer is started') self.watchdog_timer.start() elif message_id == DgtMsg.DGT_MSG_BWTIME: if message_length != 7: logging.warning('illegal length in data') if ((message[0] & 0x0f) == 0x0a) or ((message[3] & 0x0f) == 0x0a): # Clock ack message # Construct the ack message ack0 = ((message[1]) & 0x7f) | ((message[3] << 3) & 0x80) ack1 = ((message[2]) & 0x7f) | ((message[3] << 2) & 0x80) ack2 = ((message[4]) & 0x7f) | ((message[0] << 3) & 0x80) ack3 = ((message[5]) & 0x7f) | ((message[0] << 2) & 0x80) if ack0 != 0x10: logging.warning('(ser) clock ACK error %s', (ack0, ack1, ack2, ack3)) if self.last_clock_command: logging.debug( '(ser) clock resending failed message [%s]', self.last_clock_command) self.write_command(self.last_clock_command) self.last_clock_command = [] # only resend once return else: logging.debug('(ser) clock ACK okay [%s]', DgtAck(ack1)) if self.last_clock_command: cmd = self.last_clock_command[3] # type: DgtClk if cmd.value != ack1 and ack1 < 0x80: logging.warning( '(ser) clock ACK [%s] out of sync - last: [%s]', DgtAck(ack1), cmd) # @todo these lines are better as what is done on DgtHw but it doesnt work # if ack1 == DgtAck.DGT_ACK_CLOCK_SETNRUN.value: # logging.info('(ser) clock out of set time now') # self.in_settime = False if ack1 == DgtAck.DGT_ACK_CLOCK_BUTTON.value: # this are the other (ack2-ack3) codes # 05-49 33-52 17-51 09-50 65-53 | button 0-4 (single) # 37-52 21-51 13-50 69-53 | button 0 + 1-4 # 49-51 41-50 97-53 | button 1 + 2-4 # 25-50 81-53 | button 2 + 3-4 # 73-53 | button 3 + 4 if ack3 == 49: logging.info('(ser) clock button 0 pressed - ack2: %i', ack2) DisplayMsg.show(Message.DGT_BUTTON(button=0, dev='ser')) if ack3 == 52: logging.info('(ser) clock button 1 pressed - ack2: %i', ack2) DisplayMsg.show(Message.DGT_BUTTON(button=1, dev='ser')) if ack3 == 51: logging.info('(ser) clock button 2 pressed - ack2: %i', ack2) DisplayMsg.show(Message.DGT_BUTTON(button=2, dev='ser')) if ack3 == 50: logging.info('(ser) clock button 3 pressed - ack2: %i', ack2) DisplayMsg.show(Message.DGT_BUTTON(button=3, dev='ser')) if ack3 == 53: if ack2 == 69: logging.info( '(ser) clock button 0+4 pressed - ack2: %i', ack2) DisplayMsg.show( Message.DGT_BUTTON(button=0x11, dev='ser')) else: logging.info( '(ser) clock button 4 pressed - ack2: %i', ack2) DisplayMsg.show( Message.DGT_BUTTON(button=4, dev='ser')) if ack1 == DgtAck.DGT_ACK_CLOCK_VERSION.value: self.enable_ser_clock = True main = ack2 >> 4 sub = ack2 & 0x0f logging.debug('(ser) clock version %0.2f', float(str(main) + '.' + str(sub))) if self.bconn_text: self.bconn_text.devs = { 'ser' } # Now send the (delayed) message to serial clock dev = 'ser' else: dev = 'err' DisplayMsg.show( Message.DGT_CLOCK_VERSION(main=main, sub=sub, dev=dev, text=self.bconn_text)) elif any(message[:7]): r_hours = message[0] & 0x0f r_mins = (message[1] >> 4) * 10 + (message[1] & 0x0f) r_secs = (message[2] >> 4) * 10 + (message[2] & 0x0f) l_hours = message[3] & 0x0f l_mins = (message[4] >> 4) * 10 + (message[4] & 0x0f) l_secs = (message[5] >> 4) * 10 + (message[5] & 0x0f) r_time = r_hours * 3600 + r_mins * 60 + r_secs l_time = l_hours * 3600 + l_mins * 60 + l_secs errtim = r_hours > 9 or l_hours > 9 or r_mins > 59 or l_mins > 59 or r_secs > 59 or l_secs > 59 if errtim: # complete illegal package received logging.warning('(ser) clock illegal new time received %s', message) elif r_time > self.r_time or l_time > self.l_time: # the new time is higher as the old => ignore logging.warning( '(ser) clock strange old time received %s l:%s r:%s', message, hms_time(self.l_time), hms_time(self.r_time)) if self.in_settime: logging.info( '(ser) clock still in set mode, ignore received time' ) errtim = True elif r_time - self.r_time > 3600 or l_time - self.l_time > 3600: logging.info( '(ser) clock new time over 1h difference, ignore received time' ) errtim = True else: logging.info('(ser) clock new time received l:%s r:%s', hms_time(l_time), hms_time(r_time)) status = message[6] & 0x3f connect = not status & 0x20 if connect: right_side_down = -0x40 if status & 0x02 else 0x40 if self.lever_pos != right_side_down: logging.debug( '(ser) clock button status: 0x%x old lever: %s', status, self.lever_pos) if self.lever_pos is not None: DisplayMsg.show( Message.DGT_BUTTON(button=right_side_down, dev='ser')) self.lever_pos = right_side_down else: logging.info( '(ser) clock not connected, sending old time l:%s r:%s', hms_time(self.l_time), hms_time(self.r_time)) l_time = self.l_time r_time = self.r_time if self.in_settime: logging.info( '(ser) clock still in set mode, sending old time l:%s r:%s', hms_time(self.l_time), hms_time(self.r_time)) l_time = self.l_time r_time = self.r_time DisplayMsg.show( Message.DGT_CLOCK_TIME(time_left=l_time, time_right=r_time, connect=connect, dev='ser')) if not self.enable_ser_clock: dev = 'rev' if 'REVII' in self.bt_name else 'ser' if self.watchdog_timer.is_running( ): # a running watchdog means: board already found logging.info('(%s) clock restarting setup', dev) self.startup_serial_clock() else: logging.info( '(%s) clock sends messages already but (%s) board still not found', dev, dev) if not errtim: self.r_time = r_time self.l_time = l_time else: logging.debug('(ser) clock null message ignored') if self.clock_lock: logging.debug('(ser) clock unlocked after %.3f secs', time.time() - self.clock_lock) self.clock_lock = False elif message_id == DgtMsg.DGT_MSG_BOARD_DUMP: if message_length != 64: logging.warning('illegal length in data') piece_to_char = { 0x01: 'P', 0x02: 'R', 0x03: 'N', 0x04: 'B', 0x05: 'K', 0x06: 'Q', 0x07: 'p', 0x08: 'r', 0x09: 'n', 0x0a: 'b', 0x0b: 'k', 0x0c: 'q', 0x0d: '$', 0x0e: '%', 0x0f: '&', 0x00: '.' } board = '' for character in message: board += piece_to_char[character & 0x0f] logging.debug('\n' + '\n'.join( board[0 + i:8 + i] for i in range(0, len(board), 8))) # Show debug board # Create fen from board fen = '' empty = 0 for square in range(0, 64): if message[square] != 0 and message[ square] < 0x0d: # @todo for the moment ignore the special pieces if empty > 0: fen += str(empty) empty = 0 fen += piece_to_char[message[square] & 0x0f] else: empty += 1 if (square + 1) % 8 == 0: if empty > 0: fen += str(empty) empty = 0 if square < 63: fen += '/' # Attention! This fen is NOT flipped logging.debug('raw fen [%s]', fen) DisplayMsg.show(Message.DGT_FEN(fen=fen, raw=True)) elif message_id == DgtMsg.DGT_MSG_FIELD_UPDATE: if message_length != 2: logging.warning('illegal length in data') if self.field_timer_running: self.stop_field_timer() self.start_field_timer() elif message_id == DgtMsg.DGT_MSG_SERIALNR: if message_length != 5: logging.warning('illegal length in data') DisplayMsg.show( Message.DGT_SERIAL_NR( number=''.join([chr(elem) for elem in message]))) elif message_id == DgtMsg.DGT_MSG_LONG_SERIALNR: if message_length != 10: logging.warning('illegal length in data') number = ''.join([chr(elem) for elem in message]) self.enable_revelation_pi = float( number[:4]) >= 3.25 # "3.250010001"=yes "0000000001"=no logging.info('(rev) clock in PiMode: %s - serial: %s', 'yes' if self.enable_revelation_pi else 'no', number) elif message_id == DgtMsg.DGT_MSG_BATTERY_STATUS: if message_length != 9: logging.warning('illegal length in data') DisplayMsg.show(Message.BATTERY(percent=message[0])) else: # Default logging.warning('message not handled [%s]', DgtMsg(message_id))
def _process_message(self, message): if False: # switch-case pass elif isinstance(message, Message.ENGINE_READY): self._process_engine_ready(message) elif isinstance(message, Message.ENGINE_STARTUP): self._process_engine_startup(message) elif isinstance(message, Message.ENGINE_FAIL): DgtObserver.fire(self.dgttranslate.text('Y10_erroreng')) self.dgtmenu.set_engine_restart(False) elif isinstance(message, Message.COMPUTER_MOVE): self._process_computer_move(message) elif isinstance(message, Message.NEW_GAME): self._process_new_game(message) elif isinstance(message, Message.COMPUTER_MOVE_DONE): self._process_computer_move_done() elif isinstance(message, Message.USER_MOVE_DONE): self._process_user_move_done(message) elif isinstance(message, Message.REVIEW_MOVE_DONE): self._process_review_move_done(message) elif isinstance(message, Message.ALTERNATIVE_MOVE): self.force_leds_off() self.play_mode = message.play_mode DgtObserver.fire(self.dgttranslate.text('B05_altmove')) elif isinstance(message, Message.NEW_LEVEL): if not self.dgtmenu.get_engine_restart(): DgtObserver.fire(message.level_text) elif isinstance(message, Message.TIME_CONTROL): self._process_time_control(message) elif isinstance(message, Message.NEW_BOOK): if not self.dgtmenu.get_confirm() or not message.show_ok: DgtObserver.fire(message.book_text) elif isinstance(message, Message.TAKE_BACK): self.force_leds_off() self._reset_moves_and_score() DgtObserver.fire(self.dgttranslate.text('C10_takeback')) DgtObserver.fire( Dgt.DISPLAY_TIME(force=True, wait=True, devs={'ser', 'i2c', 'web'})) elif isinstance(message, Message.GAME_ENDS): if not self.dgtmenu.get_engine_restart( ): # filter out the shutdown/reboot process text = self.dgttranslate.text(message.result.value) text.beep = self.dgttranslate.bl(BeepLevel.CONFIG) text.maxtime = 0.5 DgtObserver.fire(text) if self.dgtmenu.get_mode() == Mode.PONDER: self._reset_moves_and_score() text.beep = False text.maxtime = 1 self.score = text elif isinstance(message, Message.INTERACTION_MODE): if not self.dgtmenu.get_confirm() or not message.show_ok: DgtObserver.fire(message.mode_text) elif isinstance(message, Message.PLAY_MODE): self.play_mode = message.play_mode DgtObserver.fire(message.play_mode_text) elif isinstance(message, Message.NEW_SCORE): self._process_new_score(message) elif isinstance(message, Message.BOOK_MOVE): self.score = self.dgttranslate.text('N10_score', None) DgtObserver.fire(self.dgttranslate.text('N10_bookmove')) elif isinstance(message, Message.NEW_PV): self._process_new_pv(message) elif isinstance(message, Message.NEW_DEPTH): self.depth = message.depth elif isinstance(message, Message.IP_INFO): self.dgtmenu.int_ip = message.info['int_ip'] self.dgtmenu.ext_ip = message.info['ext_ip'] elif isinstance(message, Message.STARTUP_INFO): self._process_startup_info(message) elif isinstance(message, Message.SEARCH_STARTED): logging.debug('search started') elif isinstance(message, Message.SEARCH_STOPPED): logging.debug('search stopped') elif isinstance(message, Message.CLOCK_START): self._process_clock_start(message) elif isinstance(message, Message.CLOCK_STOP): DgtObserver.fire(Dgt.CLOCK_STOP(devs=message.devs, wait=True)) elif isinstance(message, Message.DGT_BUTTON): self._process_button(message) elif isinstance(message, Message.DGT_FEN): if self.dgtmenu.inside_updt_menu(): logging.debug('inside update menu => ignore fen %s', message.fen) else: self._process_fen(message.fen, message.raw) elif isinstance(message, Message.DGT_CLOCK_VERSION): DgtObserver.fire( Dgt.CLOCK_VERSION(main=message.main, sub=message.sub, devs={message.dev})) text = self.dgttranslate.text('Y21_picochess', devs={message.dev}) text.rd = ClockIcons.DOT DgtObserver.fire(text) if message.dev == 'ser': # send the "board connected message" to serial clock DgtObserver.fire(message.text) self._set_clock(devs={message.dev}) self._exit_display(devs={message.dev}) elif isinstance(message, Message.DGT_CLOCK_TIME): time_white = message.time_left time_black = message.time_right if self.dgtmenu.get_flip_board(): time_white, time_black = time_black, time_white EvtObserver.fire( Event.CLOCK_TIME(time_white=time_white, time_black=time_black, connect=message.connect, dev=message.dev)) elif isinstance(message, Message.CLOCK_TIME): self.low_time = message.low_time if self.low_time: logging.debug('time too low, disable confirm - w: %i, b: %i', message.time_white, message.time_black) elif isinstance(message, Message.DGT_SERIAL_NR): self._process_dgt_serial_nr() elif isinstance(message, Message.DGT_JACK_ERROR ): # only working in case of 2 clocks connected! DgtObserver.fire(self.dgttranslate.text('Y00_errorjack')) elif isinstance(message, Message.DGT_EBOARD_VERSION): if self.dgtmenu.inside_updt_menu(): logging.debug( 'inside update menu => board channel not displayed') else: DgtObserver.fire(message.text) self._exit_display(devs={'i2c', 'web' }) # ser is done, when clock found elif isinstance(message, Message.DGT_EBOARD_ERROR): if self.dgtmenu.inside_updt_menu( ) or self.dgtmenu.inside_main_menu(): logging.debug('inside menu => board error not displayed') else: DgtObserver.fire(message.text) elif isinstance(message, Message.DGT_CLOCK_ERROR): pass elif isinstance(message, Message.SWITCH_SIDES): self.play_move = chess.Move.null() self.play_fen = None self.play_turn = None self.hint_move = chess.Move.null() self.hint_fen = None self.hint_turn = None self.force_leds_off() logging.debug('user ignored move %s', message.move) elif isinstance(message, Message.EXIT_MENU): self._exit_display(devs={message.dev}) elif isinstance(message, Message.WRONG_FEN): DgtObserver.fire(self.dgttranslate.text('C10_setpieces')) elif isinstance(message, Message.BATTERY_BT): if message.percent == 0x7f: percent = ' NA' elif message.percent > 99: percent = ' 99' else: percent = str(message.percent) self.dgtmenu.battery = percent elif isinstance(message, Message.REMOTE_ROOM): self.dgtmenu.inside_room = message.inside else: # Default pass