Esempio n. 1
0
class FWUploadThread(threading.Thread):
    # initialization
    def __init__(self, idcode, conf_sock, sock_type):
        threading.Thread.__init__(self)

        self.dest_mac = None
        self.bin_filename = None
        self.fd = None
        self.data = None
        self.client = None
        self.timer1 = None
        self.istimeout = 0
        self.serverip = None
        self.serverport = None
        self.idcode = idcode

        self.sentbyte = 0

        self.sock_type = sock_type
        self.conf_sock = conf_sock
        conf_sock.open()
        self.wizmsghangler = WIZMSGHandler(conf_sock)

    def setparam(self, dest_mac, binaryfile):
        self.dest_mac = dest_mac
        self.bin_filename = binaryfile
        self.fd = open(self.bin_filename, "rb")
        self.data = self.fd.read(-1)
        self.remainbytes = len(self.data)
        self.curr_ptr = 0

        sys.stdout.write("\nFirmware file size: %r\n\n" % len(self.data))

    def myTimer(self):
        # sys.stdout.write('timer1 timeout\r\n')
        self.istimeout = 1

    def jumpToApp(self):
        cmd_list = []

        # boot mode change: App boot mode
        print("[%s] Jump to app boot mode" % self.dest_mac)

        cmd_list.append(["MA", self.dest_mac])
        cmd_list.append(["PW", self.idcode])
        cmd_list.append(["AB", ""])
        self.wizmsghangler.makecommands(cmd_list, OP_FWUP)
        if self.sock_type == "udp":
            self.wizmsghangler.sendcommands()
        else:
            self.wizmsghangler.sendcommandsTCP()

            if self.conf_sock != None:
                self.conf_sock.shutdown()
            time.sleep(1)

        # print('jumpToApp cmd_list: %s' % cmd_list)

    # def run(self):
    def sendCmd(self, command):
        cmd_list = []
        self.resp = None

        # Send FW UPload request message
        cmd_list.append(["MA", self.dest_mac])
        cmd_list.append(["PW", self.idcode])
        cmd_list.append([command, str(len(self.data))])
        # sys.stdout.write("cmd_list: %s\r\n" % cmd_list)
        self.wizmsghangler.makecommands(cmd_list, OP_FWUP)

        # if no reponse from device, retry for several times.
        for i in range(3):
            if self.sock_type == "udp":
                self.wizmsghangler.sendcommands()
            else:
                self.wizmsghangler.sendcommandsTCP()
            self.resp = self.wizmsghangler.parseresponse()
            if self.resp != "":
                break
            time.sleep(1)

    def run(self):
        if self.resp != "":
            resp = self.resp.decode("utf-8")
            # print('resp', resp)
            params = resp.split(":")
            sys.stdout.write("Dest IP: %s, Dest Port num: %r\r\n" % (params[0], int(params[1])))
            self.serverip = params[0]
            self.serverport = int(params[1])

            # network reachable check
            os.system("ping " + ("-n 1 " if sys.platform.lower() == "win32" else "-c 1 ") + self.serverip)
            ping_reponse = os.system(
                "ping " + ("-n 1 " if sys.platform.lower() == "win32" else "-c 1 ") + self.serverip
            )
            # ping_reponse = os.system('ping -n 1 ' + params[0])
            if ping_reponse == 0:
                print("Device[%s] network OK" % self.dest_mac)
            else:
                print(
                    "<Ping Error>: Device[%s]: %s is unreachable.\n\tRefer --multiset or --ip options to set IP address."
                    % (self.dest_mac, self.serverip)
                )
                sys.exit(0)
        else:
            print("@@@@@ Device[%s]: No response from device. Check the network or device status." % (self.dest_mac))
            sys.exit(0)

        try:
            self.client = TCPClient(2, params[0], int(params[1]))
        except:
            pass
        self.retrycheck = 0
        try:
            # sys.stdout.write("%r\r\n" % self.client.state)
            while True:
                if self.retrycheck > 20:
                    break

                self.retrycheck += 1

                if self.client.state == SOCK_CLOSE_STATE:
                    if self.timer1 != None:
                        self.timer1.cancel()
                    cur_state = self.client.state
                    try:
                        self.client.open()
                        # sys.stdout.write('1 : %r\r\n' % self.client.getsockstate())
                        # sys.stdout.write("%r\r\n" % self.client.state)
                        if self.client.state == SOCK_OPEN_STATE:
                            # sys.stdout.write('[%r] is OPEN\r\n' % (self.serverip))
                            sys.stdout.write("[%r] is OPEN | %s\r\n" % (self.serverip, self.bin_filename))
                            # sys.stdout.write('[%r] client.working_state is %r\r\n' % (self.serverip, self.client.working_state))
                            time.sleep(0.1)
                    except Exception as e:
                        print(e)

                elif self.client.state == SOCK_OPEN_STATE:
                    cur_state = self.client.state
                    # time.sleep(2)
                    try:
                        self.client.connect()
                        # sys.stdout.write('2 : %r' % self.client.getsockstate())
                        if self.client.state == SOCK_CONNECT_STATE:
                            # sys.stdout.write('[%r] is CONNECTED\r\n' % (self.serverip))
                            sys.stdout.write("[%r] is CONNECTED | %s\r\n" % (self.serverip, self.bin_filename))
                            # sys.stdout.write('[%r] client.working_state is %r\r\n' % (self.serverip, self.client.working_state))
                            # time.sleep(1)
                    except Exception as e:
                        print(e)

                elif self.client.state == SOCK_CONNECT_STATE:
                    # if self.client.working_state == idle_state:
                    # sys.stdout.write('3 : %r' % self.client.getsockstate())
                    try:
                        while self.remainbytes != 0:
                            if self.client.working_state == idle_state:
                                if self.remainbytes >= 1024:
                                    msg = bytearray(1024)
                                    msg[:] = self.data[self.curr_ptr : self.curr_ptr + 1024]
                                    self.client.write(msg)
                                    self.sentbyte = 1024
                                    # sys.stdout.write('1024 bytes sent from at %r\r\n' % (self.curr_ptr))
                                    sys.stdout.write(
                                        "[%s] 1024 bytes sent from at %r\r\n" % (self.serverip, self.curr_ptr)
                                    )
                                    self.curr_ptr += 1024
                                    self.remainbytes -= 1024
                                else:
                                    msg = bytearray(self.remainbytes)
                                    msg[:] = self.data[self.curr_ptr : self.curr_ptr + self.remainbytes]
                                    self.client.write(msg)
                                    # sys.stdout.write('Last %r byte sent from at %r \r\n' % (self.remainbytes, self.curr_ptr))
                                    sys.stdout.write(
                                        "[%s] Last %r byte sent from at %r \r\n"
                                        % (self.serverip, self.remainbytes, self.curr_ptr)
                                    )
                                    self.curr_ptr += self.remainbytes
                                    self.remainbytes = 0
                                    self.sentbyte = self.remainbytes

                                self.client.working_state = datasent_state

                                self.timer1 = threading.Timer(2.0, self.myTimer)
                                self.timer1.start()
                            elif self.client.working_state == datasent_state:
                                # sys.stdout.write('4 : %r' % self.client.getsockstate())
                                response = self.client.readbytes(2)
                                if response != None:
                                    if int(binascii.hexlify(response), 16):
                                        self.client.working_state = idle_state
                                        self.timer1.cancel()
                                        self.istimeout = 0
                                    else:
                                        print(
                                            f"ERROR: Device[{self.dest_mac}]: No response from device. Stop FW upload..."
                                        )
                                        self.client.close()
                                        sys.exit(0)

                                if self.istimeout == 1:
                                    self.istimeout = 0
                                    self.client.working_state = idle_state
                                    self.client.close()
                                    sys.exit(0)

                    except Exception as e:
                        print(e)
                        response = ""
                    break

            if self.retrycheck > 20:
                print(f"Device [{self.dest_mac}] firmware upload fail. (file: {self.bin_filename})\r\n")
            else:
                print(f"Device [{self.dest_mac}] firmware upload success! (file: {self.bin_filename})\r\n")
            # for send FIN packet
            time.sleep(1)
            self.client.shutdown()
        except (KeyboardInterrupt, SystemExit):
            print(e)
        finally:
            pass
