[feat] add parameter logger to ModbusTcpClient and GcodeClient

Author: vimior

xarm/tools/gcode.py

@@ -13,37 +13,49 @@
 import logging
 import threading
 
-logger = logging.Logger('gcode')
-logger_fmt = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d] - - %(message)s'
-logger_date_fmt = '%Y-%m-%d %H:%M:%S'
-stream_handler = logging.StreamHandler(sys.stdout)
-stream_handler.setLevel(logging.DEBUG)
-stream_handler.setFormatter(logging.Formatter(logger_fmt, logger_date_fmt))
-logger.addHandler(stream_handler)
-logger.setLevel(logging.INFO)
+def create_logger(name):
+    logger = logging.Logger(name)
+    logger_fmt = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d] - - %(message)s'
+    logger_date_fmt = '%Y-%m-%d %H:%M:%S'
+    stream_handler = logging.StreamHandler(sys.stdout)
+    stream_handler.setLevel(logging.DEBUG)
+    stream_handler.setFormatter(logging.Formatter(logger_fmt, logger_date_fmt))
+    logger.handlers.clear()
+    logger.addHandler(stream_handler)
+    logger.setLevel(logging.INFO)
+    return logger
+
 
 GCODE_PATTERN = r'([A-Z])([-+]?[0-9.]+)'
 CLEAN_PATTERN = r'\s+|\(.*?\)|;.*'
 
 
 class GcodeClient(object):
-    def __init__(self, robot_ip):
+    def __init__(self, robot_ip, logger=None):
+        if isinstance(logger, logging.Logger):
+            self.logger = logger
+        else:
+            self.logger = create_logger('gcode')
         self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         self.sock.setblocking(True)
         self.sock.connect((robot_ip, 504))
+        self.logger.info('Connetc to GcodeServer({}) success'.format(robot_ip))
         self._lock = threading.Lock()
 
+    def close(self):
+        self.sock.close()
+
     def execute(self, cmd):
         data = re.sub(CLEAN_PATTERN, '', cmd.strip().upper())
         if not data:
-            # logger.warning('[E] null after clean {}'.format(cmd))
+            # self.logger.warning('[E] null after clean {}'.format(cmd))
             return -1, []
         if data[0] == '%':
-            # logger.warning('[E] starts with % ({})'.format(cmd))
+            # self.logger.warning('[E] starts with % ({})'.format(cmd))
             return -2, []
         if not re.findall(GCODE_PATTERN, data):
-            # logger.warning('[E] not found {}'.format(cmd))
+            # self.logger.warning('[E] not found {}'.format(cmd))
             return -3, []
         data = data.encode('utf-8', 'replace')
         with self._lock:
@@ -53,9 +65,9 @@ def execute(self, cmd):
         state, mode = mode_state & 0x0F, mode_state >> 4
         cmdnum = ret[3] << 8 | ret[4]
         if code != 0 or err != 0:
-            logger.error('[{}], code={}, err={}, mode={}, state={}, cmdnum={}'.format(cmd, code, err, mode, state, cmdnum))
+            self.logger.error('[{}], code={}, err={}, mode={}, state={}, cmdnum={}'.format(cmd, code, err, mode, state, cmdnum))
         elif state >= 4:
-            logger.warning('[{}], code={}, err={}, mode={}, state={}, cmdnum={}'.format(cmd, code, err, mode, state, cmdnum))
+            self.logger.warning('[{}], code={}, err={}, mode={}, state={}, cmdnum={}'.format(cmd, code, err, mode, state, cmdnum))
         return code, [mode, state, err, cmdnum]
 
     def execute_file(self, filepath):
@@ -73,6 +85,6 @@ def execute_file(self, filepath):
                     if code != 1 and code != 2:
                         return code
                 if cmd in ['M2', 'M02', 'M30']:
-                    logger.info('[{}] Program End'.format(cmd))
+                    self.logger.info('[{}] Program End'.format(cmd))
                     break
         return 0

xarm/tools/modbus_tcp.py

@@ -13,28 +13,39 @@
 import logging
 import threading
 
