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
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