Esempio n. 2
0
class FWUploadThread(QThread):
    uploading_size = pyqtSignal(int)
    upload_result = pyqtSignal(int)
    error_flag = pyqtSignal(int)

    def __init__(self, conf_sock, dest_mac, idcode, set_pw, filename, filesize,
                 ipaddr, port, dev_name):
        QThread.__init__(self)

        self.dest_mac = None
        self.bin_filename = filename
        self.fd = None
        self.data = None
        self.client = None
        self.timer1 = None
        self.istimeout = 0
        self.serverip = None
        self.serverport = None
        self.sentbyte = 0
        self.dest_mac = dest_mac
        self.idcode = idcode
        self.error_noresponse = 0
        self.retrycheck = 0

        # if wiz2000
        self.dev_name = dev_name
        self.set_pw = set_pw

        self.filesize = filesize
        self.remainbytes = self.filesize

        self.conf_sock = conf_sock
        self.sock_type = '%s' % self.conf_sock

        # socket config (for TCP unicast)
        self.ip_addr = ipaddr
        self.port = port

        self.tcp_sock = None

    def setparam(self):
        self.fd = open(self.bin_filename, "rb")
        self.data = self.fd.read(-1)
        self.curr_ptr = 0
        self.fd.close()

    def myTimer(self):
        # sys.stdout.write('timer1 timeout\r\n')
        self.istimeout = 1

    def jumpToApp(self):
        cmd_list = []
        # boot mode change: App boot mode
        cmd_list.append(["MA", self.dest_mac])
        cmd_list.append(["PW", self.idcode])
        cmd_list.append(["AB", ""])

        if 'TCP' in self.sock_type:
            self.wizmsghangler = WIZMSGHandler(self.conf_sock, cmd_list, 'tcp',
                                               OP_FWUP, 2)
        elif 'UDP' in self.sock_type:
            self.wizmsghangler = WIZMSGHandler(self.conf_sock, cmd_list, 'udp',
                                               OP_FWUP, 2)

        self.resp = self.wizmsghangler.run()

        self.uploading_size.emit(1)
        self.msleep(1000)

    def sendCmd(self, command):
        cmd_list = []
        self.resp = None

        # Send FW UPload request message
        cmd_list.append(["MA", self.dest_mac])
        cmd_list.append(["PW", self.idcode])
        if 'WIZ2000' in self.dev_name:
            cmd_list.append(["AP", self.set_pw.decode()])
        cmd_list.append([command, str(self.filesize)])

        print('sendCmd() cmd_list ===> ', cmd_list)

        if 'TCP' in self.sock_type:
            self.wizmsghangler = WIZMSGHandler(self.conf_sock, cmd_list, 'tcp',
                                               OP_FWUP, 2)
        elif 'UDP' in self.sock_type:
            self.wizmsghangler = WIZMSGHandler(self.conf_sock, cmd_list, 'udp',
                                               OP_FWUP, 2)
        sys.stdout.write("sendCmd(): %s\r\n" % cmd_list)

        # if no reponse from device, retry for several times.
        for i in range(4):
            # self.resp = self.wizmsghangler.parseresponse()
            self.resp = self.wizmsghangler.run()
            if self.resp is not '':
                break

        self.msleep(500)
        self.uploading_size.emit(2)

    def run(self):
        self.setparam()
        # wiz2000: not use 'AB' command
        print('===============>> FW upload', self.dev_name)
        if 'WIZ2000' in self.dev_name:
            print('wiz2000 FW upload', self.dev_name)
            pass
        else:
            self.jumpToApp()

        if 'UDP' in self.sock_type:
            pass
        elif 'TCP' in self.sock_type:
            self.sock_close()
            self.SocketConfig()

        self.sendCmd('FW')

        if self.resp is not '' and self.resp is not None:
            resp = self.resp.decode('utf-8')
            # print('resp', resp)
            params = resp.split(':')
            sys.stdout.write('Dest IP: %s, Dest Port num: %r\r\n' %
                             (params[0], int(params[1])))
            self.serverip = params[0]
            self.serverport = int(params[1])

            self.uploading_size.emit(3)
        else:
            print(
                'No response from device. Check the network or device status.')
            self.error_flag.emit(-1)
            self.error_noresponse = -1
        try:
            self.client = TCPClient(2, params[0], int(params[1]))
        except:
            pass
        try:
            if self.error_noresponse < 0:
                pass
            else:
                # sys.stdout.write("%r\r\n" % self.client.state)
                while True:
                    if self.retrycheck > 6:
                        break

                    self.retrycheck += 1
                    if self.client.state is SOCK_CLOSE_STATE:
                        if self.timer1 is not None:
                            self.timer1.cancel()
                        cur_state = self.client.state
                        try:
                            self.client.open()
                            # sys.stdout.write('1 : %r\r\n' % self.client.getsockstate())
                            # sys.stdout.write("%r\r\n" % self.client.state)
                            if self.client.state is SOCK_OPEN_STATE:
                                sys.stdout.write('[%r] is OPEN\r\n' %
                                                 (self.serverip))
                                # sys.stdout.write('[%r] client.working_state is %r\r\n' % (self.serverip, self.client.working_state))
                                self.msleep(500)
                        except Exception as e:
                            sys.stdout.write('%r\r\n' % e)

                    elif self.client.state is SOCK_OPEN_STATE:
                        self.uploading_size.emit(4)
                        cur_state = self.client.state
                        try:
                            self.client.connect()
                            # sys.stdout.write('2 : %r' % self.client.getsockstate())
                            if self.client.state is SOCK_CONNECT_STATE:
                                sys.stdout.write('[%r] is CONNECTED\r\n' %
                                                 (self.serverip))
                                # sys.stdout.write('[%r] client.working_state is %r\r\n' % (self.serverip, self.client.working_state))
                        except Exception as e:
                            sys.stdout.write('%r\r\n' % e)

                    elif self.client.state is SOCK_CONNECT_STATE:
                        # if self.client.working_state == idle_state:
                        # sys.stdout.write('3 : %r' % self.client.getsockstate())
                        try:
                            self.uploading_size.emit(5)
                            while self.remainbytes is not 0:
                                if self.client.working_state == idle_state:
                                    if self.remainbytes >= FW_PACKET_SIZE:
                                        msg = bytearray(FW_PACKET_SIZE)
                                        msg[:] = self.data[self.curr_ptr:self.
                                                           curr_ptr +
                                                           FW_PACKET_SIZE]
                                        self.client.write(msg)
                                        self.sentbyte = FW_PACKET_SIZE
                                        # sys.stdout.write('FW_PACKET_SIZE bytes sent from at %r\r\n' % (self.curr_ptr))
                                        sys.stdout.write(
                                            '[%s] FW_PACKET_SIZE bytes sent from at %r\r\n'
                                            % (self.serverip, self.curr_ptr))
                                        self.curr_ptr += FW_PACKET_SIZE
                                        self.remainbytes -= FW_PACKET_SIZE
                                    else:
                                        self.uploading_size.emit(6)
                                        msg = bytearray(self.remainbytes)
                                        msg[:] = self.data[self.curr_ptr:self.
                                                           curr_ptr +
                                                           self.remainbytes]
                                        self.client.write(msg)
                                        # sys.stdout.write('Last %r byte sent from at %r \r\n' % (self.remainbytes, self.curr_ptr))
                                        sys.stdout.write(
                                            '[%s] Last %r byte sent from at %r \r\n'
                                            % (self.serverip, self.remainbytes,
                                               self.curr_ptr))
                                        self.curr_ptr += self.remainbytes
                                        self.remainbytes = 0
                                        self.sentbyte = self.remainbytes

                                    self.client.working_state = datasent_state

                                    self.timer1 = threading.Timer(
                                        2.0, self.myTimer)
                                    self.timer1.start()

                                elif self.client.working_state == datasent_state:
                                    # sys.stdout.write('4 : %r' % self.client.getsockstate())
                                    response = self.client.readbytes(2)
                                    if response is not None:
                                        if int(binascii.hexlify(response), 16):
                                            self.client.working_state = idle_state
                                            self.timer1.cancel()
                                            self.istimeout = 0
                                        else:
                                            print(
                                                'ERROR: No response from device. Stop FW upload...'
                                            )
                                            self.client.close()
                                            self.upload_result.emit(-1)
                                            self.terminate()

                                    if self.istimeout is 1:
                                        self.istimeout = 0
                                        self.client.working_state = idle_state
                                        self.client.close()
                                        self.upload_result.emit(-1)
                                        self.terminate()

                                self.uploading_size.emit(7)

                        except Exception as e:
                            sys.stdout.write('%r\r\n' % e)
                            response = ""
                        break

            print('retrycheck: %d' % self.retrycheck)

            if self.retrycheck > 6 or self.error_noresponse < 0:
                sys.stdout.write('Device [%s] firmware upload fail.\r\n' %
                                 (self.dest_mac))
                self.upload_result.emit(-1)
            elif self.error_noresponse >= 0:
                self.uploading_size.emit(8)
                sys.stdout.write('Device [%s] firmware upload success!\r\n' %
                                 (self.dest_mac))
                self.upload_result.emit(1)
                # send FIN packet
                self.msleep(500)
                self.client.shutdown()
                if 'TCP' in self.sock_type:
                    self.conf_sock.shutdown()
        except Exception as e:
            self.error_flag.emit(-3)
            sys.stdout.write('%r\r\n' % e)
        finally:
            pass

    def sock_close(self):
        # 기존 연결 fin
        if self.tcp_sock is not None:
            if self.tcp_sock.state is not SOCK_CLOSE_STATE:
                self.tcp_sock.shutdown()
        if self.conf_sock is not None:
            self.conf_sock.shutdown()

    def tcpConnection(self, serverip, port):
        retrynum = 0
        self.tcp_sock = TCPClient(2, serverip, port)
        print('sock state: %r' % (self.tcp_sock.state))

        while True:
            if retrynum > 6:
                break
            retrynum += 1

            if self.tcp_sock.state is SOCK_CLOSE_STATE:
                self.tcp_sock.shutdown()
                cur_state = self.tcp_sock.state
                try:
                    self.tcp_sock.open()
                    if self.tcp_sock.state is SOCK_OPEN_STATE:
                        print('[%r] is OPEN' % (serverip))
                    time.sleep(0.5)
                except Exception as e:
                    sys.stdout.write('%r\r\n' % e)
            elif self.tcp_sock.state is SOCK_OPEN_STATE:
                cur_state = self.tcp_sock.state
                try:
                    self.tcp_sock.connect()
                    if self.tcp_sock.state is SOCK_CONNECT_STATE:
                        print('[%r] is CONNECTED' % (serverip))
                except Exception as e:
                    sys.stdout.write('%r\r\n' % e)
            elif self.tcp_sock.state is SOCK_CONNECT_STATE:
                break
        if retrynum > 6:
            sys.stdout.write('Device [%s] TCP connection failed.\r\n' %
                             (serverip))
            return None
        else:
            sys.stdout.write('Device [%s] TCP connected\r\n' % (serverip))
            return self.tcp_sock

    def SocketConfig(self):
        # Broadcast
        if 'UDP' in self.sock_type:
            self.conf_sock = WIZUDPSock(5000, 50001)
            self.conf_sock.open()

        # TCP unicast
        elif 'TCP' in self.sock_type:
            print('upload_unicast: ip: %r, port: %r' %
                  (self.ip_addr, self.port))

            self.conf_sock = self.tcpConnection(self.ip_addr, self.port)

            if self.conf_sock is None:
                # self.isConnected = False
                print('TCP connection failed!: %s' % self.conf_sock)
                self.error_flag.emit(-3)
                self.terminate()
            else:
                self.isConnected = True
class FWUploadThread(threading.Thread):
    # initialization
    # def __init__(self, log_level):
    def __init__(self):
        threading.Thread.__init__(self)

        self.dest_mac = None
        self.bin_filename = None
        self.fd = None
        self.data = None
        self.client = None
        self.timer1 = None
        self.istimeout = 0
        self.serverip = None
        self.serverport = None

        self.sentbyte = 0

        conf_sock = WIZUDPSock(5000, 50001)
        conf_sock.open()
        self.wizmsghangler = WIZMSGHandler(conf_sock)

    def setparam(self, dest_mac, binaryfile):
        self.dest_mac = dest_mac
        self.bin_filename = binaryfile
        self.fd = open(self.bin_filename, "rb")
        self.data = self.fd.read(-1)
        self.remainbytes = len(self.data)
        self.curr_ptr = 0

        sys.stdout.write("Firmware file size: %r\n\n" % len(self.data))

    def myTimer(self):
        # sys.stdout.write('timer1 timeout\r\n')
        self.istimeout = 1

    def jumpToApp(self):
        cmd_list = []
        # boot mode change: App boot mode
        cmd_list.append(["MA", self.dest_mac])
        cmd_list.append(["PW", " "])
        cmd_list.append(["AB", ""])
        self.wizmsghangler.makecommands(cmd_list, OP_FWUP)
        self.wizmsghangler.sendcommands()

    def run(self):
        cmd_list = []

        # Send FW UPload request message
        cmd_list.append(["MA", self.dest_mac])
        cmd_list.append(["PW", " "])
        cmd_list.append(["FW", str(len(self.data))])
        # sys.stdout.write("cmd_list: %s\r\n" % cmd_list)
        self.wizmsghangler.makecommands(cmd_list, OP_FWUP)
        self.wizmsghangler.sendcommands()
        resp = self.wizmsghangler.parseresponse()

        if resp is not '':
            resp = resp.decode('utf-8')
            # print('resp', resp)
            params = resp.split(':')
            sys.stdout.write('Dest IP: %s, Dest Port num: %r\r\n' %
                             (params[0], int(params[1])))
            self.serverip = params[0]
            self.serverport = int(params[1])

            # # network reachable check
            # os.system("ping " + ("-n 1 " if sys.platform.lower()=="win32" else "-c 1 ") + self.serverip)
            # ping_reponse = os.system("ping " + ("-n 1 " if sys.platform.lower()=="win32" else "-c 1 ") + self.serverip)
            # # ping_reponse = os.system('ping -n 1 ' + params[0])
            # if ping_reponse == 0:
            #     print('Device[%s] network OK' % self.dest_mac)
            # else:
            #     print('<ERROR>: Device[%s]: %s is unreachable.\n\tRefer --multiset or --ip options to set IP address.' % (self.dest_mac, self.serverip))
            #     sys.exit(0)
        else:
            print(
                'No response from device. Check the network or device status.')
            sys.exit(0)

        try:
            self.client = TCPClient(2, params[0], int(params[1]))
        except:
            pass

        try:
            # sys.stdout.write("%r\r\n" % self.client.state)
            while True:

                if self.client.state is SOCK_CLOSE_STATE:
                    if self.timer1 is not None:
                        self.timer1.cancel()
                    cur_state = self.client.state
                    try:
                        self.client.open()
                        # sys.stdout.write('1 : %r\r\n' % self.client.getsockstate())
                        # sys.stdout.write("%r\r\n" % self.client.state)
                        if self.client.state is SOCK_OPEN_STATE:
                            sys.stdout.write('[%r] is OPEN\r\n' %
                                             (self.serverip))
                            # sys.stdout.write('[%r] client.working_state is %r\r\n' % (self.serverip, self.client.working_state))
                            time.sleep(0.5)
                    except Exception as e:
                        sys.stdout.write('%r\r\n' % e)

                elif self.client.state is SOCK_OPEN_STATE:
                    cur_state = self.client.state
                    # time.sleep(2)
                    try:
                        self.client.connect()
                        # sys.stdout.write('2 : %r' % self.client.getsockstate())
                        if self.client.state is SOCK_CONNECT_STATE:
                            sys.stdout.write('[%r] is CONNECTED\r\n' %
                                             (self.serverip))
                            # sys.stdout.write('[%r] client.working_state is %r\r\n' % (self.serverip, self.client.working_state))
                            # time.sleep(1)
                    except Exception as e:
                        sys.stdout.write('%r\r\n' % e)

                elif self.client.state is SOCK_CONNECT_STATE:
                    # if self.client.working_state == idle_state:
                    # sys.stdout.write('3 : %r' % self.client.getsockstate())
                    try:
                        while self.remainbytes is not 0:
                            if self.client.working_state == idle_state:
                                if self.remainbytes >= 1024:
                                    msg = bytearray(1024)
                                    msg[:] = self.data[self.
                                                       curr_ptr:self.curr_ptr +
                                                       1024]
                                    self.client.write(msg)
                                    self.sentbyte = 1024
                                    # sys.stdout.write('1024 bytes sent from at %r\r\n' % (self.curr_ptr))
                                    sys.stdout.write(
                                        '[%s] 1024 bytes sent from at %r\r\n' %
                                        (self.serverip, self.curr_ptr))
                                    self.curr_ptr += 1024
                                    self.remainbytes -= 1024
                                else:
                                    msg = bytearray(self.remainbytes)
                                    msg[:] = self.data[self.
                                                       curr_ptr:self.curr_ptr +
                                                       self.remainbytes]
                                    self.client.write(msg)
                                    # sys.stdout.write('Last %r byte sent from at %r \r\n' % (self.remainbytes, self.curr_ptr))
                                    sys.stdout.write(
                                        '[%s] Last %r byte sent from at %r \r\n'
                                        % (self.serverip, self.remainbytes,
                                           self.curr_ptr))
                                    self.curr_ptr += self.remainbytes
                                    self.remainbytes = 0
                                    self.sentbyte = self.remainbytes

                                self.client.working_state = datasent_state

                                self.timer1 = threading.Timer(
                                    2.0, self.myTimer)
                                self.timer1.start()
                            elif self.client.working_state == datasent_state:
                                # sys.stdout.write('4 : %r' % self.client.getsockstate())
                                response = self.client.readbytes(2)
                                if response is not None:
                                    if int(binascii.hexlify(response), 16):
                                        self.client.working_state = idle_state
                                        self.timer1.cancel()
                                        self.istimeout = 0
                                    else:
                                        print(
                                            'ERROR: No response from device. Stop FW upload...'
                                        )
                                        self.client.close()
                                        sys.exit(0)

                                if self.istimeout is 1:
                                    self.istimeout = 0
                                    self.client.working_state = idle_state
                                    self.client.close()
                                    sys.exit(0)

                    except Exception as e:
                        sys.stdout.write('%r\r\n' % e)
                        response = ""
                    break
            sys.stdout.write('Device [%s] firmware upload success!\r\n' %
                             (self.dest_mac))
            # for send FIN packet
            time.sleep(2.5)
            self.client.shutdown()
        except (KeyboardInterrupt, SystemExit):
            sys.stdout.write('%r\r\n' % e)
        finally:
            pass