-logger = logging.Logger('modbus_tcp')
-logger_fmt = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d] - - %(message)s'
-logger_date_fmt = '%Y-%m-%d %H:%M:%S'
-stream_handler = logging.StreamHandler(sys.stdout)
-stream_handler.setLevel(logging.DEBUG)
-stream_handler.setFormatter(logging.Formatter(logger_fmt, logger_date_fmt))
-logger.addHandler(stream_handler)
-logger.setLevel(logging.INFO)
+def create_logger(name):
+    logger = logging.Logger(name)
+    logger_fmt = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d] - - %(message)s'
+    logger_date_fmt = '%Y-%m-%d %H:%M:%S'
+    stream_handler = logging.StreamHandler(sys.stdout)
+    stream_handler.setLevel(logging.DEBUG)
+    stream_handler.setFormatter(logging.Formatter(logger_fmt, logger_date_fmt))
+    logger.handlers.clear()
+    logger.addHandler(stream_handler)
+    logger.setLevel(logging.INFO)
+    return logger
 
 
 class ModbusTcpClient(object):
-    def __init__(self, ip, port=502, unit_id=0x01):
+    def __init__(self, ip, port=502, unit_id=0x01, logger=None):
+        if isinstance(logger, logging.Logger):
+            self.logger = logger
+        else:
+            self.logger = create_logger('modbus_tcp')
         self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         self.sock.setblocking(True)
         self.sock.connect((ip, port))
+        self.logger.info('Connetc to ModbusTcpServer({}) success'.format(ip))
         self._transaction_id = 0
         self._protocol_id = 0x00
         self._unit_id = unit_id
         self._func_code = 0x00
         self._lock = threading.Lock()
-    
+
+    def close(self):
+        self.sock.close()
+
     def __wait_to_response(self, transaction_id=None, unit_id=None, func_code=None, timeout=3):
         expired = time.monotonic() + timeout
         recv_data = b''
@@ -59,33 +70,33 @@ def __wait_to_response(self, transaction_id=None, unit_id=None, func_code=None,
             unit_id = recv_data[6]
             func_code = recv_data[7]
             if transaction_id != send_transaction_id:
-                logger.warning('Receive a reply with a mismatched transaction id (S: {}, R: {}), discard it and continue waiting.'.format(send_transaction_id, transaction_id))
+                self.logger.warning('Receive a reply with a mismatched transaction id (S: {}, R: {}), discard it and continue waiting.'.format(send_transaction_id, transaction_id))
                 length = 0
                 recv_data = b''
                 continue
             elif protocol_id != self._protocol_id:
-                logger.warning('Receive a reply with a mismatched protocol id (S: {}, R: {}), discard it and continue waiting.'.format(self._protocol_id, protocol_id))
+                self.logger.warning('Receive a reply with a mismatched protocol id (S: {}, R: {}), discard it and continue waiting.'.format(self._protocol_id, protocol_id))
                 length = 0
                 recv_data = b''
                 continue
             elif unit_id != send_unit_id:
-                logger.warning('Receive a reply with a mismatched unit id (S: {}, R: {}), discard it and continue waiting.'.format(send_unit_id, unit_id))
+                self.logger.warning('Receive a reply with a mismatched unit id (S: {}, R: {}), discard it and continue waiting.'.format(send_unit_id, unit_id))
                 length = 0
                 recv_data = b''
                 continue
             elif func_code != send_func_code and func_code != send_func_code + 0x80:
-                logger.warning('Receive a reply with a mismatched func code (S: {}, R: {}), discard it and continue waiting.'.format(send_func_code, func_code))
+                self.logger.warning('Receive a reply with a mismatched func code (S: {}, R: {}), discard it and continue waiting.'.format(send_func_code, func_code))
                 length = 0
                 recv_data = b''
                 continue
             else:
                 code = 0
                 break
         if code == 0 and len(recv_data) == 9:
-            logger.error('modbus tcp data exception, exp={}, res={}'.format(recv_data[8], recv_data))
+            self.logger.error('modbus tcp data exception, exp={}, res={}'.format(recv_data[8], recv_data))
             return recv_data[8], recv_data
         elif code != 0:
-            logger.error('recv timeout, len={}, res={}'.format(len(recv_data), recv_data))
+            self.logger.error('recv timeout, len={}, res={}'.format(len(recv_data), recv_data))
         return code, recv_data
 
     def __pack_to_send(self, pdu_data, unit_id=None):