Merge pull request #6 from haklein/wip-move-event

Wip move event

Author: haklein

certabo-lichess.py

@@ -92,12 +92,10 @@ def handle_state_change(self, game_state):
             self.certabo.set_board_from_fen(tmp_chessboard.fen())
         if tmp_chessboard.turn == self.certabo.get_color():
             logging.info('it is our turn')
-            while self.certabo.has_user_move() == []:
-                time.sleep(0.1)
-            ucimove = self.certabo.has_user_move()[0]
-            logging.info(f'our move: {ucimove}') 
+            moves = self.certabo.get_user_move()
+            logging.info(f'our move: {moves}') 
             try:
-                self.client.board.make_move(self.certabo.get_reference(), ucimove)
+                self.client.board.make_move(self.certabo.get_reference(), moves[0])
             except:
                 e = sys.exc_info()[0]
                 logging.info(f'exception on make_move: {e}')
@@ -193,9 +191,8 @@ def setup_new_gameid(gameId):
                     if mycertabo.get_state() == 'myturn':
                         logging.info(f'starting new game, checking for user move')
                         mycertabo.set_state('init')
-                        while mycertabo.has_user_move() == []:
-                            time.sleep(0.1)
-                        client.board.make_move(mycertabo.get_reference(), mycertabo.has_user_move()[0])
+                        moves = mycertabo.get_user_move()
+                        client.board.make_move(mycertabo.get_reference(), moves[0])
 
         except berserk.exceptions.ResponseError as e:
             print(f'ERROR: Invalid server response: {e}')

certabo/certabo.py

@@ -41,6 +41,9 @@ def __init__(self, port='auto', calibrate=False, **kwargs):
         self.board_state_usb = ""
         self.mystate = "init"
         self.reference = ""
+        self.move_event = threading.Event()
+        self.wait_for_move = False
+        self.pending_moves = []
 
         # internal values for CERTABO board
         self.calibration_samples_counter = 0
@@ -60,12 +63,14 @@ def __init__(self, port='auto', calibrate=False, **kwargs):
         self.serialthread.daemon = True
         self.serialthread.start()
 
-    def has_user_move(self):
-        try:
-            moves = codes.get_moves(self.chessboard, self.board_state_usb)
-            return moves
-        except:
-            return []
+    def get_user_move(self):
+        self.wait_for_move = True
+        logging.debug('waiting for event signal')
+        self.move_event.wait()
+        self.move_event.clear()
+        logging.debug(f'event signal received, pending moves: {self.pending_moves}')
+        self.wait_for_move = False
+        return self.pending_moves 
 
     def get_reference(self):
         return self.reference
@@ -122,9 +127,25 @@ def handle_usb_data(self, data):
                 if self.usb_data_processed != []:
                     test_state = codes.usb_data_to_FEN(self.usb_data_processed, self.rotate180)
                     if test_state != "":
+                        if self.board_state_usb != test_state:
+                            new_position = True
+                        else:
+                            new_position = False
                         self.board_state_usb = test_state
-                        # logging.info(f'info string FEN {test_state}')
                         self.diff_leds()
+                        if new_position:
+                            # new board state via usb
+                            # logging.info(f'info string FEN {test_state}')
+                            if self.wait_for_move:
+                                logging.debug('trying to find user move in usb data')
+                                try:
+                                    self.pending_moves = codes.get_moves(self.chessboard, self.board_state_usb, 1) # only search one move deep
+                                    if self.pending_moves != []:
+                                        logging.debug('firing event')
+                                        # self.chessboard.push_uci(self.pending_moves[0])
+                                        self.move_event.set()
+                                except:
+                                    self.pending_moves = []
 
     def calibrate_from_usb_data(self, usb_data):
         self.calibration_samples.append(usb_data)

certabo/codes.py

@@ -592,7 +592,7 @@ class InvalidMove(Exception):
     pass
 
 
-def get_moves(board, fen):
+def get_moves(board, fen, max_depth =2):
     """
     :param board:
     :type board: chess.Board
@@ -613,16 +613,17 @@ def get_moves(board, fen):
             logging.debug('Single move detected - {}'.format(move.uci()))
             return [move.uci()]
         copy_board.pop()
-    for move in moves:
-        copy_board.push(move)
-        legal_moves2 = list(copy_board.generate_legal_moves())
-        for move2 in legal_moves2:
-            copy_board.push(move2)
-            if board_fen == copy_board.board_fen():
-                logging.debug('Double move detected - {}, {}'.format(move.uci(), move2.uci()))
-                return [move.uci(), move2.uci()]
+    if max_depth > 1:
+        for move in moves:
+            copy_board.push(move)
+            legal_moves2 = list(copy_board.generate_legal_moves())
+            for move2 in legal_moves2:
+                copy_board.push(move2)
+                if board_fen == copy_board.board_fen():
+                    logging.debug('Double move detected - {}, {}'.format(move.uci(), move2.uci()))
+                    return [move.uci(), move2.uci()]
+                copy_board.pop()
             copy_board.pop()
-        copy_board.pop()
-    # logging.debug('Unable to detect moves')
+    logging.debug('Unable to detect moves')
     raise InvalidMove()
 

certabo/serialreader.py

@@ -55,13 +55,31 @@ def __init__ (self, handler, device='auto'):
         self.connected = False
         self.handler = handler
         self.uart = None
+        self.buf = bytearray()
 
     def send_led(self, message: bytes):
         # logging.debug(f'Sending to serial: {message}')
         if self.connected:
             return self.uart.write(message)
         return None
 
+    def readline(self):
+        i = self.buf.find(b"\n")
+        if i >= 0:
+            r = self.buf[:i+1]
+            self.buf = self.buf[i+1:]
+            return r
+        while True:
+            i = max(1, min(2048, self.uart.in_waiting))
+            data = self.uart.read(i)
+            i = data.find(b"\n")
+            if i >= 0:
+                r = self.buf + data[:i+1]
+                self.buf[0:] = data[i+1:]
+                return r
+            else:
+                self.buf.extend(data)
+
     def run(self):
         while True:
             if not self.connected:
@@ -97,7 +115,8 @@ def run(self):
                 try:
                     while True:
                         # logging.debug(f'serial data pending')
-                        raw_message = self.uart.readline()
+                        #raw_message = self.uart.readline()
+                        raw_message = self.readline()
                         try:
                             message = raw_message.decode("ascii")[1: -3]
                             #if DEBUG: