# uncompyle6 version 3.9.3 # Python bytecode version base 2.6 (62161) # Decompiled from: Python 3.9.25 (main, Oct 31 2025, 23:16:49) # [GCC 14.2.0] # Embedded file name: d_protocol.pyc # Compiled at: 2025-05-20 14:45:24 import sys, socket, collections, mytime, myserial, threading, copy, struct, types, os.path, traceback, wx, codecs, string, main, protocol, math, one_unit, subprocess, d_usb, data_model, server, ConfigParser, os from random import randint import zipfile, future, cleanImage from definitions import * def getString(str): return one_unit.getString(str) mac_names = 'posix' if os.name in mac_names: newline = '\n' else: newline = '\r\n' FOUND_CODEC_ES9290Q_1 = 1 FOUND_CODEC_ES9290Q_2 = 2 FOUND_CODEC_ES9006 = 4 FOUND_CODEC_ES9017Q = 8 FOUND_CODEC_PCM1690 = 16 FOUND_CODEC_TAS5760M = 32 FOUND_CODEC_AK5702 = 64 FOUND_CODEC_AK5534 = 128 FOUND_CODEC_AK5534_NO_I2C = 256 FOUND_CODEC_TLV320ADC5140 = 512 FOUND_CODEC_AK5704 = 1024 FOUND_CODEC_AK4619 = 2048 FOUND_CODEC_ES9290Q_3 = 4096 FOUND_CODEC_ES9290Q_4 = 8192 FOUND_CODEC_ES9026PRO = 16384 FOUND_PLL_CS2100 = 65536 FOUND_PLL_SI5351 = 131072 FOUND_SENSOR_LSM303 = 1048576 FOUND_SENSOR_DS18B20 = 2097152 FOUND_HARDWARE_TEXT = {FOUND_CODEC_ES9290Q_1: 'Codec: ES9290Q 1', FOUND_CODEC_ES9290Q_2: 'Codec: ES9290Q 2', FOUND_CODEC_ES9290Q_3: 'Codec: ES9290Q 3', FOUND_CODEC_ES9290Q_4: 'Codec: ES9290Q 4', FOUND_CODEC_ES9006: 'Codec: ES9006', FOUND_CODEC_ES9017Q: 'Codec: ES9017Q', FOUND_CODEC_PCM1690: 'Codec: PCM1690', FOUND_CODEC_TAS5760M: 'Codec: TAS5760', FOUND_CODEC_AK5702: 'Codec: AK5702', FOUND_CODEC_AK5534: 'Codec: AK5534', FOUND_CODEC_AK5534_NO_I2C: 'Codec: AK5534 NO I2C', FOUND_CODEC_TLV320ADC5140: 'Codec: TLV320ADC5140', FOUND_CODEC_AK5704: 'Codec: AK5704', FOUND_CODEC_AK4619: 'Codec: AK4619', FOUND_CODEC_ES9026PRO: 'Codec: ES9026PRO', FOUND_PLL_CS2100: 'PLL: CS2100', FOUND_PLL_SI5351: 'PLL: Si5351', FOUND_SENSOR_LSM303: 'Sensor: LSM303', FOUND_SENSOR_DS18B20: 'Sensor: DS18B20'} if True: SYNC_DELAY = 0 MIN_DELAY = 0.03 MIN_DELAY_USB = 0.1 MAX_DELAY = 0.05 MAX_DELAY_USB = 0.1 CHOOSE_VAR_TO_UPDATE_SKIP_CYCLES = 5000 CONDITIONAL_VU = True Key = collections.namedtuple('Key', 'struct_id, member_id, channel, num') CodeTable = ( 233, 45, 98, 215, 123, 42, 99, 23, 178, 132, 200, 150, 100, 50, 77, 43, 54, 90, 31, 43, 123, 234, 211, 177, 65, 133, 3, 64, 23, 83, 251, 1, 54, 34) verifiedList = {1: '', 2: 'AKM ADC installed', 4: 'Default DAC installed', 8: 'AUX ADC installed', 16: 'PLL installed', 32: 'Inclinometer installed', 64: '', 128: '', 256: '', 512: '', 1024: '', 2048: '', 4096: 'USB processor installed', 8192: 'Dante module installed', 16384: 'PLL is master clock', 32768: 'Burr Brown ADC installed', 65536: 'Burr Brown DAC installed', 131072: '', 262144: '', 524288: '', 1048576: ''} notInstalledList = {1: '', 2: '', 4: '', 8: 'AUX ADC not installed', 16: 'PLL not installed', 32: 'Inclinometer not installed', 64: '', 128: '', 256: '', 512: '', 1024: '', 2048: '', 4096: 'USB processor not installed', 8192: 'Dante module not installed', 16384: 'DSP is master clock', 32768: '', 65536: '', 131072: '', 262144: '', 524288: '', 1048576: ''} errorList = {1: 'DSP bus error', 2: 'ADC bus error', 4: 'DAC bus error', 8: 'AUX ADC bus error', 16: 'PLL bus error', 32: 'Motion Sensor not available', 64: 'Coprocessor bus error', 128: 'Flash not empty in virgin state', 256: 'Failed to write Global', 512: 'Failed to write slot', 1024: 'Failed to write preset', 2048: 'Memory full', 4096: 'Failed to read preset', 8192: 'Dante module not installed', 16384: '', 32768: '', 65536: ''} def readableHEX(cmd): res = '' for c in cmd: res += hex(ord(c)) + ':' return res[:-1] def readableDecimal(cmd): res = '' for c in cmd: res += str(ord(c)) + ':' return res[:-1] def readable(key): if key.member_id in (protocol.MEMBER_ID_VU_IN, protocol.MEMBER_ID_VU_OUT, protocol.MEMBER_ID_GR_IN, protocol.MEMBER_ID_GR_OUT): res = 'Got ' + protocol.get_member_text(key.member_id) + ' ' if key.channel < 128: res += str(key.channel + 1) + ' ' else: res += str(key.channel - 127) + ' ' return res res = '' res += protocol.get_strid_text(key.struct_id) + ' ' res += protocol.get_member_text(key.member_id) + ' ' if key.channel < 128: res += 'Input ' + str(key.channel + 1) + ' ' else: res += 'Output ' + str(key.channel - 127) + ' ' res += 'No. ' + str(key.num) return res def safeRemove(array, key): try: array.remove(key) except: pass return class Unit_var(): """The state of an interface variable in a hardware unit""" def __init__(self): """Constructor""" self.read_val = None self.read_ts = None self.change_ts = 0 self.write_val = None self.write_ts = 0 self.SetCount = 0 self.set_ts = 0 self.saved_val = None self.set_time = 0 self.target_val = None return class RemoteUnit(): def __init__(self): self.MAC = 'no MAC' self.IP = 'no IP' self.type = 'no type' self.name = 'no name' self.pkt = None self.MK2 = False self.link_status = None self.link_type = None self.last_rx = 0 self.thread = None self.preset_names = {} self.values = {} self.process = None self.last_write = {} self.BuildNumber = 0 self.HWVersion = None self.FWVersion = 'Unknown' self.PICVersion = None self.Serial = None self.ProductionDate = None self.numericalFWVersion = 0 self.originalSwID = '' self.InstanceId = None self.Muted = str(False) self.DSPState = 0 self.minPresetLockVersion = 198656 self.minPINVersion = 198656 self.minFIRgainVersion = 198677 self.minBuildNumberVersion = 198679 self.minModelFirmwareVersion = 198679 self.foundHardwareString = 'Found Hardware: Unknown' return update_interval = 300 class Remote_Link(): def __init__(self, parent, MAC): self.parent = parent self.MAC = MAC self.stopping = False self.thread = threading.Thread(name=MAC, target=self.process) self.thread.daemon = True self.lock = threading.Lock() self.model_firmware_string = '' self.model_firmware = 0 self.model_number_string = '' self.model_number = -1 self.started_read_image = False self.reset_counter = 0 self.first_sync = True self.IP = 'USB' self.fastUpdate = False self.lastPrintTime = 0 self.enable_vu = False self.initial_sync = False self.connectTime = 0 if self.MAC not in one_unit.app.bootloader_progress: one_unit.updateBootloaderDial(self.MAC, None) one_unit.app.always_allow_update[self.MAC] = False self.main_config = ConfigParser.ConfigParser() self.main_config.read(os.path.join(one_unit.app.cwd, 'main.cfg')) try: emulate = self.main_config.get('ROOT', 'emulate') self.main_config = ConfigParser.ConfigParser() self.main_config.read(one_unit.app.cwd + '/customers/' + emulate + '/main.cfg') except: pass try: self.global_vu_stereo_out = eval(self.main_config.get('ROOT', 'global_vu_stereo_out')) except: self.global_vu_stereo_out = False try: self.global_vu_channels = eval(self.main_config.get('ROOT', 'global_vu_channels')) except: self.global_vu_channels = None try: self.mute_channels = eval(self.main_config.get('ROOT', 'mute_channels')) except: self.mute_channels = None self.conn = Protocol_Execute(self) self.invalid_packet_counter = 0 self.delay = 0.01 self.connection_attempts = 0 self.ignore_fw_version = '' self.ser = None self.fw_retry_counter = 0 self.action = None self.start_bootloader_time = mytime.clock() self.last_mute_state = {} self.last_refresh = mytime.clock() self.updateDisplayState = 0 self.start() return def TempMute(self, mute): if self.mute_channels == None or self.mute_channels == []: self.mute_channels = [] for key in self.conn.values.keys(): if key.struct_id == protocol.STRUCT_ID_MUTE and key.channel < 128: if key.channel not in self.mute_channels: self.mute_channels.append(key.channel) self.conn.set_by_key(key, mute) self.parent.peers.set_by_key(self.MAC, key, mute) self.parent.peers.units[self.MAC].Muted = str(mute) else: for channel in self.mute_channels: key = data_model.Key(protocol.STRUCT_ID_MUTE, protocol.MEMBER_ID_MUTE, channel, 0) self.conn.set_by_key(key, mute) self.parent.peers.set_by_key(self.MAC, key, mute) self.parent.peers.units[self.MAC].Muted = str(mute) return def restartSocket(self): try: self.ethSocket.close() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(0.5) s.connect((self.IP, 50675)) s.settimeout(0.5) self.ethSocket = s print mytime.displayTime(), 'd_p.Restarted Ethernet socket' except: print mytime.displayTime(), 'Failed to restart ethernet socket' return def updateDisplay(self, s): stateInit = 0 stateGetNextFile = 1 stateStartUploadFile = 2 stateUploadFile = 3 stateFinishedOK = 4 stateFinishedFailed = 5 blockSize = 1024 if self.updateDisplayState == stateInit: self.updateDisplayFileList = [] try: fNames = sorted(os.listdir(one_unit.app.cwd + '/dfi/VT_SET')) for fName in fNames: if fName in ('CONFIG.txt', '.DS_Store'): continue self.updateDisplayFileList.append(fName) print self.updateDisplayFileList except: print mytime.displayTime(), 'd_p.uD. directory not found?' traceback.print_exc(file=sys.stdout) self.updateDisplayState = stateFinishedFailed return if len(self.updateDisplayFileList) == 0: print mytime.displayTime(), 'd_p.uD. No file to upload', fNames self.updateDisplayState = stateFinishedFailed return self.updateDisplayState = stateGetNextFile self.update_start_time = mytime.clock() self.filesToUpload = len(self.updateDisplayFileList) s.settimeout(0.5) return else: if self.updateDisplayState == stateGetNextFile: if len(self.updateDisplayFileList) == 0: self.updateDisplayState = stateFinishedOK print mytime.displayTime(), 'File uploaded in', mytime.clock() - self.updateDisplayFileStartTime, 'seconds' return self.fileStartTime = mytime.clock() self.updateDisplayFileName = self.updateDisplayFileList[0] f = open(one_unit.app.cwd + '/dfi/VT_SET/' + self.updateDisplayFileName, 'rb') fData = f.read() f.close() self.updateDisplayFileData = fData print mytime.displayTime(), 'Upload File:', self.updateDisplayFileName, len(self.updateDisplayFileData), 'bytes' self.updateDisplayState = stateStartUploadFile self.updateDisplayFileStartTime = mytime.clock() if self.updateDisplayState == stateStartUploadFile: print mytime.displayTime(), 'd_p.uD.sending file name', self.updateDisplayFileName if mytime.clock() - self.fileStartTime > 10: print mytime.displayTime(), 'd_p.file timeout' self.updateDisplayState = stateFinishedFailed return cmd = 'DCDISPLAY_FILENAME' + struct.pack('>l', len(self.updateDisplayFileData)) + self.updateDisplayFileName + 'Q' print mytime.displayTime(), 'Command:', cmd, readableHEX(cmd) if s != None: try: s.send(cmd) except: self.restartSocket() return try: if s != None: new_pkt = s.recv(4096) else: self.restartSocket() return except: new_pkt = None self.updateDisplayState = stateFinishedFailed return print mytime.displayTime(), 'd:p.uD.got reply', readableHEX(new_pkt[:6]), new_pkt[6:] if new_pkt != None and len(new_pkt) >= 7 + len(self.updateDisplayFileName) and ord(new_pkt[0]) == 68 and ord(new_pkt[1]) == 4 and new_pkt[6 + len(self.updateDisplayFileName)] == 'Q': returnedFileName = new_pkt[6:6 + len(self.updateDisplayFileName)] returnedFileSize = struct.unpack('>l', new_pkt[2:6])[0] if returnedFileName == self.updateDisplayFileName and returnedFileSize == len(self.updateDisplayFileData): print mytime.displayTime(), 'd_p.uD.file name and size confirmed' self.updateDisplayState = stateUploadFile self.completion = 0 mytime.sleep(0.1) else: print mytime.displayTime(), 'File name:', returnedFileName, len(returnedFileName), self.updateDisplayFileName, len(self.updateDisplayFileName), 'File size:', returnedFileSize, len(self.updateDisplayFileData) self.updateDisplayState = stateFinishedFailed return return if self.updateDisplayState == stateUploadFile: start = self.completion end = self.completion + blockSize if end > len(self.updateDisplayFileData): end = len(self.updateDisplayFileData) print mytime.displayTime(), 'uploading', self.updateDisplayFileName, start, 'to', end, 'of', len(self.updateDisplayFileData), 'bytes' if end == len(self.updateDisplayFileData): cmd = 'DCDISPLAY_FILELAST' + self.updateDisplayFileData[start:end] + 'Q' last = True else: cmd = 'DCDISPLAY_FILEDATA' + self.updateDisplayFileData[start:end] + 'Q' last = False if s != None: try: s.send(cmd) except: self.restartSocket() return try: if s != None: new_pkt = s.recv(4096) else: self.restartSocket() except: new_pkt = None self.updateDisplayState = stateFinishedFailed return else: if last and new_pkt != None and len(new_pkt) >= 3 + end - start: print mytime.displayTime(), 'last packet:', new_pkt[:18], readableHEX(new_pkt[:18]) if new_pkt[:17] != 'One file Saved OK': print mytime.displayTime(), 'Upload Failed!!! -> retry' self.updateDisplayState = stateGetNextFile mytime.sleep(1) return print mytime.displayTime(), 'Upload: File Saved OK' new_pkt = new_pkt[18:] if new_pkt != None and len(new_pkt) >= 3 + end - start and ord(new_pkt[0]) == 68 and ord(new_pkt[1]) == 5 and new_pkt[2 + end - start] == 'Q': if new_pkt[2:2 + end - start] == self.updateDisplayFileData[start:end]: self.completion = end if last: self.updateDisplayState = stateGetNextFile self.updateDisplayFileList.remove(self.updateDisplayFileName) mytime.sleep(1) else: print mytime.displayTime(), 'Data not verified', len(new_pkt), new_pkt[:10], new_pkt[-1] self.updateDisplayState = stateFinishedFailed return one_unit.updateBootloaderDial(self.MAC, '(3) Uploading file ' + str(self.filesToUpload - len(self.updateDisplayFileList) + 1) + ' of ' + str(self.filesToUpload) + ' (' + str(self.completion * 100 / len(self.updateDisplayFileData)) + '%)', alwaysUpdate=False) else: print mytime.displayTime(), 'Invalid packet', len(new_pkt), readableHEX(new_pkt[2:12]), readableHEX(self.updateDisplayFileData[start:start + 10]) self.updateDisplayState = stateFinishedFailed return return if self.updateDisplayState == stateFinishedOK: one_unit.updateBootloaderDial(self.MAC, '(3) Finished', alwaysUpdate=True) print mytime.displayTime(), 'Finished uploading display files in', mytime.clock() - self.update_start_time, 'seconds.' s.settimeout(0.5) cmd = 'DCDISPLAY_FINISHED' if s != None: try: s.send(cmd) except: self.restartSocket() return self.action = None mytime.sleep(0.2) one_unit.updateBootloaderDial(self.MAC, '(3) Finished', alwaysUpdate=True) return if self.updateDisplayState == stateFinishedFailed: one_unit.updateBootloaderDial(self.MAC, '(3) Failed', alwaysUpdate=False) print mytime.displayTime(), 'Failed to upload display files.' s.settimeout(0.5) cmd = 'DCDISPLAY_FINISHED' if s != None: try: s.send(cmd) except: self.restartSocket() return self.action = None return return def startUpdateDisplay(self): print mytime.displayTime(), 'd_p.startUpdateDisplay' try: if self.action == None: print mytime.displayTime() + ' d_p.Starting Display Update' self.action = 'update_display' self.completion = 0 self.updateDisplayState = 0 self.updateDisplayFileList = [] except: traceback.print_exc(file=sys.stdout) return def MakeImage(self): self.replyTime = mytime.clock() self.loopTime = 0 self.replyDelay = 0 try: if self.action == None: print mytime.displayTime() + ' d_p.Starting Make Image' self.action = 'make_image' self.completion = 0 self.started_read_image = False except: traceback.print_exc(file=sys.stdout) return def SetPower(self, state): hwstatskey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_HARDWARE_STATUS_FLAGS, 0, 0) try: hwstatsval = int(self.conn.values[hwstatskey].read_val) except: hwstatsval = None try: if state == True: if hwstatsval: hwstatsval |= protocol.confStandby self.conn.set_by_key(hwstatskey, hwstatsval) key = data_model.Key(protocol.STRUCT_ID_COMMAND, protocol.MEMBER_ID_COMMAND, 0, protocol.cmdExitStandby) self.conn.set_by_key(key, 1) retry = 0 while self.conn.synced == False and retry < 100: mytime.sleep(0.1) retry += 1 wait = 0 while wait < 10: mytime.sleep(0.05) wait += 1 self.conn.set_by_key(key, 0) wait = 0 while wait < 10: mytime.sleep(0.01) wait += 1 elif hwstatsval: hwstatsval &= 4294967295L ^ protocol.confStandby self.conn.set_by_key(hwstatskey, hwstatsval) key = data_model.Key(protocol.STRUCT_ID_COMMAND, protocol.MEMBER_ID_COMMAND, 0, protocol.cmdGotoStandby) self.conn.set_by_key(key, 1) retry = 0 while self.conn.synced == False and retry < 100: mytime.sleep(0.1) retry += 1 wait = 0 while wait < 10: mytime.sleep(0.05) wait += 1 self.conn.set_by_key(key, 0) wait = 0 while wait < 10: mytime.sleep(0.01) wait += 1 try: del self.conn.values[hwstatskey] except: pass self.conn.get_list.append(hwstatskey) except: traceback.print_exc(file=sys.stdout) return def getModelFirmwareString(self): try: self.model_firmware = 0 key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_MODEL_NUMBER, 0, 0) try: mf = self.parent.peers.units[self.MAC].values[key].read_val if mf > 0: self.model_firmware = mf print mytime.displayTime(), 'd_p.mf 1 OK', mf except: print mytime.displayTime(), 'd_p.mf 1', key, 'not in peers' key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_MODEL_NUMBER, 0, 0) try: mf = self.conn.values[key].read_val if mf > 0: self.model_firmware = mf print mytime.displayTime(), 'd_p.mf 2 OK', mf except: print mytime.displayTime(), 'd_p.mf 2', key, 'not in conn' key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_MODEL_FIRMWARE, 0, 0) try: mf = self.parent.peers.units[self.MAC].values[key].read_val if mf > 0: self.model_firmware = mf print mytime.displayTime(), 'd_p.mf 3 OK', mf except: print mytime.displayTime(), 'd_p.mf 3', key, 'not in peers' key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_MODEL_FIRMWARE, 0, 0) try: mf = self.conn.values[key].read_val if mf > 0: self.model_firmware = mf print mytime.displayTime(), 'd_p.mf 4 OK', mf except: print mytime.displayTime(), 'd_p.mf 4', key, 'not in conn' self.model_firmware_string = '_' + str(self.model_firmware) print mytime.displayTime() + ' Loading diversity', self.model_firmware_string[1:] except: traceback.print_exc(file=sys.stdout) self.model_firmware_string = '' self.model_firmware = 0 print mytime.displayTime(), 'd_p.mf not found, default 0' return def StartMainUpdate(self, ignore): print mytime.displayTime() + ' d_p.Starting Update....' self.get_list = [] if self.action == None: print mytime.displayTime() + ' d_p.smu', self.MAC key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_USER_ACCESS_RIGHTS, 0, 2) key2 = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_ACCESS_RIGHTS, 0, 0) self.ignore_fw_version = ignore self.action = 'start_bootloader' print mytime.displayTime() + ' Starting Bootloader....' else: print mytime.displayTime() + ' Can not start update of', self.MAC + ', current status:', self.action return self.getModelFirmwareString() return def process(self): if self.MAC not in one_unit.app.bootloader_progress: one_unit.app.bootloader_progress[self.MAC] = None if one_unit.app.bootloader_progress[self.MAC] != None: if one_unit.app.bootloader_progress[self.MAC] in ('Starting Main Update', '(2) Initializing Update Mode....') or one_unit.app.bootloader_progress[self.MAC].find('Erasing') >= 0 or one_unit.app.bootloader_progress[self.MAC].find('(2) Uploading') >= 0: print mytime.displayTime(), 'd_p. Restarting Main Update' self.fastUpdate = True self.action = 'start_main_update' if one_unit.app.bootloader_progress[self.MAC] in ('Preparing Flash Image', 'iets anders'): self.action = 'make_image' self.completion = 0 self.started_read_image = False if self.parent.peers.units[self.MAC].link_type == 'USB': self.usb_process() if self.parent.peers.units[self.MAC].link_type == 'Ethernet': print mytime.displayTime() + ' d_p.Starting Ethernet process on ', self.parent.peers.units[self.MAC].IP self.ethernet_process() print mytime.displayTime() + ' d_p.Ethernet process for', self.MAC, 'finished on', self.parent.peers.units[self.MAC].IP if one_unit.app.testpc == True: self.parent.peers.units[self.MAC].name = 'No Name' self.parent.peers.units[self.MAC].link_status = 'disconnected' self.conn.set_aborted = True self.parent.peers.units[self.MAC].IP = 'Offline' self.parent.peers.set_by_key(self.MAC, data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_CHECK_PIN, 0, 0), None) print mytime.displayTime() + ' d_p.Connection with ' + self.MAC + ' Lost' return def get_speed(self): if self.delay < 0.01: return 100 return int(1 / self.delay) def read_image(self, s): if self.started_read_image == False: self.started_read_image = True cmd = 'DCCOPY__FIRMWARE' if s != None: s.send(cmd) mytime.sleep(0.5) if s != None: s.send(cmd) mytime.sleep(0.5) if self.conn.MK2 == True: self.completion = 65536 / 512 s.settimeout(0.5) picversion = self.parent.peers.units[self.MAC].PICVersion.split('.') picversion_int = int(picversion[0]) * 65536 + int(picversion[1]) * 256 + int(picversion[2]) if picversion_int > 198410 or self.conn.MK2 == True: buflen = 512 else: buflen = 32 self.length = one_unit.app.image_filesize[self.MAC] self.filename = one_unit.app.image_filename[self.MAC] block_high = int(self.completion / 256) block_low = self.completion - block_high * 256 start = (self.completion - 1) * buflen end = start + buflen if end >= self.length - 1: last = True cmd = chr(0) + 'Q' + chr(block_high) + chr(block_low) else: last = False cmd = chr(0) + 'R' + chr(block_high) + chr(block_low) nul = '0' * 24 cmd += nul if s != None: s.send(cmd) else: self.action = 'Exit' return if self.completion % 100 == 0: print mytime.displayTime() + ' Sent Read Command for block', self.completion one_unit.updateBootloaderDial(self.MAC, '(2) Copying (' + str(self.completion * 100 / (self.length / buflen)) + '%)', alwaysUpdate=False) start_time = mytime.clock() send_time = mytime.clock() while one_unit.app.application_stopping == False: one_unit.tryYield() try: if s != None: new_pkt = s.recv(4096) except: new_pkt = None if new_pkt != None and len(new_pkt) >= buflen + 3 and ord(new_pkt[0]) == 0 and ord(new_pkt[1]) == 4 and ord(new_pkt[2]) == block_high and ord(new_pkt[3]) == block_low: break if mytime.clock() - send_time > 0.05: send_time = mytime.clock() try: if s != None: s.send(cmd) except: print mytime.displayTime() + ' d_p.ri.Send Failed' traceback.print_exc(file=sys.stdout) if mytime.clock() - start_time > 1: one_unit.tryYield() print mytime.displayTime() + ' d_p.ri.Timeout for block', self.completion, '-> Attempt to reconnect' try: self.ethSocket.close() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(0.5) s.connect((self.IP, 50675)) s.settimeout(0.5) self.ethSocket = s cmd2 = 'DCCOPY__FIRMWARE' if s != None: s.send(cmd2) mytime.sleep(0.2) if s != None: s.send(cmd2) mytime.sleep(0.2) self.ethSocket.send(cmd) continue except: print mytime.displayTime() + ' d_p.ri.TCP/IP Reconnection of ' + self.MAC + ' to ' + self.IP + ' Failed for block', self.completion mytime.sleep(0.5) else: one_unit.tryYield() if mytime.clock() - start_time > 30: one_unit.tryYield() print mytime.displayTime() + ' d_p.ri.Timeout for block', self.completion, '-> aborting (reconenction attempts failed)' mytime.sleep(0.5) self.action = 'Exit' one_unit.updateBootloaderDial(self.MAC, '(2) Flash Image Failed!') return if new_pkt != None and len(new_pkt) >= buflen + 5 and ord(new_pkt[0]) == 0 and ord(new_pkt[1]) == 4 and ord(new_pkt[2]) == block_high and ord(new_pkt[3]) == block_low: checksum = 170 for i in range(4, buflen + 4): checksum ^= ord(new_pkt[i]) if checksum != ord(new_pkt[buflen + 4]): print mytime.displayTime() + ' d_p.checksum failed, Retry packet', self.completion, checksum, ord(new_pkt[buflen + 4]), buflen if new_pkt != None: sv = 'Packet: ' for c in new_pkt: sv += ':' + hex(ord(c)) print sv return if self.completion == 0 or self.completion == 65536 / 512 and self.conn.MK2 == True: try: os.remove(self.filename) except: pass else: try: self.target_file = open(self.filename, 'wb') except: print mytime.displayTime() + ' Failed to open target file' one_unit.updateBootloaderDial(self.MAC, 'File Error') self.action = 'Exit' return else: try: print mytime.displayTime() + ' Opened target file', self.filename, 'for writing', self.length, 'bytes' except: pass else: self.update_start_time = mytime.clock() if self.completion > 0 or self.conn.MK2 == True: self.target_file.write(new_pkt[4:-1]) self.completion += 1 one_unit.tryYield() if last == True: print mytime.displayTime() + ' Finished copy of', self.MAC, 'in', round(mytime.clock() - self.update_start_time, 1), 'seconds' self.action = 'Exit' self.target_file.close() mytime.sleep(1.1) one_unit.updateBootloaderDial(self.MAC, 'Compacting...') one_unit.tryYield() try: if self.conn.MK2 == True: sectorSize = one_unit.app.image_sector_size[self.MAC] slotSize = one_unit.app.image_slot_size[self.MAC] flashDiskStartAddress = one_unit.app.image_start_address[self.MAC] - one_unit.app.update_image_start_address[self.MAC] try: print mytime.displayTime(), 'd_p.check clean', self.filename, slotSize, flashDiskStartAddress, sectorSize except: pass else: if sectorSize != None and slotSize != None: cleanImage.cleanImage(self.filename, self.filename, 1, flashDiskStartAddress, sectorSize, 50) cmd = 'DCRESARTFIRMWARE' if s != None: try: s.send(cmd) except: pass self.conn.got_basic_info = False zfile = zipfile.ZipFile(self.filename + 'zip', 'w') zfile.write(self.filename, os.path.split(self.filename)[1], compress_type=zipfile.ZIP_DEFLATED) try: type = self.parent.peers.units[self.MAC].type + '_' + str(self.conn.model_number) except: type = 'Unknown' type = encode(type, 'djkfhnsakdjvdlkf') zfile.writestr('/info.lst', type) zfile.close() os.remove(self.filename) os.rename(self.filename + 'zip', self.filename) try: print mytime.displayTime() + ' Closed target file', self.filename except: pass mytime.sleep(1.1) one_unit.updateBootloaderDial(self.MAC, 'Restarting...') one_unit.tryYield() except: print mytime.displayTime(), 'd_p.ri.problem in file operation' traceback.print_exc(file=sys.stdout) one_unit.updateBootloaderDial(self.MAC, 'Create Flash Image Failed, file access problem') one_unit.tryYield() return def verifyNIC(self): numberOfNIC = 0 retry = 5 while retry > 0: try: one_unit.check_interfaces() except: traceback.print_exc(file=sys.stdout) for adapter in one_unit.app.LAN_adapters: if one_unit.app.LAN_adapters[adapter].IPv4 not in ('none', 'None', None) or one_unit.app.LAN_adapters[adapter].IPv6 not in ('none', 'None', None): numberOfNIC += 1 print mytime.displayTime(), 'd_p.vN.Verify NIC: Counted', numberOfNIC, 'network ports' if numberOfNIC == 1: break retry -= 1 mytime.sleep(0.1) return numberOfNIC def start_bootloader(self, s): print mytime.displayTime() + ' d_p.start_bootloader 1' if self.action == 'start_bootloader': self.parent.peers.units[self.MAC].preset_names = {} self.parent.peers.units[self.MAC].values = {} key2 = data_model.Key(protocol.STRUCT_ID_COMMAND, protocol.MEMBER_ID_COMMAND, 0, protocol.cmdGotoStandby) print mytime.displayTime() + ' d_p.sb.Setting Hardware to standby...' self.conn.set_by_key(key2, 1) self.start_bootloader_time = mytime.clock() one_unit.updateBootloaderDial(self.MAC, getString('sts'), statusInfo=one_unit.app.bootloaderStatus[self.MAC] | infoStatusSettingToStandby) print mytime.displayTime() + ' d_p.sb.Setting to Standby' self.action = 'start bootloader standby delay' mytime.sleep(0.1) return else: if one_unit.app.bootloader_mode == True: self.action = 'start_main_update' mytime.sleep(0.1) return if self.parent.peers.units[self.MAC].link_type == 'USB': self.action = 'start_main_update' mytime.sleep(0.1) return version = one_unit.app.Version try: version = one_unit.app.pic_version except: print mytime.displayTime() + ' Default interface version not found' try: version = one_unit.app.pic_versions[self.parent.peers.units[self.MAC].type] except: pass if self.parent.peers.units[self.MAC].PICVersion == version: one_unit.updateBootloaderDial(self.MAC, getString('vfv'), statusInfo=infoStatusVerifyingFirmwareVersion | infoStatusInterfaceUpdate | infoStatusRunning) mytime.sleep(1) one_unit.tryYield() mytime.sleep(1) one_unit.tryYield() print mytime.displayTime() + ' Interface up-to-date, version', version self.action = 'start_main_update' return if one_unit.app.updating_all == True or one_unit.app.interfaceUpdate[self.MAC] == False: one_unit.updateBootloaderDial(self.MAC, 'Ignoring Interface') print mytime.displayTime() + ' Ignoring Interface version, found version ', self.parent.peers.units[self.MAC].PICVersion self.action = 'start_main_update' return if one_unit.app.bootloader_ok == False and self.conn.MK2 == False: one_unit.app.enable_bootloader = False self.action = None print mytime.displayTime() + ' Bootloader server not running, aborting' one_unit.updateBootloaderDial(self.MAC, None) wx.MessageBox('Error: unable to access network port. This may be caused by an internal computer error. Please restart your system.') return if self.conn.MK2 == True: one_unit.app.enable_bootloader = False self.action = 'start_main_update' one_unit.updateBootloaderDial(self.MAC, None) return no_of_interfaces = self.verifyNIC() if no_of_interfaces > 1: print mytime.displayTime(), 'Verify NIC failed:', no_of_interfaces res = wx.MessageBox('Error: Multiple active network ports. The network interface update will be skipped.', 'Multiple NIC detected', wx.OK) one_unit.app.enable_bootloader = False self.action = 'start_main_update' one_unit.updateBootloaderDial(self.MAC, None) return if no_of_interfaces == 0: print mytime.displayTime(), 'Verify NIC failed:', no_of_interfaces res = wx.MessageBox('Warning: Could not detect active network ports. Please make sure one and only one network port is active for this update.', 'No NIC detected', wx.OK) print mytime.displayTime() + ' Updating Interface from', self.parent.peers.units[self.MAC].PICVersion, 'to', version one_unit.app.enable_bootloader = True if self.action == 'start bootloader standby delay': if one_unit.app.interfaceUpdate[self.MAC] == True: if one_unit.app.bootloaderStatus['Bootloader'] & infoStatusProgressMask != infoStatusStart: print mytime.displayTime(), 'd_p.Bootloader running, exiting', hex(one_unit.app.bootloaderStatus['Bootloader']) self.action = 'Exit' return cmd = 'DDReset_Interface' one_unit.updateBootloaderDial(self.MAC, getString('vfv'), statusInfo=infoStatusInterfaceUpdate | infoStatusRunning) mytime.sleep(1) one_unit.tryYield() start_time = mytime.clock() interval = 0 while one_unit.app.application_stopping == False: print mytime.displayTime(), 'd_p.reset interface looping' mytime.sleep(0.1) if interval % 30 == 0: tmpLoop = 10 while tmpLoop > 0: tmpLoop -= 1 try: s.send(cmd) print mytime.displayTime(), 'd_p.reset interface command sent' except: self.action = 'wait_for_bootloader' try: s.close() except: pass return interval += 1 try: if one_unit.app.bootloaderStatus['Bootloader'] & (infoStatusProcessmask | infoStatusResetOK) == infoStatusInterfaceUpdate | infoStatusResetOK: self.action = 'wait_for_bootloader' return except: pass if mytime.clock() - start_time > 25: print mytime.displayTime() + ' d_p.sb.Reset Timeout' one_unit.updateBootloaderDial(self.MAC, 'Please power cycle the unit.') break else: self.action = 'start_main_update' return def getFirmwareFile(self): try: self.conn.MK2 = one_unit.app.MK2[self.MAC] print mytime.displayTime(), 'd_p.gFF.set MK2 from app for', self.MAC, self.conn.MK2 except: pass try: if self.conn.MK2 == True and self.parent.peers.units[self.MAC].link_type == 'Ethernet': extension = 'dfu' else: extension = 'dfi' self.broadcasted_skin = self.parent.peers.units[self.MAC].type try: model_firmware_string = one_unit.app.lastModelFirmwareString[self.MAC] print mytime.displayTime(), 'd_p.gFF.mf from app', model_firmware_string fName = one_unit.app.cwd + '/dfi/' + self.broadcasted_skin + model_firmware_string + '.' + extension datafile = open(os.path.normpath(fName), 'rb') self.data = datafile.read() datafile.close() self.model_firmware_string = model_firmware_string print mytime.displayTime() + ' Found', fName return except: pass model_firmware_string = '' self.getModelFirmwareString() try: model_firmware_string = self.model_firmware_string fName = one_unit.app.cwd + '/dfi/' + self.broadcasted_skin + model_firmware_string + '.' + extension print mytime.displayTime(), 'd_p.gFF.full file name:', self.broadcasted_skin + model_firmware_string + '.' + extension datafile = open(os.path.normpath(fName), 'rb') self.data = datafile.read() datafile.close() print mytime.displayTime() + ' d_p.Found', fName one_unit.app.lastModelFirmwareString[self.MAC] = model_firmware_string except: print mytime.displayTime() + ' d_p.Not Found: ', one_unit.app.cwd + '/dfi/' + self.broadcasted_skin + model_firmware_string + '.' + extension try: if model_firmware_string == '': print mytime.displayTime() + ' Trying model 0' model_firmware_string = '_0' else: print mytime.displayTime() + ' Trying without model number' model_firmware_string = '' fName = one_unit.app.cwd + '/dfi/' + self.broadcasted_skin + model_firmware_string + '.' + extension datafile = open(os.path.normpath(fName), 'rb') self.data = datafile.read() datafile.close() self.model_firmware_string = model_firmware_string print mytime.displayTime() + ' Found', fName one_unit.app.lastModelFirmwareString[self.MAC] = model_firmware_string except: print mytime.displayTime() + ' Not Found: ', one_unit.app.cwd + '/dfi/' + self.broadcasted_skin + model_firmware_string + '.' + extension try: print mytime.displayTime() + ' Trying model 0' model_firmware_string = '_0' datafile = open(os.path.normpath(one_unit.app.cwd + '/dfi/' + self.broadcasted_skin + model_firmware_string + '.' + extension), 'rb') self.data = datafile.read() datafile.close() self.model_firmware_string = model_firmware_string print mytime.displayTime() + ' Found', one_unit.app.cwd + '/dfi/' + self.broadcasted_skin + model_firmware_string + '.' + extension except: found_fw = False print mytime.displayTime() + ' Not Found: ', one_unit.app.cwd + '/dfi/' + self.broadcasted_skin + model_firmware_string + '.' + extension print mytime.displayTime() + ' Trying to find matching firmware....' for testfw in range(100): if os.path.exists(os.path.normpath(one_unit.app.cwd + '/dfi/' + self.broadcasted_skin + '_' + str(testfw) + '.' + extension)): self.model_firmware_string = '_' + str(testfw) print mytime.displayTime() + ' Found ', one_unit.app.cwd + '/dfi/' + self.broadcasted_skin + self.model_firmware_string + '.' + extension found_fw = True one_unit.app.lastModelFirmwareString[self.MAC] = model_firmware_string break if found_fw == False: self.data = '' print mytime.displayTime() + ' Unsupported hardware type 1:', self.broadcasted_skin self.action = None one_unit.updateBootloaderDial(self.MAC, '(2) Unsupported Type') return except: traceback.print_exc(file=sys.stdout) return def upload_main_firmware(self, s, ser=None): if one_unit.app.interfaceUpdate[self.MAC] == True or one_unit.app.application_stopping == True: self.action = None return else: try: if int(self.parent.peers.units[self.MAC].HWVersion[0]) == 3 and int(self.parent.peers.units[self.MAC].HWVersion[2]) == 6 and self.parent.peers.units[self.MAC].link_type == 'Ethernet' and int(self.parent.peers.units[self.MAC].HWVersion[4]) <= 4: self.action = None one_unit.updateBootloaderDial(self.MAC, 'USB Update Only') print mytime.displayTime(), 'd_p. HW too old for Ethernet update, HW version', self.parent.peers.units[self.MAC].HWVersion return except: pass if self.parent.peers.units[self.MAC].link_type == 'Ethernet': try: s.settimeout(0.03) except: pass picversion = self.parent.peers.units[self.MAC].PICVersion.split('.') picversion_int = int(picversion[0]) * 65536 + int(picversion[1]) * 256 + int(picversion[2]) if self.conn.MK2 == True and self.parent.peers.units[self.MAC].link_type == 'Ethernet': extension = 'dfu' else: extension = 'dfi' if picversion_int > 198410 or self.conn.MK2 == True: buflen = 512 else: buflen = 32 try: self.length = len(self.data) / buflen except: pass if self.action == 'start_main_update': if one_unit.app.image_filename[self.MAC] == None: self.getFirmwareFile() self.length = len(self.data) / buflen if one_unit.app.bootloader_mode == True: start_time = mytime.clock() while True: if mytime.clock() - start_time > 10: one_unit.updateBootloaderDial(self.MAC, 'FAIL') self.action = None return DSPState = self.parent.peers.units[self.MAC].DSPState if DSPState != None: if DSPState == 1: one_unit.updateBootloaderDial(self.MAC, 'PASS') self.action = None return if DSPState != 67 and self.action == 'start_main_update': print mytime.displayTime() + ' Blank Device' break else: mytime.sleep(0.1) continue else: version = one_unit.app.Version try: version = one_unit.app.fw_version except: print mytime.displayTime() + ' Default firmware version not found' else: try: version = one_unit.app.fw_versions[self.parent.peers.units[self.MAC].type] except: pass else: if self.parent.peers.units[self.MAC].FWVersion == version and self.ignore_fw_version != 'i': one_unit.updateBootloaderDial(self.MAC, 'Firmware OK') print mytime.displayTime() + ' Firmware up-to-date, version', version self.action = None return print mytime.displayTime() + ' Updating Main Firmware of', self.MAC, 'from', self.parent.peers.units[self.MAC].FWVersion, 'to', version self.parent.peers.clear_preset_names(self.MAC) self.parent.peers.units[self.MAC].values = {} self.parent.peers.units[self.MAC].link_status = 'Updating Firmware' self.update_start_time = mytime.clock() cmd = 'DDUPLOADFIRMWARE' self.conn.got_basic_info = False print mytime.displayTime() + ' d_p.Initiating Firmware Update Mode' if one_unit.app.image_filename[self.MAC] == None: one_unit.updateBootloaderDial(self.MAC, '(2) Initializing Update Mode....') else: one_unit.updateBootloaderDial(self.MAC, '(2) Initializing Flash Load....') if s != None: s.send(cmd) else: try: ser.write(cmd) except: print mytime.displayTime() + ' Connection Interrupted' self.action = None one_unit.updateBootloaderDial(self.MAC, '(2) Failed!') return mytime.sleep(0.1) if s != None: s.send(cmd) else: try: ser.write(cmd) except: print mytime.displayTime() + ' Connection Interrupted' self.action = None one_unit.updateBootloaderDial(self.MAC, '(2) Failed!') return mytime.sleep(0.1) if s != None: s.send(cmd) else: try: ser.write(cmd) except: print mytime.displayTime() + ' Connection Interrupted' self.action = None one_unit.updateBootloaderDial(self.MAC, '(2) Failed!') return if one_unit.app.image_filename[self.MAC] != None: print mytime.displayTime() + ' d_p.umf.Loading Flash Image File into', self.MAC else: print mytime.displayTime() + ' d_p.umf.Starting Main Firmware Update of', self.MAC self.completion = 'erasing' mytime.sleep(0.1) start_time = mytime.clock() startUpdateLinkCounter = 0 while one_unit.app.application_stopping == False: try: if s != None: if self.conn.MK2 == True: s.send(cmd) mytime.sleep(0.1) startUpdateLinkCounter += 1 print mytime.displayTime() + ' d_p.smu.counting', startUpdateLinkCounter, startUpdateLinkCounter % 30 if startUpdateLinkCounter % 5 == 0: print mytime.displayTime(), 'Resetting connection 4.0' try: self.ethSocket.close() s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(2) s.connect((self.IP, 50675)) s.settimeout(0.5) self.ethSocket = s self.ethSocket.send(cmd) print mytime.displayTime() + ' d_p.ep.Reconnected', self.MAC, 'to', self.IP continue except: print mytime.displayTime() + ' d_p.ep.TCP/IP Reconnection of ' + self.MAC + ' to ' + self.IP + ' Failed' mytime.sleep(0.1) continue new_pkt = s.recv(4096) else: l = ser.inWaiting() if l > 0: new_pkt = ser.read(l) else: new_pkt = None except: mytime.sleep(0.1) new_pkt = None if new_pkt != None and len(new_pkt) > 7: print mytime.displayTime() + ' Update Link -> Got packet:', readableHEX(new_pkt[:20]) break one_unit.tryYield() if mytime.clock() - start_time > 30: new_pkt = None self.action = None print mytime.displayTime() + ' Set Hardware to Update mode: Link Timeout' one_unit.updateBootloaderDial(self.MAC, '(2) Failed!') one_unit.app.image_filename[self.MAC] = None return if one_unit.app.application_stopping: return one_unit.tryYield() if ord(new_pkt[0]) == 0 and ord(new_pkt[1]) == 1 and ord(new_pkt[2]) == 66 and ord(new_pkt[3]) == 76: skin_high = unicode(ord(new_pkt[4])) skin_mid = unicode(ord(new_pkt[5])) skin_low = unicode(ord(new_pkt[6])) self.broadcasted_skin = skin_high + '_' + skin_mid + '_' + skin_low try: self.broadcasted_skin = one_unit.app.type_replacements[self.broadcasted_skin] except: pass else: if self.broadcasted_skin == self.parent.peers.units[self.MAC].type: self.action = 'updating_main_firmware' self.completion = 'erasing' print mytime.displayTime() + ' d_p.Update Link Established' if s != None: s.settimeout(0.5) loop = 20 while loop > 0: loop -= 1 try: new_pkt = s.recv(4096) except: pass s.settimeout(0.5) print mytime.displayTime() + ' d_p.going to Erase mode' return else: print mytime.displayTime() + ' d_p.Broadcasted skin does not match unit type, got', self.broadcasted_skin, 'but unit type is', self.parent.peers.units[self.MAC].type one_unit.app.image_filename[self.MAC] = None return elif self.action == 'updating_main_firmware': if self.completion == 'erasing': if s != None: try: s.settimeout(0.5) except: try: s.close() except: pass else: try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(0.5) s.connect((self.IP, 50675)) s.settimeout(0.5) self.ethSocket = s print mytime.displayTime(), 'd_p.umf.12.TCP/IP Connection restored' except: print mytime.displayTime() + ' d_p.umf.12.TCP/IP Connection of ' + self.MAC + ' to ' + self.IP + ' Failed' return else: loop = 2 while loop > 0: loop -= 1 try: new_pkt = s.recv(4096) except: pass print mytime.displayTime(), 'd_p.umf.2' counter = 0 erasecounter = 0 one_unit.tryYield() if False: cmd = chr(0) + chr(2) + 'dfdg_dfv' + chr(0) + 'netascii' + chr(0) print mytime.displayTime() + ' d_p.partial erase!!!!!!!' else: cmd = chr(0) + chr(2) + 'dddd.dfi' + chr(0) + 'netascii' + chr(0) print mytime.displayTime() + ' d_p.full erase' if s != None: try: s.send(cmd) except: self.action = 'Exit' print mytime.displayTime() + ' d_p.umf.s.send failed' traceback.print_exc(file=sys.stdout) return else: try: ser.write(cmd) except: print mytime.displayTime() + ' Connection Interrupted' self.action = None one_unit.updateBootloaderDial(self.MAC, '(2) Failed!') one_unit.app.image_filename[self.MAC] = None return timeout = 60 if one_unit.app.image_filesize[self.MAC] >= 4194304: timeout = 90 if one_unit.app.image_filesize[self.MAC] >= 8388608: timeout = 180 if self.conn.MK2 == False and self.parent.peers.units[self.MAC].link_type == 'Ethernet': timeout = 10 print mytime.displayTime() + ' Erasing', self.MAC, 'with timeout', timeout one_unit.updateBootloaderDial(self.MAC, '(2) Erasing....') one_unit.tryYield() mytime.sleep(0.1) new_pkt = None start_time = mytime.clock() while one_unit.app.application_stopping == False: one_unit.tryYield() mytime.sleep(0.01) try: if s != None: new_pkt = s.recv(4096) else: l = ser.inWaiting() if l > 0: l = ser.inWaiting() new_pkt = ser.read(l) else: new_pkt = None mytime.sleep(1) erasecounter += 1 except: mytime.sleep(1) erasecounter += 1 one_unit.tryYield() new_pkt = None one_unit.updateBootloaderDial(self.MAC, '(2) Erasing, less than ' + str(timeout - erasecounter) + ' seconds remaining', alwaysUpdate=False) if new_pkt != None: print mytime.displayTime() + ' Erase -> Got packet (' + str(len(new_pkt)) + ' bytes):', readableHEX(new_pkt) if len(new_pkt) > 2 and ord(new_pkt[0]) == 0 and ord(new_pkt[1]) == 4: break if len(new_pkt) == 8 and ord(new_pkt[0]) == 0 and ord(new_pkt[1]) == 1 and ord(new_pkt[2]) == 66 and ord(new_pkt[3]) == 76: if False: cmd = chr(0) + chr(2) + 'dfdg_dfv' + chr(0) + 'netascii' + chr(0) print mytime.displayTime() + ' d_p. resend partial erase!!!!!!!' else: cmd = chr(0) + chr(2) + 'dddd.dfi' + chr(0) + 'netascii' + chr(0) print mytime.displayTime() + ' d_p. resend full erase' if s != None: try: s.send(cmd) except: self.action = 'Exit' print mytime.displayTime() + ' d_p.umf.s.send failed' traceback.print_exc(file=sys.stdout) return else: try: ser.write(cmd) except: print mytime.displayTime() + ' Connection Interrupted' self.action = None one_unit.updateBootloaderDial(self.MAC, '(2) Failed!') one_unit.app.image_filename[self.MAC] = None return if len(new_pkt) == 0: print mytime.displayTime(), 'd_p. nul bytes packet, wat gaan we doen? -> reset connection and start_main_update' self.action = 'start_main_update' s.close() try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(0.5) s.connect((self.IP, 50675)) s.settimeout(0.5) self.ethSocket = s print mytime.displayTime(), 'd_p.umf.1.TCP/IP Connection restored' except: print mytime.displayTime() + ' d_p.umf.1.TCP/IP Connection of ' + self.MAC + ' to ' + self.IP + ' Failed' return if mytime.clock() - start_time < 5 and new_pkt != None and len(new_pkt) == 0: print mytime.displayTime() + ' Resending Erase command...' if s != None: s.send(cmd) else: try: ser.write(cmd) except: print mytime.displayTime() + ' Connection Interrupted' self.action = None one_unit.updateBootloaderDial(self.MAC, '(2) Failed!') one_unit.app.image_filename[self.MAC] = None return mytime.sleep(1) if mytime.clock() - start_time > timeout: print mytime.displayTime() + ' Erase Timeout' one_unit.updateBootloaderDial(self.MAC, '(2) Erase Failed (1)!') self.action = None one_unit.app.image_filename[self.MAC] = None break if new_pkt != None and len(new_pkt) > 2 and ord(new_pkt[0]) == 0 and ord(new_pkt[1]) == 4: print mytime.displayTime() + ' d_p.Erase OK, erase tijd:', mytime.clock() - start_time one_unit.updateBootloaderDial(self.MAC, '(2) Erase OK') resend_counter = 0 if s != None: s.settimeout(0.5) loop = 20 while loop > 0: one_unit.tryYield() loop -= 1 try: new_pkt = s.recv(4096) except: pass s.settimeout(0.5) self.completion = 1 model_firmware_string = '' if one_unit.app.image_filename[self.MAC] != None: datafile = open(one_unit.app.image_filename[self.MAC], 'rb') self.data = datafile.read()[:one_unit.app.image_filesize[self.MAC]] datafile.close() try: print mytime.displayTime() + ' Starting upload of', one_unit.app.image_filename[self.MAC], 'to', self.MAC except: pass else: try: model_firmware_string = self.model_firmware_string datafile = open(os.path.normpath(one_unit.app.cwd + '/dfi/' + self.broadcasted_skin + model_firmware_string + '.' + extension), 'rb') self.data = datafile.read() datafile.close() try: print mytime.displayTime() + ' Starting upload of', self.broadcasted_skin + model_firmware_string + '.' + extension + ' to', self.MAC except: pass except: try: print mytime.displayTime() + ' Not found:', self.broadcasted_skin + model_firmware_string if model_firmware_string == '': model_firmware_string = '_0' else: model_firmware_string = '' print mytime.displayTime() + ' Trying:', self.broadcasted_skin + model_firmware_string datafile = open(os.path.normpath(one_unit.app.cwd + '/dfi/' + self.broadcasted_skin + model_firmware_string + '.' + extension), 'rb') self.data = datafile.read() datafile.close() try: print mytime.displayTime() + ' Starting upload of', self.broadcasted_skin + model_firmware_string + '.' + extension + ' to', self.MAC except: pass except: self.data = '' print mytime.displayTime() + ' Unsupported hardware type 2:', self.broadcasted_skin + self.model_firmware_string self.action = None one_unit.updateBootloaderDial(self.MAC, '(2) Unsupported Type') one_unit.app.image_filename[self.MAC] = None return self.length = len(self.data) / buflen elif new_pkt != None: print mytime.displayTime() + ' Got invalid packet:', print [_[1] for i in new_pkt] one_unit.updateBootloaderDial(self.MAC, '(2) Erase Failed!') if s != None and self.conn.MK2 == True: try: cmd = chr(0) + chr(7) + chr(0) + chr(0) nul = '0' * buflen cmd += nul cmd = cmd[:buflen + 4] s.send(cmd) except: print mytime.displayTime(), 'd_p.umf.Sending Abort command failed' traceback.print_exc(file=sys.stdout) self.action = None one_unit.app.image_filename[self.MAC] = None return one_unit.tryYield() page_empty = False while one_unit.app.application_stopping == False: if self.conn.MK2 == True: block_high = int((self.completion - 1) / 256) block_low = self.completion - 1 - block_high * 256 else: block_high = int(self.completion / 256) block_low = self.completion - block_high * 256 start = (self.completion - 1) * buflen end = start + buflen page_empty = True if end >= len(self.data) - 1: break for i in range(0, buflen): if ord(self.data[start + i]) != 255: page_empty = False break if page_empty and self.completion < self.length: self.completion += 1 else: break if end >= len(self.data) - 1: print mytime.displayTime() + ' Last Packet', self.completion, 'of', self.length, 'data length:', len(self.data), 'bytes' last = True cmd = chr(0) + chr(7) + chr(block_high) + chr(block_low) + self.data[start:] nul = '0' * buflen cmd += nul cmd = cmd[:buflen + 4] else: last = False cmd = chr(0) + chr(3) + chr(block_high) + chr(block_low) + self.data[start:end] if s != None: try: s.send(cmd) except: traceback.print_exc(file=sys.stdout) else: try: ser.write(cmd) except: print mytime.displayTime() + ' Connection Interrupted' self.action = None one_unit.updateBootloaderDial(self.MAC, '(2) Failed!') one_unit.app.image_filename[self.MAC] = None return percent_completion = self.completion * 100 / self.length if percent_completion > 100: percent_completion = 100 one_unit.updateBootloaderDial(self.MAC, '(2) Uploading packet ' + str(self.completion) + ' of ' + str(self.length + 1) + ' (' + str(percent_completion) + '%)', alwaysUpdate=False) one_unit.tryYield() if mytime.clock() - self.lastPrintTime > 0: print mytime.displayTime() + ' (2) Uploading (' + str(percent_completion) + '%)', self.completion - 1, 'of', self.length self.lastPrintTime = mytime.clock() start_time = mytime.clock() send_time = mytime.clock() resend_counter = 0 while one_unit.app.application_stopping == False: try: if s != None: new_pkt = s.recv(4096) else: l = ser.inWaiting() if l > 0: new_pkt = ser.read(l) else: new_pkt = ' ' except: new_pkt = None if new_pkt != None and len(new_pkt) >= buflen + 3 and ord(new_pkt[0]) == 0 and ord(new_pkt[1]) == 4 and ord(new_pkt[2]) == block_high and ord(new_pkt[3]) == block_low: break elif self.parent.peers.units[self.MAC].link_type == 'Ethernet': print mytime.displayTime() + ' Uploading -> Got invalid packet for block', self.completion, ' (' + str(len(new_pkt)) + ' bytes):', readableHEX(new_pkt[:20]) mytime.sleep(0.1) if last == True: if self.parent.peers.units[self.MAC].PICVersion == '3.8.2': print mytime.displayTime(), 'Exiting, seems to be finished....' print mytime.displayTime() + ' Finished update of', self.MAC, 'in', round(mytime.clock() - self.update_start_time, 1), 'seconds (last packet timeout)' print mytime.displayTime() + ' Total time:', round(mytime.clock() - self.start_bootloader_time, 1), 'seconds' one_unit.updateBootloaderDial(self.MAC, 'Finished') if one_unit.app.image_filename[self.MAC].endswith('ffii'): os.remove(one_unit.app.image_filename[self.MAC]) self.action = 'Exit' one_unit.tryYield() mytime.sleep(0.1) one_unit.tryYield() return if len(new_pkt) > 4 and new_pkt[:2] == 'DD': self.action = 'Exit' one_unit.updateBootloaderDial(self.MAC, '(2) Failed!') print mytime.displayTime(), 'd_p.Got DD packet, exiting' return if (last == False or self.conn.MK2 == True) and (mytime.clock() - send_time > 0.5 or self.conn.MK2 == True and new_pkt != None and len(new_pkt) == 0): one_unit.tryYield() send_time = mytime.clock() try: if self.conn.MK2 == True and (resend_counter > 5 or new_pkt != None and len(new_pkt) == 0): print mytime.displayTime() + ' d_p.umf.Resetting Connection 3.0' resend_counter = 0 s.close() try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(0.5) s.connect((self.IP, 50675)) s.settimeout(0.5) self.ethSocket = s print mytime.displayTime() + ' d_p.umf.Connection opened' except: print mytime.displayTime() + ' d_p.umf.1.TCP/IP Connection of ' + self.MAC + ' to ' + self.IP + ' Failed' else: print mytime.displayTime() + ' d_p.umf.No response, Resending block', self.completion resend_counter += 1 if s != None: s.send(cmd) else: ser.write(cmd) except: print mytime.displayTime() + ' d_p.Send Failed (1)' traceback.print_exc(file=sys.stdout) try: s.connect((self.IP, 50675)) except: print mytime.displayTime() + ' d_p.umf.2.TCP/IP Connection of ' + self.MAC + ' to ' + self.IP + ' Failed' self.action = 'Exit' one_unit.updateBootloaderDial(self.MAC, '(2) Failed!') return else: mytime.sleep(0.1) if mytime.clock() - start_time > 30: one_unit.tryYield() print mytime.displayTime() + ' Timeout! last:', last, 'MK2:', self.conn.MK2, 'send delay:', mytime.clock() - send_time, 'new packet:', new_pkt mytime.sleep(0.5) self.action = 'Exit' one_unit.updateBootloaderDial(self.MAC, '(2) Failed!') if s != None: try: cmd = chr(0) + chr(7) + chr(0) + chr(0) nul = '0' * buflen cmd += nul cmd = cmd[:buflen + 4] s.send(cmd) except: print mytime.displayTime(), 'd_p.umf.Sending Abort command failed' traceback.print_exc(file=sys.stdout) one_unit.app.image_filename[self.MAC] = None if s != None: s.settimeout(1) return if last == True and mytime.clock() - start_time > 2: one_unit.tryYield() print mytime.displayTime() + ' Finished update of', self.MAC, 'in', round(mytime.clock() - self.update_start_time, 1), 'seconds (last packet timeout)' print mytime.displayTime() + ' Total time:', round(mytime.clock() - self.start_bootloader_time, 1), 'seconds' one_unit.updateBootloaderDial(self.MAC, 'Finished') if self.MAC in one_unit.app.image_filename and str(one_unit.app.image_filename[self.MAC]).endswith('ffii'): os.remove(one_unit.app.image_filename[self.MAC]) self.action = 'Exit' try: ser.close() if os.name not in mac_names: mytime.sleep(3) d_usb.RestartDevice(self.parent.peers.units[self.MAC].InstanceId) except: pass if s != None and self.conn.MK2 == True: loop = 5 while loop > 0: print mytime.displayTime(), 'Restarting Firmware (1)...', loop loop -= 1 cmd = 'DCRESARTFIRMWARE' try: s.send(cmd) except: break mytime.sleep(0.1) mytime.sleep(0.1) if s != None: s.settimeout(1) return if new_pkt != None and len(new_pkt) >= buflen + 3 and ord(new_pkt[0]) == 0 and ord(new_pkt[1]) == 4 and ord(new_pkt[2]) == block_high and ord(new_pkt[3]) == block_low: one_unit.tryYield() verify_ok = True for i in range(len(cmd)): if i < 4: continue if cmd[i] != new_pkt[i]: print mytime.displayTime(), 'd_p.Packet verification failed, packet', self.completion, 'byte', i, 'memory location', self.completion * buflen, 'should be', hex(ord(cmd[i])), 'but reads', hex(ord(new_pkt[i])) verify_ok = False break if verify_ok == True: self.fw_retry_counter = 0 if last == True: print mytime.displayTime() + ' verify OK for block', self.completion, 'of', self.length + 1, 'return time:', mytime.clock() - send_time self.completion += 1 if last == True: print mytime.displayTime() + ' Finished update of', self.MAC, 'in', round(mytime.clock() - self.update_start_time, 1), 'seconds (verify OK)' print mytime.displayTime() + ' Total time:', round(mytime.clock() - self.start_bootloader_time, 1), 'seconds' one_unit.updateBootloaderDial(self.MAC, 'Finished') if self.conn.MK2 == True: loop = 5 while loop > 0: print mytime.displayTime(), 'Restarting Firmware (2)...', loop loop -= 1 cmd = 'DCRESARTFIRMWARE' try: s.send(cmd) except: break mytime.sleep(0.1) self.action = 'Exit' try: ser.close() if os.name not in mac_names: mytime.sleep(3) d_usb.RestartDevice(self.parent.peers.units[self.MAC].InstanceId) except: pass else: mytime.sleep(0.1) else: one_unit.tryYield() self.fw_retry_counter += 1 mytime.sleep(0.1) if self.fw_retry_counter > 10: one_unit.updateBootloaderDial(self.MAC, '(2) Failed!') if s != None and self.conn.MK2 == True: try: cmd = chr(0) + chr(7) + chr(0) + chr(0) nul = '0' * buflen cmd += nul cmd = cmd[:buflen + 4] s.send(cmd) except: print mytime.displayTime(), 'd_p.umf.Sending Abort command failed' traceback.print_exc(file=sys.stdout) one_unit.app.image_filename[self.MAC] = None print mytime.displayTime() + ' Verify Fail!', self.MAC self.action = None try: ser.close() if os.name not in mac_names: mytime.sleep(3) d_usb.RestartDevice(self.parent.peers.units[self.MAC].InstanceId) except: pass one_unit.tryYield() if s != None: s.settimeout(1) return return def usb_process(self): cmd = None if os.name in mac_names: port = self.parent.peers.units[self.MAC].InstanceId else: port = int(self.parent.peers.units[self.MAC].IP[9:]) - 1 self.delay = 0.01 self.connection_attempts += 1 if self.connection_attempts > 10: self.stopping = True return else: while self.parent.usb_listener.active_port == port: print mytime.displayTime() + ' Waiting for detection thread to free up port' mytime.sleep(0.1) try: self.ser = myserial.Serial(port, 115200, timeout=0, writeTimeout=3) except: print mytime.displayTime() + ' d_protocol.connect error' self.usb_disconnect(port) self.reset_counter += 1 return else: if self.ser is None: print mytime.displayTime() + ' Connection attempt failed!' return if os.name in mac_names: print mytime.displayTime() + ' Connected', self.MAC, 'by port', port, ': ', self.parent.peers.units[self.MAC].type else: print mytime.displayTime() + ' Connected', self.MAC, 'by port COM', port + 1, ': ', self.parent.peers.units[self.MAC].type self.parent.peers.units[self.MAC].link_status = 'available' self.conn.Connected = True self.conn.ResetValues = False self.avg_response_time = 0.001 packet_counter = 0 pkt = self.parent.peers.units[self.MAC].pkt my_id = 1 speedtimer = mytime.clock() + 10 while not self.stopping and one_unit.app.application_stopping == False: try: while not self.stopping and self.conn.Connected == True and one_unit.app.application_stopping == False: if self.action != None: if self.action == 'Exit': self.usb_disconnect(port) return if self.action == 'start_bootloader': self.start_bootloader(None) continue if self.action == 'start bootloader standby delay': name = self.parent.peers.units[self.MAC].name if name is not None and name.strip() in ('No Name', 'Recovery Mode'): print mytime.displayTime() + ' Skipping Standby for', name self.start_bootloader(None) continue if self.conn.synced == True: print mytime.displayTime() + ' Standby OK!' mytime.sleep(1) self.start_bootloader(None) continue elif mytime.clock() - self.start_bootloader_time > 5: print mytime.displayTime() + ' Standby Failed!' self.start_bootloader(None) continue else: try: self.upload_main_firmware(None, self.ser) except: traceback.print_exc(file=sys.stdout) else: continue if mytime.clock() > speedtimer: speedtimer = mytime.clock() + update_interval if self.invalid_packet_counter > 100: self.invalid_packet_counter = 0 self.keepalive_counter = 0 port_index = 0 self.last_hw_packet_id = pkt.HW_PacketID print mytime.displayTime() + ' d_process_usb.invalid packets exceeded 100' self.usb_disconnect(port) return if mytime.clock() - self.last_refresh > 30 and self.delay == MAX_DELAY_USB: self.conn.refresh_get_list() self.last_refresh = mytime.clock() self.conn.MK2 = pkt.MK2 cmd = self.conn.build_command(pkt.HW_PacketID, my_id) if self.conn.synced == False or len(self.conn.get_list) > 0 or self.conn.got_basic_info == False: self.delay = MIN_DELAY_USB self.conn.check_vars_delay = 0 if mytime.clock() - self.conn.full_sync_time > 3: self.conn.full_synced = False self.last_refresh = mytime.clock() elif self.initial_sync == False: self.initial_sync = True if self.delay == MIN_DELAY_USB: if self.first_sync: print mytime.displayTime() + ' ' + self.MAC + ' Initial sync finished' self.first_sync = False self.delay = MAX_DELAY_USB self.conn.full_synced = True self.conn.full_sync_time = mytime.clock() self.setting = 0 try: self.ser.write(cmd) except: print mytime.displayTime() + ' d_protocol.write error 1' self.usb_disconnect(port) return else: send_ts = mytime.clock() retry_ts = mytime.clock() new_pkt = None got_packet = False while one_unit.app.application_stopping == False: if mytime.clock() - retry_ts > 3: print mytime.displayTime() + ' d_protocol.USB: more than 3 seconds no response' self.usb_disconnect(port) return if mytime.clock() - send_ts > 0.1: try: self.ser.write(cmd) except: print mytime.displayTime() + ' d_protocol.write error 2' self.usb_disconnect(port) return else: send_ts = mytime.clock() new_pkt = read_packet(self.ser) if new_pkt == None and got_packet == True: break if not isinstance(new_pkt, Data_packet): mytime.sleep(0.01) continue pkt = new_pkt new_pkt = None self.parent.peers.units[self.MAC].last_rx = mytime.clock() my_id += 1 if my_id == 255: my_id = 1 self.conn.process_data_pkt(pkt) self.invalid_packet_counter += pkt.invalid_packet_counter self.connection_attempts = 0 got_packet = True if self.delay >= 0.01 and self.conn.got_vu == True: mytime.sleep(self.delay) elif self.conn.got_vu == False: mytime.sleep(0.01) self.conn.got_vu = False except: print mytime.displayTime() + ' d_protocol.loop error' traceback.print_exc(file=sys.stdout) self.usb_disconnect(port) return return def usb_disconnect(self, port): try: print mytime.displayTime() + ' Exception in USB thread, disconnecting' traceback.print_exc(file=sys.stdout) except: pass try: self.ser.close() except: pass try: self.conn.Connected = False self.conn.SyncIndicateActive = False del self.ser except: pass try: self.conn.DisconnectTime = mytime.clock() except: pass try: mytime.sleep(0.1) except: pass self.connection_attempts = 0 if self.action != None and self.action != 'Exit' and one_unit.app.bootloader_progress[self.MAC] != None: print mytime.displayTime() + ' USB Disconnect: Aborting Firmware Update' one_unit.updateBootloaderDial(self.MAC, '(2) Failed!') if os.name not in mac_names: d_usb.RestartDevice(self.parent.peers.units[self.MAC].InstanceId) return def ethernet_process(self): cmd = None while not self.stopping and one_unit.app.application_stopping == False: my_id = 1 PORT = 50675 self.ethSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.ethSocket.settimeout(3) self.conn.MK2 = self.parent.peers.units[self.MAC].MK2 try: self.conn.MK2 = one_unit.app.MK2[self.MAC] print mytime.displayTime(), 'd_p.ep.set MK2 from app for', self.MAC, self.conn.MK2 except: pass self.IP = self.parent.peers.units[self.MAC].IP if self.conn.MK2 == True: mk2String = '(MK2)' else: mk2String = '' try: self.ethSocket.connect((self.IP, PORT)) except: print mytime.displayTime() + ' d_p.ep.TCP/IP Connection of ' + self.MAC + ' to ' + self.IP + ' Failed' if one_unit.app.runConnectionTest == True: one_unit.app.connectionTestLog.write(mytime.displayTime() + ' d_p.rC10' + newline) self.conn.Connected = False self.conn.ResetValues = True self.conn.SyncIndicateActive = False if self.action == 'start_main_update' or self.action == 'wait_for_bootloader': self.reset_counter += 1 else: self.reset_counter = 1000 if one_unit.app.testpc == True: self.parent.peers.units[self.MAC].name = 'No Name' self.parent.peers.units[self.MAC].link_status = 'disconnected' self.ethernet_disconnect(self.ethSocket) return else: if one_unit.app.runConnectionTest == True: one_unit.app.connectionTestLog.write(mytime.displayTime() + ' Connected to MAC ' + self.MAC + ' by IP ' + self.IP + newline) self.connectTime = mytime.clock() self.ethSocket.settimeout(0.1) if one_unit.app.EmergencyRecoveryMode == True or self.fastUpdate == True: self.fastUpdate = False self.action = 'updating_main_firmware' one_unit.app.interfaceUpdate[self.MAC] = False self.completion = 1 self.ignore_fw_version = 'i' try: print mytime.displayTime(), 'd_p.ep.bootloader progress:', one_unit.app.bootloader_progress[self.MAC] if True: cmd = 'DDUPLOADFIRMWARE' print mytime.displayTime() + ' d_p.Auto Initiating Firmware Update Mode' retries = 30 while retries > 0: try: self.ethSocket.send(cmd) mytime.sleep(0.1) retries -= 1 except: print mytime.displayTime() + ' d_p.Auto Initiating Firmware Update Mode: Send failed' return print mytime.displayTime() + ' d_p.Auto Initiating Firmware Update Mode: Erasing' if False: cmd = chr(0) + chr(2) + 'dfdg_dfv' + chr(0) + 'netascii' + chr(0) print mytime.displayTime() + ' d_p.partial erase!!!!!!!' else: cmd = chr(0) + chr(2) + 'dddd.dfi' + chr(0) + 'netascii' + chr(0) print mytime.displayTime() + ' d_p.full erase' retries = 30 while retries > 0: try: self.ethSocket.send(cmd) mytime.sleep(0.1) retries -= 1 except: print mytime.displayTime() + ' d_p.Auto Initiating Firmware Update Mode: Send failed' return print mytime.displayTime() + ' d_p.Auto Initiating Firmware Update Mode: Done' self.getFirmwareFile() self.update_start_time = mytime.clock() except: pass print mytime.displayTime(), 'Connected', self.MAC, 'by', self.parent.peers.units[self.MAC].IP, ':', self.parent.peers.units[self.MAC].type, 'action:', self.action self.parent.peers.units[self.MAC].link_status = 'available' self.conn.Connected = True one_unit.app.mac_lookup[self.IP] = self.MAC self.conn.ResetValues = False packet_counter = 0 pkt = self.parent.peers.units[self.MAC].pkt self.delay = 0.01 self.avg_response_time = 0.001 speedtimer = mytime.clock() + 10 last_packet_time = 0 testcounter = 0 while not self.stopping and one_unit.app.application_stopping == False: try: if self.action != None: if self.action == 'Exit': print mytime.displayTime(), 'd_p.exit command for', self.MAC self.ethernet_disconnect(self.ethSocket) return if self.action == 'update_display': self.updateDisplay(self.ethSocket) continue if self.action == 'make_image': self.read_image(self.ethSocket) continue if self.action == 'start_bootloader': self.start_bootloader(self.ethSocket) continue if self.action == 'start bootloader standby delay': name = self.parent.peers.units[self.MAC].name if name is not None and name.strip() in ('No Name', 'Recovery Mode'): print mytime.displayTime() + ' Skipping Standby for', name self.start_bootloader(None) continue if self.conn.synced == True: print mytime.displayTime() + ' Standby OK!' mytime.sleep(1) self.start_bootloader(self.ethSocket) continue elif mytime.clock() - self.start_bootloader_time > 5: print mytime.displayTime() + ' Standby Failed!' self.start_bootloader(self.ethSocket) continue else: if self.action == 'wait_for_bootloader': mytime.sleep(0.1) print mytime.displayTime() + ' Exiting communication loop to wait for bootloader' self.ethernet_disconnect(self.ethSocket) self.reset_counter = 100 return continue try: self.upload_main_firmware(self.ethSocket) except: print mytime.displayTime(), 'd_p.error in upload main firmware, exiting', self.MAC traceback.print_exc(file=sys.stdout) self.action = 'Exit' else: continue if mytime.clock() - self.last_refresh > 30 and self.delay == MAX_DELAY: self.conn.refresh_get_list() self.last_refresh = mytime.clock() if pkt is not None: self.conn.MK2 = pkt.MK2 cmd = self.conn.build_command(pkt.HW_PacketID, my_id) else: print mytime.displayTime() + ' d_protocol.ethernet.None Packet!' print mytime.displayTime() + ' Vroeger: disconnect etc. Nu: Zelfde cmd nog een keer sturen. Beter? Afwachten.' if self.conn.synced == False or len(self.conn.get_list) > 0 or self.conn.got_basic_info == False: if self.first_sync: self.delay = MIN_DELAY else: self.delay = SYNC_DELAY self.conn.check_vars_delay = 0 if mytime.clock() - self.conn.full_sync_time > 3: self.conn.full_synced = False self.last_refresh = mytime.clock() elif self.initial_sync == False: self.initial_sync = True if self.delay == MIN_DELAY: if self.first_sync: print mytime.displayTime() + ' ' + self.MAC + ' Initial sync finished' self.first_sync = False self.delay = MAX_DELAY self.conn.full_synced = True self.conn.full_sync_time = mytime.clock() self.setting = 0 vu_delay = len(one_unit.app.server.peers.units) / 50.0 if vu_delay < 0.1: vu_delay = 0.1 if vu_delay > 1: vu_delay = 1 if self.delay == MAX_DELAY and CONDITIONAL_VU == True and len(cmd) < 10 and self.enable_vu == False and mytime.clock() - last_packet_time < vu_delay: mytime.sleep(0.1) continue last_packet_time = mytime.clock() pkt_id = pkt.HW_PacketID try: self.ethSocket.send(cmd) except: try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(0.5) s.connect((self.IP, 50675)) s.settimeout(0.5) self.ethSocket = s self.ethSocket.send(cmd) except: print mytime.displayTime() + ' Sending Ethernet Packet Reconnect Failed, Exiting' self.ethernet_disconnect(self.ethSocket) return last_id = pkt.HW_PacketID send_ts = mytime.clock() retry_ts = mytime.clock() retry_ts_2 = mytime.clock() reconnectCounter = 0 new_pkt = None got_packet = False while one_unit.app.application_stopping == False: if mytime.clock() - retry_ts_2 > 2: reconnectCounter += 1 try: self.ethSocket.close() except: pass else: retry_ts = mytime.clock() try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(0.5) s.connect((self.IP, 50675)) s.settimeout(0.5) self.ethSocket = s if reconnectCounter > 1: print mytime.displayTime() + ' d_p.ep.Reconnected', self.MAC, 'to', self.IP, mytime.clock(), retry_ts_2, reconnectCounter break except: if one_unit.app.runConnectionTest == True: one_unit.app.connectionTestLog.write(mytime.displayTime() + ' d_p.rC12' + newline) else: if reconnectCounter > 13: print mytime.displayTime(), self.MAC, 'Ethernet Timeout, uptime', mytime.clock() - self.connectTime, 'seconds' print mytime.displayTime(), 'd_p.ts delta:', mytime.clock() - retry_ts, reconnectCounter, self.reset_counter, mytime.clock() - retry_ts_2, 'ts:', retry_ts, retry_ts_2, 'clock:', mytime.clock() if one_unit.app.runConnectionTest == True: one_unit.app.connectionTestLog.write(mytime.displayTime() + ' d_p.rC13' + newline) try: cmd = 'DDRESETCONNECTIO' self.ethSocket.send(cmd) print mytime.displayTime() + ' d_p.Reset connection 3.1' except: print mytime.displayTime() + ' d_p.Reset connection failed 3.1', reconnectCounter self.ethernet_disconnect(self.ethSocket) self.reset_counter += 1 mytime.sleep(1) return mytime.sleep(0.1) continue if mytime.clock() - send_ts > 1: print mytime.displayTime(), 'dp.ep.Resending Ethernet packet' try: self.ethSocket.send(cmd) except: try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(0.5) s.connect((self.IP, 50675)) s.settimeout(0.5) self.ethSocket = s self.ethSocket.send(cmd) except: print mytime.displayTime() + ' Ethernet disconnect: repeated send reconnect failed' self.ethernet_disconnect(self.ethSocket) return else: send_ts = mytime.clock() try: new_pkt = '' new_pkt = self.ethSocket.recv(4096) except: mytime.sleep(0.01) if self.conn.synced == False and len(cmd) == 9: mytime.sleep(0.1) try: new_pkt = self.ethSocket.recv(4096) except: pass else: break continue if len(new_pkt) < 9: retry_ts_2 = mytime.clock() - 5 continue new_pkt = parse_packet(new_pkt, length=len(new_pkt) - 10) if not isinstance(new_pkt, Data_packet): continue pkt = new_pkt new_pkt = None my_id += 1 if my_id == 255: my_id = 1 packet_counter += 1 self.conn.process_data_pkt(pkt) self.conn.Connected = True self.reset_counter = 0 got_packet = True break if self.delay >= 0.01: mytime.sleep(self.delay) else: mytime.sleep(0.01) self.conn.got_vu = False except: print mytime.displayTime() + ' Ethernet exception, closing socket for ' + self.MAC + ' to ' + self.IP if one_unit.app.runConnectionTest == True: one_unit.app.connectionTestLog.write(mytime.displayTime() + ' d_p.rC14' + newline) try: traceback.print_exc(file=sys.stdout) except: pass else: try: self.conn.Connected = False self.conn.SyncIndicateActive = False except: pass else: break try: cmd = 'DDRESETCONNECTIO' self.ethSocket.send(cmd) except: pass print mytime.displayTime() + ' Disconnecting', self.MAC, 'from', self.IP if one_unit.app.runConnectionTest == True: one_unit.app.connectionTestLog.write(mytime.displayTime() + ' d_p.rC15' + newline) self.ethernet_disconnect(self.ethSocket) return try: cmd = 'DDRESETCONNECTIO' self.ethSocket.send(cmd) except: pass try: print mytime.displayTime() + ' Ethernet disconnect end of loop' self.ethernet_disconnect(self.ethSocket) except: pass return def ethernet_disconnect(self, s): print mytime.displayTime(), 'd_p.ethernet disconnect for', self.MAC, self.conn.MK2 if one_unit.app.runConnectionTest == True: one_unit.app.connectionTestLog.write(mytime.displayTime() + ' d_p.rC16' + newline) if self.conn.MK2 == True: one_unit.app.MK2[self.MAC] = self.conn.MK2 self.parent.peers.units[self.MAC].MK2 = self.conn.MK2 print mytime.displayTime(), 'd_p. set one_unit.app.MK2[self.MAC] to', self.conn.MK2, 'for', self.MAC try: s.settimeout(1) pkt = s.recv(1024) print mytime.displayTime() + ' d_p.ed.Got disconnect reply from', self.IP except: print mytime.displayTime() + ' d_p.ed.No reply from', self.IP try: s.close() except: pass mytime.sleep(0.1) return def start(self): """Start the updating thread""" self.stopping = False self.thread.start() return def stop(self): """Stop the updating thread""" self.stopping = True self.thread.join() return class Protocol_Execute(): def __init__(self, parent): self.parent = parent self.lock = threading.Lock() self.reset() self.stopping = False self.broadcasted_skin = '' self.keepalive = True self.last_hw_packet_id = 0 self.getIndex = 0 self.invalid_packet_counter = 0 self.min = {} self.max = {} self.firTaps = None self.link_type = self.parent.parent.peers.units[self.parent.MAC].link_type self.firTapsFromUi = None self.adcRef33Main = 3.3 self.adcRef33Standby = 3.3 self.DisconnectTime = mytime.clock() self.synced = False self.last_vu = 0 self.get_time = {} self.maxNumberOfPresets = 100 self.isTCS = False self.isZwembad = False self.get_counter = {} self.slave_id = 'J' self.full_synced = False self.FIRmap = {} self.firStartBlockByChannel = {} self.firBlockSize = 1 self.full_sync_time = 0 self.setting = 0 self.last_impedance = {} self.MK2 = False try: self.MK2 = one_unit.app.MK2[self.parent.MAC] except: pass self.got_basic_info = False self.model_number = None self.factory = False self.set_aborted = False self.got_vu = False self.avg_vu_delay = 0 self.max_vu_delay = 0 self.min_vu_delay = 1000000000 self.vu_dropouts = 0 self.Connected = False self.full_config = None self.LinkStatus = False self.SyncIndicateActive = False self.muted = False self.last_refresh = mytime.clock() self.check_vars_delay = 0 self.gotVUtime = mytime.clock() self.buildNumber = 0 self.make_get_list() decoding_map = codecs.make_identity_dict(range(128)) self.encoding_map = codecs.make_encoding_map(decoding_map) self.testtime = 0 return def get_relative_group_keys(self): for group_id in one_unit.app.groups: if group_id == 'all_units': continue if one_unit.app.group_type[group_id] == 'Relative': for grouped_key in one_unit.app.group_links[group_id]: self.config_vars.append(Key(grouped_key[0], grouped_key[1], grouped_key[2], grouped_key[3])) return def make_get_list(self): if self.got_basic_info == False: temp_config_vars = [] self.config_vars = [] fwversion = self.parent.parent.peers.units[self.parent.MAC].FWVersion key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_SW_VERSION, 0, 0) self.config_vars.append(key) key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_MODEL_FIRMWARE, 0, 0) self.config_vars.append(key) key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_MODEL_NUMBER, 0, 0) self.config_vars.append(key) key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_CURRENT_USER, 0, 0) self.config_vars.append(key) key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_ACCESS_RIGHTS, 0, 0) self.config_vars.append(key) try: use_preset_lock = eval(self.parent.main_config.get('ROOT', 'use_preset_lock')) except: if self.parent.parent.peers.units[self.parent.MAC].numericalFWVersion >= self.parent.parent.peers.units[self.parent.MAC].minPresetLockVersion: use_preset_lock = True else: use_preset_lock = False if use_preset_lock: for i in range(1, 5): pwkey = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_SET_PASSWORD, i, 0) self.config_vars.append(pwkey) pwkey = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_USER_ACCESS_RIGHTS, 0, i + 1) self.config_vars.append(pwkey) key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_HARDWARE_STATUS_FLAGS, 0, 0) self.config_vars.append(key) key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_SHORT_NAME, 0, 0) self.config_vars.append(key) key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_PIN, 0, 0) self.config_vars.append(key) key = data_model.Key(protocol.STRUCT_ID_MUTE, protocol.MEMBER_ID_MUTE, 0, 0) self.config_vars.append(key) self.get_list = self.config_vars[:] return else: key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_MODEL_NUMBER, 0, 0) if key not in self.values: self.values[key] = Unit_var() self.values[key].read_val = -1 if self.values[key].read_val == -1: key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_MODEL_FIRMWARE, 0, 0) try: self.model_number = self.values[key].read_val except KeyError: self.values[key] = Unit_var() self.values[key].read_val = 0 except: traceback.print_exc(file=sys.stdout) self.values[key] = Unit_var() self.values[key].read_val = 0 self.model_number = self.values[key].read_val try: key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_SHORT_NAME, 0, 0) name = self.values[key].read_val.strip() except: name = 'Unknown Name' try: if len(self.config_vars) > 5: temp_config_vars = self.config_vars[:] else: temp_config_vars = [] except: pass self.config_vars = [] got_config = False number_of_presets = 0 self.config = None myChannels = [] try: model_number_string = '_' + str(self.model_number) count = 0 while count < 3: myFullType = self.parent.parent.peers.units[self.parent.MAC].type + model_number_string if myFullType in one_unit.app.get_list_by_type: self.myFullType = myFullType self.config_vars = one_unit.app.get_list_by_type[myFullType] self.get_list = self.config_vars[:] self.parent.mute_channels = one_unit.app.mute_channels_by_type[myFullType] self.min = one_unit.app.min_by_type[myFullType] self.max = one_unit.app.max_by_type[myFullType] self.config = one_unit.app.config_by_type[myFullType] self.full_config = one_unit.app.config_by_type[myFullType] self.get_fir_map(self.config) self.parent.parent.peers.units[self.parent.MAC].minPresetLockVersion = one_unit.app.minPresetLockVersion[myFullType] self.parent.parent.peers.units[self.parent.MAC].minPINVersion = one_unit.app.minPINVersion[myFullType] self.parent.parent.peers.units[self.parent.MAC].minFIRgainVersion = one_unit.app.minFIRgainVersion[myFullType] self.parent.parent.peers.units[self.parent.MAC].minBuildNumberVersion = one_unit.app.minBuildNumberVersion[myFullType] self.parent.parent.peers.units[self.parent.MAC].minModelFirmwareVersion = one_unit.app.minModelFirmwareVersion[myFullType] return skin_path = os.path.join(one_unit.app.cwd, one_unit.app.skin_path, self.parent.parent.peers.units[self.parent.MAC].type + model_number_string + '_d') if os.path.exists(os.path.join(skin_path, 'default.cfg')): try: config = ConfigParser.ConfigParser() config.read(os.path.join(skin_path, 'default.cfg')) views = config.get('DEFAULT', 'views') self.full_config = config try: skip = eval(config.get('DEFAULT', 'skip')) except: if True: skip = True else: skip = False try: number_of_presets = config.getint('recall_preset', 'max_value') except: pass try: self.isTCS = eval(config.get('DEFAULT', 'isTCS')) except: pass self.get_mute_channels(config) self.get_min_max(config) self.config = config myChannels = self.get_all_channels(config, myChannels) if skip == False: self.get_fir_map(config) self.get_config_vars() got_config = True print mytime.displayTime() + ' d_p.mgl.Loaded config from ' + os.path.split(skin_path)[1] else: try: dummy = config.get('standby_delay_time', 'struct_id') key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_STANDBY_DELAY, 0, 0) self.config_vars.append(key) except: pass except: traceback.print_exc(file=sys.stdout) skin_path = os.path.join(one_unit.app.cwd, one_unit.app.skin_path, self.parent.parent.peers.units[self.parent.MAC].type + '_d') if os.path.exists(os.path.join(skin_path, 'default.cfg')): try: config = ConfigParser.ConfigParser() config.read(os.path.join(skin_path, 'default.cfg')) views = config.get('DEFAULT', 'views') self.full_config = config try: skip = eval(config.get('DEFAULT', 'skip')) except: if True: skip = True else: skip = False try: number_of_presets = config.getint('recall_preset', 'max_value') except: pass try: self.isTCS = eval(config.get('DEFAULT', 'isTCS')) except: pass self.get_mute_channels(config) self.get_min_max(config) self.config = config myChannels = self.get_all_channels(config, myChannels) if skip == False: self.get_fir_map(config) self.get_config_vars() got_config = True print mytime.displayTime() + ' d_p.mgl.Loaded config from ' + os.path.split(skin_path)[1] else: try: dummy = config.get('standby_delay_time', 'struct_id') key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_STANDBY_DELAY, 0, 0) self.config_vars.append(key) except: pass except: traceback.print_exc(file=sys.stdout) skin_path = os.path.join(one_unit.app.cwd, one_unit.app.skin_path, self.parent.parent.peers.units[self.parent.MAC].type + model_number_string + '_a') if os.path.exists(os.path.join(skin_path, 'default.cfg')): try: config = ConfigParser.ConfigParser() config.read(os.path.join(skin_path, 'default.cfg')) views = config.get('DEFAULT', 'views') try: skip = eval(config.get('DEFAULT', 'skip')) except: if True: skip = True else: skip = False try: number_of_presets = config.getint('recall_preset', 'max_value') except: pass try: self.isTCS = eval(config.get('DEFAULT', 'isTCS')) except: pass self.get_mute_channels(config) self.get_min_max(config) myChannels = self.get_all_channels(config, myChannels) if skip == False: self.get_fir_map(config) self.config = config self.get_config_vars() got_config = True print mytime.displayTime() + ' d_p.mgl.Loaded config from ' + os.path.split(skin_path)[1] else: try: dummy = config.get('standby_delay_time', 'struct_id') key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_STANDBY_DELAY, 0, 0) self.config_vars.append(key) except: pass except: traceback.print_exc(file=sys.stdout) skin_path = os.path.join(one_unit.app.cwd, one_unit.app.skin_path, self.parent.parent.peers.units[self.parent.MAC].type + '_a') if os.path.exists(os.path.join(skin_path, 'default.cfg')): try: config = ConfigParser.ConfigParser() config.read(os.path.join(skin_path, 'default.cfg')) views = config.get('DEFAULT', 'views') try: skip = eval(config.get('DEFAULT', 'skip')) except: if True: skip = True else: skip = False try: number_of_presets = config.getint('recall_preset', 'max_value') except: pass try: self.isTCS = eval(config.get('DEFAULT', 'isTCS')) except: pass self.get_mute_channels(config) self.get_min_max(config) myChannels = self.get_all_channels(config, myChannels) if skip == False: self.get_fir_map(config) self.config = config self.get_config_vars() got_config = True print mytime.displayTime() + ' d_p.mgl.Loaded config from ' + os.path.split(skin_path)[1] else: try: dummy = config.get('standby_delay_time', 'struct_id') key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_STANDBY_DELAY, 0, 0) self.config_vars.append(key) except: pass except: traceback.print_exc(file=sys.stdout) skin_path = os.path.join(one_unit.app.cwd, one_unit.app.skin_path, self.parent.parent.peers.units[self.parent.MAC].type + model_number_string + '_u') if os.path.exists(os.path.join(skin_path, 'default.cfg')): try: config = ConfigParser.ConfigParser() config.read(os.path.join(skin_path, 'default.cfg')) views = config.get('DEFAULT', 'views') try: skip = eval(config.get('DEFAULT', 'skip')) except: if True: skip = True else: skip = False try: number_of_presets = config.getint('recall_preset', 'max_value') except: pass try: self.isTCS = eval(config.get('DEFAULT', 'isTCS')) except: pass self.get_mute_channels(config) self.get_min_max(config) myChannels = self.get_all_channels(config, myChannels) if skip == False: self.get_fir_map(config) self.config = config self.get_config_vars() got_config = True print mytime.displayTime() + ' d_p.mgl.Loaded config from ' + os.path.split(skin_path)[1] else: try: dummy = config.get('standby_delay_time', 'struct_id') key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_STANDBY_DELAY, 0, 0) self.config_vars.append(key) except: pass except: traceback.print_exc(file=sys.stdout) skin_path = os.path.join(one_unit.app.cwd, one_unit.app.skin_path, self.parent.parent.peers.units[self.parent.MAC].type + '_u') if os.path.exists(os.path.join(skin_path, 'default.cfg')): try: config = ConfigParser.ConfigParser() config.read(os.path.join(skin_path, 'default.cfg')) views = config.get('DEFAULT', 'views') try: skip = eval(config.get('DEFAULT', 'skip')) except: if True: skip = True else: skip = False try: number_of_presets = config.getint('recall_preset', 'max_value') except: pass try: self.isTCS = eval(config.get('DEFAULT', 'isTCS')) except: pass self.get_mute_channels(config) self.get_min_max(config) myChannels = self.get_all_channels(config, myChannels) if skip == False: self.get_fir_map(config) self.config = config self.get_config_vars() got_config = True print mytime.displayTime() + ' d_p.mgl.Loaded config from ' + os.path.split(skin_path)[1] else: try: dummy = config.get('standby_delay_time', 'struct_id') key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_STANDBY_DELAY, 0, 0) self.config_vars.append(key) except: pass except: traceback.print_exc(file=sys.stdout) skin_path = os.path.join(one_unit.app.cwd, one_unit.app.skin_path, self.parent.parent.peers.units[self.parent.MAC].type + model_number_string + '_f') if os.path.exists(os.path.join(skin_path, 'default.cfg')): try: config = ConfigParser.ConfigParser() config.read(os.path.join(skin_path, 'default.cfg')) views = config.get('DEFAULT', 'views') try: skip = eval(config.get('DEFAULT', 'skip')) except: if True: skip = True else: skip = False try: number_of_presets = config.getint('recall_preset', 'max_value') except: pass try: self.isTCS = eval(config.get('DEFAULT', 'isTCS')) except: pass self.get_mute_channels(config) self.get_min_max(config) myChannels = self.get_all_channels(config, myChannels) if skip == False: self.get_fir_map(config) self.config = config self.get_config_vars() got_config = True print mytime.displayTime() + ' Loaded config from ' + os.path.split(skin_path)[1] else: print mytime.displayTime() + ' Skipping config ' + os.path.split(skin_path)[1] + ', skip:', skip try: dummy = config.get('standby_delay_time', 'struct_id') key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_STANDBY_DELAY, 0, 0) self.config_vars.append(key) except: pass except: traceback.print_exc(file=sys.stdout) skin_path = os.path.join(one_unit.app.cwd, one_unit.app.skin_path, self.parent.parent.peers.units[self.parent.MAC].type + model_number_string) if os.path.exists(os.path.join(skin_path, 'default.cfg')): try: config = ConfigParser.ConfigParser() config.read(os.path.join(skin_path, 'default.cfg')) views = config.get('DEFAULT', 'views') if self.full_config == None: self.full_config = config try: skip = eval(config.get('DEFAULT', 'skip')) except: if True: skip = True else: skip = False try: number_of_presets = config.getint('recall_preset', 'max_value') except: pass try: self.isTCS = eval(config.get('DEFAULT', 'isTCS')) except: pass self.get_mute_channels(config) self.get_min_max(config) if self.config == None: self.config = config if skip == False: self.get_fir_map(config) self.get_config_vars() got_config = True print mytime.displayTime() + ' d_p.mgl.Loaded config from ' + os.path.split(skin_path)[1] else: try: dummy = config.get('standby_delay_time', 'struct_id') key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_STANDBY_DELAY, 0, 0) self.config_vars.append(key) except: pass except: traceback.print_exc(file=sys.stdout) skin_path = os.path.join(one_unit.app.cwd, one_unit.app.skin_path, self.parent.parent.peers.units[self.parent.MAC].type) if os.path.exists(os.path.join(skin_path, 'default.cfg')): try: config = ConfigParser.ConfigParser() config.read(os.path.join(skin_path, 'default.cfg')) views = config.get('DEFAULT', 'views') if self.full_config == None: self.full_config = config try: skip = eval(config.get('DEFAULT', 'skip')) except: if True: skip = True else: skip = False try: number_of_presets = config.getint('recall_preset', 'max_value') except: pass try: self.isTCS = eval(config.get('DEFAULT', 'isTCS')) except: pass self.get_mute_channels(config) self.get_min_max(config) if self.config == None: self.config = config if skip == False: self.get_fir_map(config) self.get_config_vars() got_config = True print mytime.displayTime() + ' d_p.mgl.Loaded config from ' + os.path.split(skin_path)[1] else: try: dummy = config.get('standby_delay_time', 'struct_id') key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_STANDBY_DELAY, 0, 0) self.config_vars.append(key) except: pass except: traceback.print_exc(file=sys.stdout) if got_config == True: print mytime.clock(), 'Reading Config:', self.parent.parent.peers.units[self.parent.MAC].type + model_number_string break if count == 0: model_number_string = '_0' elif count == 1: model_number_string = '' else: break count += 1 except: traceback.print_exc(file=sys.stdout) if got_config == False: model_number_string = '_' + str(self.model_number) try: config = self.config except: pass else: if len(temp_config_vars) > 0: self.config_vars = temp_config_vars try: always_load_presets = eval(self.parent.main_config.get('ROOT', 'always_load_presets')) except: always_load_presets = False if got_config == True or always_load_presets == True: self.maxNumberOfPresets = number_of_presets for i in range(1, number_of_presets + 1): key = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_SHORT_NAME, i, 0) self.config_vars.append(key) try: use_preset_lock = eval(self.parent.main_config.get('ROOT', 'use_preset_lock')) except: if self.parent.parent.peers.units[self.parent.MAC].numericalFWVersion >= self.parent.parent.peers.units[self.parent.MAC].minPresetLockVersion: use_preset_lock = True else: use_preset_lock = False if use_preset_lock: for i in range(1, 5): pwkey = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_SET_PASSWORD, i, 0) self.config_vars.append(pwkey) pwkey = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_USER_ACCESS_RIGHTS, 0, i + 1) self.config_vars.append(pwkey) for map in self.FIRmap.values(): if map[0] not in myChannels: myChannels.append(map[0]) if self.parent.IP != 'USB': for channel in myChannels: key = data_model.Key(protocol.STRUCT_ID_LPF, protocol.MEMBER_ID_GAIN, channel, 0) self.config_vars.append(key) key = data_model.Key(protocol.STRUCT_ID_HPF, protocol.MEMBER_ID_GAIN, channel, 0) self.config_vars.append(key) key = data_model.Key(protocol.STRUCT_ID_LPF, protocol.MEMBER_ID_Q, channel, 0) self.config_vars.append(key) key = data_model.Key(protocol.STRUCT_ID_HPF, protocol.MEMBER_ID_Q, channel, 0) self.config_vars.append(key) for i in range(1, 5): pwkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_SET_PASSWORD, i, 0) self.config_vars.append(pwkey) pwkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_USER_ACCESS_RIGHTS, 0, i + 1) self.config_vars.append(pwkey) key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_CURRENT_USER, 0, 0) self.config_vars.append(key) key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_ACCESS_RIGHTS, 0, 0) self.config_vars.append(key) key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_HARDWARE_STATUS_FLAGS, 0, 0) self.config_vars.append(key) key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_SHORT_NAME, 0, 0) self.config_vars.append(key) key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_CHECK_PASSWORD, 0, 0) self.config_vars.append(key) key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_SW_VERSION, 0, 0) self.config_vars.append(key) key = Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_STARTUP_PRESET, 0, 0) self.config_vars.append(key) if self.parent.parent.peers.units[self.parent.MAC].link_type == 'Ethernet': key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_IP, 0, 0) self.config_vars.append(key) key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_SUBNET_MASK, 0, 0) self.config_vars.append(key) if model_number_string != '': key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_MODEL_FIRMWARE, 0, 0) self.config_vars.append(key) self.get_relative_group_keys() if self.parent.mute_channels != None: for channel in self.parent.mute_channels: key = data_model.Key(protocol.STRUCT_ID_MUTE, protocol.MEMBER_ID_MUTE, channel, 0) if key not in self.config_vars: self.config_vars.append(key) self.get_list = self.config_vars[:] self.myFullType = myFullType one_unit.app.get_list_by_type[myFullType] = self.config_vars[:] one_unit.app.mute_channels_by_type[myFullType] = self.parent.mute_channels one_unit.app.min_by_type[myFullType] = self.min one_unit.app.max_by_type[myFullType] = self.max one_unit.app.minPresetLockVersion[myFullType] = self.parent.parent.peers.units[self.parent.MAC].minPresetLockVersion one_unit.app.minPINVersion[myFullType] = self.parent.parent.peers.units[self.parent.MAC].minPINVersion one_unit.app.minFIRgainVersion[myFullType] = self.parent.parent.peers.units[self.parent.MAC].minFIRgainVersion one_unit.app.minBuildNumberVersion[myFullType] = self.parent.parent.peers.units[self.parent.MAC].minBuildNumberVersion one_unit.app.minModelFirmwareVersion[myFullType] = self.parent.parent.peers.units[self.parent.MAC].minModelFirmwareVersion one_unit.app.config_by_type[myFullType] = self.config return def refresh_get_list(self): if self.parent.action != None or self.synced == False or len(self.get_list) > 0: return else: try: if self.parent.MAC in one_unit.app.bootloader_progress and one_unit.app.bootloader_progress[self.parent.MAC] != None: return except: traceback.print_exc(file=sys.stdout) if self.got_basic_info == False: self.make_get_list() return vars = [] key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_HARDWARE_STATUS_FLAGS, 0, 0) vars.append(key) try: for channel in self.parent.mute_channels: key = data_model.Key(protocol.STRUCT_ID_MUTE, protocol.MEMBER_ID_MUTE, channel, 0) if key not in vars: vars.append(key) except: pass for key in vars: try: del self.values[key] except: pass self.get_list.append(key) return def get_all_channels(self, config, channels): for var in config.sections(): try: channel = config.getint(var, 'channel') strid = config.getint(var, 'struct_id') if strid not in (protocol.STRUCT_ID_GAIN, protocol.STRUCT_ID_VU, protocol.STRUCT_ID_GAIN): continue if channel not in channels: channels.append(channel) except: pass return channels def get_mute_channels(self, config): try: self.parent.mute_channels = eval(config.get('DEFAULT', 'mute_channels')) except: if self.parent.mute_channels == None: in_channels = [] for var in config.sections(): try: channel = config.getint(var, 'channel') if channel < 128 and channel not in in_channels and config.getint(var, 'struct_id') not in (-3, -2, -1, 13): in_channels.append(channel) except: pass self.parent.mute_channels = in_channels return def get_fir_map(self, config): print mytime.displayTime(), 'dp.get FIR map' self.makeFirMap(config=config) return def makeFirMap(self, firTaps=None, config=None, firBlockSize=None): if self.MK2 == False: return else: if config == None: if self.full_config != None: config = self.full_config print mytime.displayTime(), 'dp.Using self.full_config for FIR map' else: print mytime.displayTime(), 'dp.Failed to make FIR map, full config not set yet!' return tempFirBlockSize = self.firBlockSize self.firBlocksPerChannel = 0 if firBlockSize == None: try: self.firBlockSize = config.getint('DEFAULT', 'firBlockSize') except: try: time.sleep(0.1) self.firBlockSize = config.getint('DEFAULT', 'firBlockSize') except: if tempFirBlockSize != None: self.firBlockSize = tempFirBlockSize else: print mytime.displayTime(), 'dp.Failed to make FIR map, FIR block size not set' return else: self.firBlockSize = firBlockSize try: self.firBlocksPerChannel = config.getint('DEFAULT', 'firBlocks') except: pass if firTaps == None: try: firTaps = eval(config.get('DEFAULT', 'FIR_taps')) print 'dp.fir taps from config:', firTaps except: print mytime.displayTime(), 'dp.Failed to make FIR map, FIR taps not set' return if self.firTaps != None and (firTaps == None or len(firTaps) == 0): firTaps = self.firTaps print mytime.displayTime(), 'dp.Using self.firTaps for FIR map' if self.firTapsFromUi != None: firTaps = self.firTapsFromUi print mytime.displayTime(), 'dp.Using self.firTapsFromUi for FIR map' print mytime.displayTime(), 'dp. FIR taps uiteindelijk:', firTaps if firTaps == None: ( mytime.displayTime(), 'dp. No FIR taps, aborting') self.firStartBlockByChannel = {} self.FIRmap = {} self.firTaps = firTaps block = -1 for channel in sorted(firTaps.keys()): numberOfTaps = firTaps[channel] offset = 0 if numberOfTaps > 0: blocks = self.firBlocksPerChannel else: blocks = 0 while numberOfTaps > 0 or blocks > 0: block = block + 1 self.FIRmap[block] = (channel, offset) offset += self.firBlockSize numberOfTaps -= self.firBlockSize blocks -= 1 for block in self.FIRmap: if block == 65535: continue channel = self.FIRmap[block][0] if channel not in self.firStartBlockByChannel: self.firStartBlockByChannel[channel] = block elif block < self.firStartBlockByChannel[channel]: self.firStartBlockByChannel[channel] = block for testkey in self.config_vars[:]: if testkey.member_id == protocol.MEMBER_ID_FIR: safeRemove(self.config_vars, testkey) for testkey in self.get_list[:]: if testkey.member_id & 128 == protocol.MEMBER_ID_FIR: safeRemove(self.get_list, testkey) for testkey in self.values.keys(): if testkey.member_id == protocol.MEMBER_ID_FIR: del self.values[testkey] return def get_min_max(self, config): try: self.parent.parent.peers.units[self.parent.MAC].minPresetLockVersion = config.getint('DEFAULT', 'minPresetLockVersion') except: pass try: self.parent.parent.peers.units[self.parent.MAC].minPINVersion = config.getint('DEFAULT', 'minPINVersion') except: pass try: self.parent.parent.peers.units[self.parent.MAC].minFIRgainVersion = config.getint('DEFAULT', 'minFIRgainVersion') except: pass try: self.parent.parent.peers.units[self.parent.MAC].minBuildNumberVersion = config.getint('DEFAULT', 'minBuildNumberVersion') except: pass try: self.parent.parent.peers.units[self.parent.MAC].minModelFirmwareVersion = config.getint('DEFAULT', 'minModelFirmwareVersion') except: pass sections = config.sections() struct_id = None member_id = None num = None for var in sections: channels = [] if var == 'DEFAULT': continue try: scale = config.get(var, 'svg_file') continue except: pass try: struct_id = config.getint(var, 'struct_id') member_id = config.getint(var, 'member_id') num = config.getint(var, 'num') except: pass try: scale = protocol.get_member_scale(member_id) except: traceback.print_exc(file=sys.stdout) scale = 1.0 if struct_id in ( protocol.STRUCT_ID_INTERNAL, protocol.STRUCT_ID_COMMAND, protocol.STRUCT_ID_VU, protocol.STRUCT_ID_GR, protocol.STRUCT_ID_RAW_VU): continue if member_id in ( protocol.MEMBER_ID_VU_IN, protocol.MEMBER_ID_VU_OUT, protocol.MEMBER_ID_GR_IN, protocol.MEMBER_ID_GR_OUT, protocol.MEMBER_ID_COMMAND, protocol.MEMBER_ID_CHECK_PASSWORD, protocol.MEMBER_ID_HARDWARE_STATUS_FLAGS, protocol.MEMBER_ID_AMP_READINGS, protocol.MEMBER_ID_AMP_READINGS_2): continue try: channels = self.channels_for_var(var, config) except: traceback.print_exc(file=sys.stdout) continue for channel in channels: key = data_model.Key(struct_id, member_id, channel, num) try: self.min[key] = config.getfloat(var, 'min_value') * scale except: self.min[key] = None try: self.max[key] = config.getfloat(var, 'max_value') * scale except: self.max[key] = None break return def get_config_vars(self): sections = self.config.sections() struct_id = None member_id = None num = None try: custom_scales = eval(self.config.get('DEFAULT', 'custom_scales')) print 'd_p.jaja custom scales' except: custom_scales = False for var in sections: channels = [] if var == 'DEFAULT': continue try: scale = self.config.get(var, 'svg_file') continue except: pass try: struct_id = self.config.getint(var, 'struct_id') member_id = self.config.getint(var, 'member_id') num = self.config.getint(var, 'num') except: pass try: min_build_number = self.config.getint(var, 'min_build_number') continue except: pass scale = protocol.get_member_scale(member_id) offset = 0.0 try: if custom_scales == True: scale = self.config.getfloat(var, 'scale') one_unit.app.custom_scale[member_id] = scale print 'Scale for', member_id, 'is', scale offset = self.config.getfloat(var, 'offset') except: pass if struct_id in ( protocol.STRUCT_ID_INTERNAL, protocol.STRUCT_ID_COMMAND, protocol.STRUCT_ID_VU, protocol.STRUCT_ID_GR, protocol.STRUCT_ID_RAW_VU): continue if member_id in ( protocol.MEMBER_ID_VU_IN, protocol.MEMBER_ID_VU_OUT, protocol.MEMBER_ID_GR_IN, protocol.MEMBER_ID_GR_OUT, protocol.MEMBER_ID_COMMAND, protocol.MEMBER_ID_CHECK_PASSWORD, protocol.MEMBER_ID_HARDWARE_STATUS_FLAGS, protocol.MEMBER_ID_AMP_READINGS, protocol.MEMBER_ID_AMP_READINGS_2): continue channels = self.channels_for_var(var) for channel in channels: key = data_model.Key(struct_id, member_id, channel, num) one_unit.app.member_scale[key] = scale one_unit.app.member_offset[key] = offset if key not in self.config_vars: self.config_vars.append(key) return def channels_for_var(self, var, config=None): if config == None: config = self.config channels = [] try: channels = config.get(var, 'channels') except ConfigParser.NoOptionError: try: channel = config.get(var, 'channel') except ConfigParser.NoOptionError: print mytime.displayTime() + " d_p.variable '%s' has neither 'channels' nor 'channel' attributes defined. This is wrong, variable ignored." % var return [] else: channel = int(channel, 0) channels = [channel] else: channels = [_[1] for s in channels.split(',')] return channels def reset(self): self.Connected = False self.last_refresh = mytime.clock() self.LinkStatus = False self.ResetValues = True self.getIndex = 0 self.last_get_key = None self.SyncIndicateActive = False self.last_peq_key = None self.last_xover_key = None self.values = {} self.preset_names = {} self.last_requested = -1 self.correct_vars = 0 self.check_vars_delay = 0 return def build_key(self, struct_id, member_id, channel=0, num=0): return Key(struct_id, member_id, channel, num) def get(self, struct_id, member_id, channel=0, num=0): struct_id = int(struct_id) member_id = int(member_id) key = self.build_key(struct_id, member_id, channel, num) return self.get_by_key(key) def get_by_key(self, key): if self.parent.action != None: return else: if key.channel == None or key.channel < 0: print mytime.displayTime() + ' d_protocol.get_by_key.invalid key!', key try: var = self.values[key] except KeyError: self.values[key] = Unit_var() var = self.values[key] except: raise return copy.deepcopy(var) def set(self, val, struct_id, member_id, channel=0, num=0): key = self.build_key(struct_id, member_id, channel, num) return self.set_by_key(key, val) def set_last_key(self, key): if key.struct_id == protocol.STRUCT_ID_PEQ: self.last_peq_key = key if key.struct_id == protocol.STRUCT_ID_HPF or key.struct_id == protocol.STRUCT_ID_LPF: self.last_xover_key = key return def add_by_key(self, key, delta, factory=False): try: if self.values[key].target_val == None: self.values[key].target_val = self.values[key].read_val if self.values[key].target_val == None: print mytime.displayTime(), 'No base value for', self.parent.MAC return print mytime.displayTime(), 'Setting', self.parent.MAC, 'from', self.values[key].target_val, 'to', self.values[key].target_val + delta self.values[key].target_val = self.values[key].target_val + delta val = self.values[key].target_val if key in self.min: if self.min[key] != None: if val < self.min[key]: val = self.min[key] if key in self.max: if self.max[key] != None: if val > self.max[key]: val = self.max[key] self.set_by_key(key, val, factory=factory, update_target_value=False) return val except KeyError: self.get_list.append(key) return except: print mytime.displayTime(), 'Add value failed for', self.parent.MAC traceback.print_exc(file=sys.stdout) self.get_list.append(key) return return def set_by_key(self, key, val, factory=False, update_target_value=True): if self.parent.action != None and self.parent.action != 'start_bootloader': return else: if key.struct_id == protocol.STRUCT_ID_GLOBAL and key.member_id == protocol.MEMBER_ID_CURRENT_USER: return if key.struct_id == protocol.STRUCT_ID_COMMAND and val == 0: return self.factory = factory try: var = self.values[key] except KeyError: self.values[key] = Unit_var() var = self.values[key] except: raise self.check_vars_delay = 0 if protocol.get_member_format(key.member_id)[-1:] == 's': if key.member_id != protocol.MEMBER_ID_UI_CONTROL: if isinstance(val, unicode): text = val else: try: text = str(val) except: text = 'Encode Error' try: encoded = codecs.charmap_encode(text, 'replace', self.encoding_map) except UnicodeEncodeError, err: encoded = str(err) else: val = encoded[0] try: val = str(val) except: val = '' else: validFilenameChars = unicode('#$%&*"+!?/-_.,^@<>=;:{}[]|() ') + string.ascii_letters + string.digits val = ('').join(c for c in val if c in validFilenameChars) val = val + ' ' val = val[:int(protocol.get_member_format(key.member_id)[:-1])] else: try: val = int(val) except: pass if val != var.read_val or key.member_id == protocol.MEMBER_ID_CHECK_PASSWORD or key.struct_id == protocol.STRUCT_ID_COMMAND: if var.write_val == None: self.setting += 1 var.write_val = val var.set_ts = 0 self.synced = False var.saved_val = var.read_val var.set_time = mytime.clock() var.read_val = None var.read_ts = None var.change_ts = None var.SetCount = 0 if update_target_value == True: var.target_val = val return def choose_var_to_update(self, get=False): if self.parent.action != None and self.parent.action != 'start bootloader standby delay': return else: if get == False: keys = [_[1] for k in self.values.keys() if k[0] >= 0] tmpSynced = True for key in keys: try: var = self.values[key] except: return else: if var.write_val is not None: self.synced = False tmpSynced = False if mytime.clock() - var.set_ts > 0.5: if var.SetCount < 50: var.SetCount = var.SetCount + 1 var.set_ts = mytime.clock() self.synced = False if var.SetCount % 10 == 0: print mytime.displayTime(), self.parent.MAC, 'd_protocol.Still trying to set', protocol.get_strid_text(key.struct_id), protocol.get_member_text(key.member_id), 'channel', key.channel, 'no. ', key.num, 'tried ', var.write_val, ', current value', var.saved_val return key print mytime.displayTime(), self.parent.MAC, 'd_protocol.SET Aborted!!!', protocol.get_strid_text(key.struct_id), protocol.get_member_text(key.member_id), 'channel', key.channel, 'no. ', key.num, 'tried ', var.write_val, ', current value', var.saved_val var.write_val = None var.read_val = var.saved_val self.set_aborted = True self.synced = tmpSynced if len(self.get_list) > 5: self.getIndex += 1 if self.getIndex >= len(self.get_list): self.getIndex = 0 return self.get_list[self.getIndex] if self.MK2 == True: if len(self.get_list) < 100: timeout = 0.1 else: timeout = 1 elif len(self.get_list) < 20: timeout = 0.1 else: timeout = 3 if self.link_type == 'USB': timeout = 1 nowtime = mytime.clock() for key in self.get_list: try: lastGetTime = self.get_time[key] counter = self.get_counter[key] except: self.get_time[key] = nowtime self.get_counter[key] = 0 return key else: if nowtime - lastGetTime < timeout: continue self.get_counter[key] += 1 self.get_time[key] = nowtime if self.get_counter[key] % 50 == 0: print mytime.displayTime(), self.parent.MAC, 'd_protocol.CVTU: Retry getting Key', key, ':', protocol.readable(key), 'Count:', self.get_counter[key] if self.get_counter[key] > 148: print mytime.displayTime(), self.parent.MAC, 'd_protocol.CVTU: Error getting Key', key, ':', protocol.readable(key), ',giving up now!' self.get_counter[key] = 0 self.get_list.remove(key) if key.struct_id == protocol.STRUCT_ID_PRESET_GLOBAL and key.member_id == protocol.MEMBER_ID_SHORT_NAME and key.channel > self.maxNumberOfPresets: print mytime.displayTime(), 'd_p.removing preset', key.channel, self.maxNumberOfPresets self.get_list.remove(key) return key return def percent_vars_to_update(self): if self.parent.action != None: return 100 else: keys = [_[1] for k in self.values.keys() if k[0] >= 0] nitems = len(keys) if nitems == 0: return 100 percent = 0.01 if nitems == 0: return 100 for key in keys: var = self.values[key] if var.write_val is None: percent += 1 return percent / nitems * 99 def process_data_pkt(self, pkt): if self.got_basic_info == False and len(self.get_list) == 0: self.got_basic_info = True self.make_get_list() in_db_value_max = -100 out_db_value_max = -100 db_value_max = None gr_value_max = None try: for (opcode, fragment) in pkt.fragments: if opcode == protocol.OPCODE_ID: if struct.unpack('B', fragment[0])[0] != self.slave_id: return else: if opcode == protocol.OPCODE_LIST_SLAVES: no_of_slaves = struct.unpack('B', fragment[0])[0] if no_of_slaves > 0: self.slave_id = chr(struct.unpack('B', fragment[1])[0]) string = str(mytime.clock()) + ' d_p.Found ' + str(no_of_slaves) + ' RS485 Slave IDs: ' for i in range(0, no_of_slaves): string += str(struct.unpack('B', fragment[1 + i])[0]) + ', ' string = string[:-2] print string return if opcode in (protocol.OPCODE_VU_DATA_IN, protocol.OPCODE_VU_DATA_OUT, protocol.OPCODE_RAW_VU_IN): if opcode == protocol.OPCODE_VU_DATA_IN: self.got_vu = True channel = 0 struct_id = protocol.STRUCT_ID_VU member_id = protocol.MEMBER_ID_VU_IN if opcode == protocol.OPCODE_VU_DATA_OUT: member_id = protocol.MEMBER_ID_VU_OUT channel = 128 if opcode == protocol.OPCODE_RAW_VU_IN: struct_id = protocol.STRUCT_ID_RAW_VU member_id = protocol.MEMBER_ID_RAW_VU_IN if self.parent.global_vu_stereo_out == False and self.parent.global_vu_channels == None: db_value_max = -100 for c in fragment: db_value = struct.unpack('b', c)[0] self.set_read_val(db_value, struct_id, member_id, channel) channel += 1 if db_value > db_value_max: db_value_max = db_value if opcode == protocol.OPCODE_VU_DATA_OUT: out_db_value_max = db_value_max self.set_read_val(db_value_max, protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_VU_OUT, 0, 0) if opcode == protocol.OPCODE_VU_DATA_IN: in_db_value_max = db_value_max self.set_read_val(db_value_max, protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_VU_IN, 0, 0) else: if self.parent.global_vu_stereo_out == True: db_value_max = 0 for c in fragment: db_value = struct.unpack('b', c)[0] self.set_read_val(db_value, struct_id, member_id, channel) if channel == 128: in_db_value_max = db_value if channel == 129: out_db_value_max = db_value channel += 1 if self.parent.global_vu_channels != None: db_value_max = 0 for c in fragment: db_value = struct.unpack('b', c)[0] self.set_read_val(db_value, struct_id, member_id, channel) if channel == self.parent.global_vu_channels[0]: in_db_value_max = db_value if channel == self.parent.global_vu_channels[1]: out_db_value_max = db_value channel += 1 elif opcode in (protocol.OPCODE_GR_DATA_IN, protocol.OPCODE_GR_DATA_OUT): channel = 0 struct_id = protocol.STRUCT_ID_GR member_id = protocol.MEMBER_ID_GR_IN if opcode == protocol.OPCODE_GR_DATA_OUT: member_id = protocol.MEMBER_ID_GR_OUT channel = 128 gr_value_max = 0 for c in fragment: db_value = struct.unpack('b', c)[0] self.set_read_val(db_value, struct_id, member_id, channel) if db_value > gr_value_max: gr_value_max = db_value channel += 1 if opcode == protocol.OPCODE_GR_DATA_OUT: self.set_read_val(gr_value_max, protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_GR_OUT, 0, 0) else: self.set_read_val(gr_value_max, protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_GR_IN, 0, 0) elif opcode == protocol.OPCODE_VU_DATA_READING: channel = 128 struct_id = protocol.STRUCT_ID_VU odd = True for c in fragment: db_value = struct.unpack('B', c)[0] if odd: self.set_read_val(db_value, struct_id, protocol.MEMBER_ID_VOLTAGE_READING, channel) db_value = db_value / 4.0 - 3.75 voltage = math.pow(10, db_value / 20) odd = False else: self.set_read_val(db_value, struct_id, protocol.MEMBER_ID_CURRENT_READING, channel) db_value = db_value / 4.0 - 13.75 current = math.pow(10, db_value / 20) current_db = db_value if current < 0.3: current = 0 db_value = -100 if voltage > 2: try: impedance = voltage / current try: last_impedance = self.last_impedance[channel] impedance = (last_impedance * 99.0 + impedance) / 100 except: self.last_impedance[channel] = impedance self.last_impedance[channel] = impedance impedance = round(impedance, 1) except: try: impedance = self.last_impedance[channel] * 1.01 self.last_impedance[channel] = impedance impedance = round(impedance, 1) except: impedance = '--' else: try: impedance = self.last_impedance[channel] impedance = round(impedance, 1) except: impedance = '--' try: if impedance > 100 and impedance != '--': self.last_impedance[channel] = '--' impedance = '--' except: pass self.set_read_val(str(impedance) + ' Ohm', struct_id, protocol.MEMBER_ID_IMPEDANCE_READING, channel) try: watt = voltage * current watt = 20 * math.log10(watt) except: try: watt = self.values[data_model.Key(struct_id, protocol.MEMBER_ID_POWER_READING, channel, 0)].read_val except: watt = 0 else: if watt == None: watt = 0 elif watt > -1: watt = watt - 5 self.set_read_val(watt, struct_id, protocol.MEMBER_ID_POWER_READING, channel) odd = True channel += 1 elif opcode == protocol.OPCODE_INCLINATION: x = struct.unpack('>h', fragment[0:2])[0] / 100.0 y = struct.unpack('>h', fragment[2:4])[0] / 100.0 z = struct.unpack('>h', fragment[4:6])[0] / 100.0 elif opcode == protocol.OPCODE_ORIENTATION: x = struct.unpack('>h', fragment[0:2])[0] y = struct.unpack('>h', fragment[2:4])[0] z = struct.unpack('>h', fragment[4:6])[0] elif opcode == protocol.OPCODE_TEST_RESULT: one_unit.app.testResult = fragment elif opcode == protocol.OPCODE_GPI: bits = struct.unpack('>L', fragment[0:4])[0] elif opcode == protocol.OPCODE_FOUND_HARDWARE: bits = struct.unpack('>L', fragment[0:4])[0] txt = 'Found Hardware:\n' for bitPos in range(32): bit = 1 << bitPos if bits & bit: if bit in FOUND_HARDWARE_TEXT: txt += '\t' + FOUND_HARDWARE_TEXT[bit] + '\n' else: txt += '\t Unknown Hardware' + hex(bit) + '\n' self.parent.parent.peers.units[self.parent.MAC].foundHardwareString = txt if one_unit.app.mijnpc == True: print mytime.displayTime(), self.parent.MAC, txt elif opcode == protocol.OPCODE_ADC: adcNum = struct.unpack('>B', fragment[0])[0] if adcNum <= 23: val = 1.02 * float(struct.unpack('>H', fragment[1:3])[0]) / 10000 adcName = 'rADC ' + str(adcNum) if adcNum == 19: self.adcRef33Main = val elif adcNum == 22: self.adcRef33Standby = val elif adcNum == 16: val = self.adcRef33Standby - (self.adcRef33Standby - val) * 11 self.set_read_val(val, protocol.STRUCT_ID_ADC_READING, protocol.MEMBER_ID_VSS_READING, 0, 0) elif adcNum == 0: val = val * 5.7 self.set_read_val(val, protocol.STRUCT_ID_ADC_READING, protocol.MEMBER_ID_VCC_READING, 0, 0) elif adcNum == 5: val = val * 5.7 self.set_read_val(val, protocol.STRUCT_ID_ADC_READING, protocol.MEMBER_ID_VD_READING, 0, 0) elif adcNum > 5: self.set_read_val(val, protocol.STRUCT_ID_ADC_READING, protocol.MEMBER_ID_ADC_READING, adcNum - 2, 0) else: self.set_read_val(val, protocol.STRUCT_ID_ADC_READING, protocol.MEMBER_ID_ADC_READING, adcNum - 1, 0) else: adcNum -= 24 if adcNum < 16: val = struct.unpack('>B', fragment[1])[0] self.set_read_val(val, protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_TEMPERATURE, adcNum, 0) val = struct.unpack('>B', fragment[2])[0] self.set_read_val(val, protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_TEMPERATURE, adcNum + 1, 0) else: val = struct.unpack('>B', fragment[1])[0] self.set_read_val(val, protocol.STRUCT_ID_CHANNEL, protocol.MEMBER_ID_TEMPERATURE, adcNum - 16 + 128, 0) val = struct.unpack('>B', fragment[2])[0] self.set_read_val(val, protocol.STRUCT_ID_CHANNEL, protocol.MEMBER_ID_TEMPERATURE, adcNum - 16 + 128 + 1, 0) elif opcode == protocol.OPCODE_RSP: if len(fragment) < 5: print mytime.displayTime() + ' Too small fragment! len=', len(fragment), ', packet discarded' self.parent.invalid_packet_counter = self.parent.invalid_packet_counter + 1 return struct_id = struct.unpack('B', fragment[0])[0] member_id = struct.unpack('B', fragment[1])[0] channel = struct.unpack('B', fragment[2])[0] index = struct.unpack('B', fragment[3])[0] if struct_id == protocol.STRUCT_ID_FIR and member_id & 128 == 128: index = index + 256 * (member_id & 127) member_id = protocol.MEMBER_ID_FIR data_len = len(fragment) - 4 if struct_id == protocol.STRUCT_ID_FIR_BLOCK: if channel not in self.FIRmap: continue FIRmap = self.FIRmap[channel] if index > 0: part = 2 else: part = 1 if part == 1 and data_len / 2 != self.firBlockSize: print mytime.displayTime(), 'FIR block size incorrect!! recalculating FIR map from', self.firBlockSize, 'to', data_len / 2 self.makeFirMap(firBlockSize=data_len / 2) channel = FIRmap[0] index += FIRmap[1] offset = 0 while offset < data_len: val = struct.unpack('>l', fragment[4 + offset:8 + offset])[0] self.set_read_val(val, protocol.STRUCT_ID_FIR, protocol.MEMBER_ID_FIR, channel, index) offset += 4 index += 1 continue try: val = struct.unpack(protocol.get_member_format(member_id), fragment[4:])[0] except: print mytime.displayTime() + ' ERROR: Member ID ', member_id, ' unknown' continue else: self.set_read_val(val, struct_id, member_id, channel, index) elif opcode == protocol.OPCODE_ACTIVITY_LOG: page = ord(fragment[0]) val = fragment[1:] tenDayLogEntries = {} sixteenHourLogEntries = {} oneHourLogEntries = {} sixMinuteLogEntries = {} latest = 0 valid = False try: for i in range(64): if i == 0: if ord(val[0]) in (224, 225): valid = True else: break else: timeCode = ord(val[0]) & 31 if timeCode != 0: if self.isTCS: if self.parent.parent.peers.units[self.parent.MAC].name.lower().find('zwembad') >= 0: averageTemperature = ord(val[1]) / 2.0 peakTemperature = ord(val[1]) / 2.0 averageSignalLevel = ord(val[2]) / 2.0 peakSignalLevel = ord(val[2]) / 2.0 averageGainReduction = ord(val[3]) / 2.0 peakGainReduction = ord(val[3]) / 2.0 print mytime.displayTime(), 'Zwembad activity log', averageSignalLevel, averageGainReduction, averageTemperature else: averageTemperature = ord(val[1]) peakTemperature = ord(val[1]) averageSignalLevel = ord(val[2]) * 10 peakSignalLevel = ord(val[2]) * 10 averageGainReduction = ord(val[3]) * 10 peakGainReduction = ord(val[3]) * 10 else: averageTemperature = (ord(val[1]) & 240) / 16 * 5 + 25 peakTemperature = (ord(val[1]) & 15) * 5 + 25 averageSignalLevel = (ord(val[2]) & 240) / 16 * 6 - 64 peakSignalLevel = (ord(val[2]) & 15) * 6 - 64 averageGainReduction = (ord(val[3]) & 240) / 16 peakGainReduction = ord(val[3]) & 15 statusBits = struct.unpack(' 0: j -= len(logEntries) sortedLogEntries[j] = i tmpLogEntries = {} for j in sorted(sortedLogEntries.keys()): tmpLogEntries[j] = logEntries[sortedLogEntries[j]] logEntries = tmpLogEntries for logEntryNumber in sorted(logEntries.keys(), reverse=True): res = logEntries[logEntryNumber] if printLog: if res[0] & 32 == 0: print mytime.displayTime(), 'Activity log', tmpTitles[entryType], 'entry (newest first), entry number:', res[0] & 31, 'avgT:', res[1], 'pkT:', res[2], 'avgSL:', res[3], 'pkSL:', res[4], 'avgGR:', res[5], 'pkGR:', res[6], 'status:', print [_[1] for i in range(32) if res[7] & 1 << i > 0] else: print mytime.displayTime(), 'Activity log', tmpTitles[entryType], 'entry (newest first), entry number:', res[0] & 31, 'avgT:', res[1], 'pkT:', res[2], 'avgSL:', res[3], 'pkSL:', res[4], 'avgGR:', res[5], 'pkGR:', res[6], 'ERROR:', print [_[2] for i in range(32) if res[7] & 1 << i > 0] one_unit.app.unitLogs[self.parent.MAC][tmpTitles[entryType]].append(res) except: print mytime.displayTime(), 'd_p.aLE.Error:', print [_[3] for c in val[:20]] traceback.print_exc(file=sys.stdout) else: alkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_ACTIVITY_LOG, 0, 0) if alkey in self.get_list: self.get_list.remove(alkey) alkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_ACTIVITY_LOG, 0, page) if alkey in self.get_list: self.get_list.remove(alkey) self.set_read_val(val, protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_ACTIVITY_LOG, 0, page) else: print mytime.displayTime(), 'Unknown opcode', opcode self.parent.invalid_packet_counter = 0 except: traceback.print_exc(file=sys.stdout) if db_value_max != None: if in_db_value_max > 24: in_db_value_max = 24 if out_db_value_max > 24: out_db_value_max = 24 server.unit_data.vu[self.parent.MAC] = ( in_db_value_max, out_db_value_max) if gr_value_max != None: server.unit_data.gr[self.parent.MAC] = gr_value_max return def set_read_val(self, val, struct_id, member_id, channel=0, num=0): if self.parent.action != None and self.parent.action != 'start bootloader standby delay': return else: if member_id == protocol.MEMBER_ID_BUILD_NUMBER: self.parent.parent.peers.units[self.parent.MAC].BuildNumber = str(val) try: self.buildNumber = int(val) except: pass else: if val < 40190: bnkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_MODEL_NUMBER, 0, 0) while bnkey in self.get_list: self.get_list.remove(bnkey) if bnkey not in self.values: self.values[bnkey] = Unit_var() self.values[bnkey].read_val = -1 if val >= 41995 and self.MK2 == True and self.parent.parent.peers.units[self.parent.MAC].link_type == 'Ethernet': alkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_ACTIVITY_LOG, 0, 0) if alkey not in self.values: self.get_list.append(alkey) print mytime.displayTime(), 'd_p.appended key for activity log and getting 512 UI key in basic info data!!' ui = 511 while ui >= 0: key = data_model.Key(protocol.STRUCT_ID_UI_CONTROL, protocol.MEMBER_ID_UI_CONTROL, int(ui) / 256, int(ui) % 256) self.get_list.append(key) ui -= 1 if member_id == protocol.MEMBER_ID_SW_VERSION: if val != None: high = int(val / 65536) mid = int((val - high * 65536) / 256) low = int(val - high * 65536 - mid * 256) FWVersion = str(high) + '.' + str(mid) + '.' + str(low) self.parent.parent.peers.units[self.parent.MAC].FWVersion = FWVersion self.parent.parent.peers.units[self.parent.MAC].numericalFWVersion = val if int(val) < self.parent.parent.peers.units[self.parent.MAC].minBuildNumberVersion: bnkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_BUILD_NUMBER, 0, 0) while bnkey in self.get_list: self.get_list.remove(bnkey) if bnkey not in self.values: self.values[bnkey] = Unit_var() self.values[bnkey].read_val = 0 self.parent.parent.peers.units[self.parent.MAC].BuildNumber = '0' if int(val) < self.parent.parent.peers.units[self.parent.MAC].minPINVersion: bnkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_PIN, 0, 0) while bnkey in self.get_list: self.get_list.remove(bnkey) if bnkey not in self.values: self.values[bnkey] = Unit_var() self.values[bnkey].read_val = 0 if int(val) < self.parent.parent.peers.units[self.parent.MAC].minModelFirmwareVersion: bnkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_MODEL_NUMBER, 0, 0) while bnkey in self.get_list: self.get_list.remove(bnkey) if bnkey not in self.values: self.values[bnkey] = Unit_var() self.values[bnkey].read_val = -1 if int(val) < self.parent.parent.peers.units[self.parent.MAC].minModelFirmwareVersion: bnkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_MODEL_FIRMWARE, 0, 0) while bnkey in self.get_list: self.get_list.remove(bnkey) if bnkey not in self.values: self.values[bnkey] = Unit_var() self.values[bnkey].read_val = 0 else: key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_BUILD_NUMBER, 0, 0) if key not in self.values: self.config_vars.append(key) if struct_id == protocol.STRUCT_ID_PRESET_GLOBAL and member_id == protocol.MEMBER_ID_SHORT_NAME and num > 0: self.maxNumberOfPresets = num num = 0 key = Key(struct_id, member_id, channel, num) if struct_id == protocol.STRUCT_ID_GLOBAL and member_id == protocol.MEMBER_ID_SHORT_NAME: self.parent.parent.peers.set_unit_name(self.parent.MAC, val) now = mytime.clock() try: var = self.values[key] except KeyError: self.values[key] = Unit_var() var = self.values[key] var.read_val = val var.read_ts = now except: raise try: if struct_id == protocol.STRUCT_ID_PRESET_GLOBAL and member_id == protocol.MEMBER_ID_SHORT_NAME and channel > 0: if ord(val[0]) == 0: for v in val: presetNumber = ord(v) if presetNumber != 0: self.set_read_val('Empty ', struct_id, member_id, channel=presetNumber) val = 'Empty ' except: traceback.print_exc(file=sys.stdout) if self.Connected == True and self.LinkStatus == False: self.LinkStatus = True self.SyncIndicateActive = True if var.write_val is not None: alternative_val = None write_val = 1 if struct_id == protocol.STRUCT_ID_GLOBAL and member_id == protocol.MEMBER_ID_HARDWARE_STATUS_FLAGS: alternative_val = val & (4294967295L ^ protocol.HARDWARE_STATUS_FLAGS_READ_ONLY_MASK) write_val = var.write_val & (4294967295L ^ protocol.HARDWARE_STATUS_FLAGS_READ_ONLY_MASK) if var.write_val == val or write_val == alternative_val: if one_unit.app.mijnpc: if struct_id == protocol.STRUCT_ID_UI_CONTROL: print mytime.displayTime() + ' ' + self.parent.MAC + ' Unit SET Ok: ' + protocol.get_strid_text(struct_id) + ' ' + protocol.get_member_text(member_id) + ' channel ' + str(channel) + ' no. ' + str(num) + ' set to ' + str([_[1] for c in val]) + ' (' + str(int(round(mytime.clock() - var.set_time, 3) * 1000)) + 'ms, ' + str(var.SetCount - 1) + ' retries)' elif member_id == protocol.MEMBER_ID_USER_ACCESS_RIGHTS: print mytime.displayTime() + ' ' + self.parent.MAC + ' Unit SET Ok: ' + protocol.get_strid_text(struct_id) + ' ' + protocol.get_member_text(member_id) + ' channel ' + str(channel) + ' no. ' + str(num) + ' set to ' + hex(int(val)) + ' (' + str(int(round(mytime.clock() - var.set_time, 3) * 1000)) + 'ms, ' + str(var.SetCount - 1) + ' retries)' elif member_id & 128 == protocol.MEMBER_ID_FIR: firBlock = self.firStartBlockByChannel[channel] + num / self.firBlockSize if num == 0 or num == self.firBlockSize / 2: print mytime.displayTime() + ' ' + self.parent.MAC + ' Unit SET Ok: FIR Half Block ' + str(firBlock) + '.' + str(num / (self.firBlockSize / 2)) + ' channel ' + str(channel) + ' (' + str(int(round(mytime.clock() - var.set_time, 3) * 1000)) + 'ms, ' + str(var.SetCount - 1) + ' retries)' else: print mytime.displayTime() + ' ' + self.parent.MAC + ' Unit SET Ok: ' + protocol.get_strid_text(struct_id) + ' ' + protocol.get_member_text(member_id) + ' channel ' + str(channel) + ' no. ' + str(num) + ' set to ' + str(val) + ' (' + str(int(round(mytime.clock() - var.set_time, 3) * 1000)) + 'ms, ' + str(var.SetCount - 1) + ' retries)' var.write_val = None var.read_val = val var.SetCount = 0 self.setting -= 1 else: timeout = 10 if self.MK2 == True or mytime.clock() - var.set_ts > timeout or now < 10: var.write_val = None if key.member_id == protocol.MEMBER_ID_AMP_READINGS: tempkey = data_model.Key(key.struct_id, key.member_id, 130, 0) tempval = int(val) >> 8 & 255 self.parent.parent.peers.set_by_key(self.parent.MAC, tempkey, tempval) try: temp = self.values[tempkey].read_val except KeyError: self.values[tempkey] = Unit_var() else: self.values[tempkey].read_val = tempval tempkey = data_model.Key(key.struct_id, key.member_id, 129, 0) tempval = int(val) >> 16 & 255 self.parent.parent.peers.set_by_key(self.parent.MAC, tempkey, tempval) try: temp = self.values[tempkey].read_val except KeyError: self.values[tempkey] = Unit_var() else: self.values[tempkey].read_val = tempval self.values[tempkey].read_val = tempval tempkey = data_model.Key(key.struct_id, key.member_id, 128, 0) tempval = int(val) >> 24 & 255 self.parent.parent.peers.set_by_key(self.parent.MAC, tempkey, tempval) try: temp = self.values[tempkey].read_val except KeyError: self.values[tempkey] = Unit_var() else: self.values[tempkey].read_val = tempval self.values[tempkey].read_val = tempval val = int(val) & 255 if key.member_id == protocol.MEMBER_ID_AMP_READINGS_2: tempkey = data_model.Key(key.struct_id, key.member_id, 0, 0) tempval = int(val) >> 8 & 255 self.parent.parent.peers.set_by_key(self.parent.MAC, tempkey, tempval) try: temp = self.values[tempkey].read_val except KeyError: self.values[tempkey] = Unit_var() else: self.values[tempkey].read_val = tempval self.values[tempkey].read_val = tempval tempkey = data_model.Key(key.struct_id, key.member_id, 0, 1) tempval = int(val) >> 16 & 255 self.parent.parent.peers.set_by_key(self.parent.MAC, tempkey, tempval) try: temp = self.values[tempkey].read_val except KeyError: self.values[tempkey] = Unit_var() else: self.values[tempkey].read_val = tempval self.values[tempkey].read_val = tempval tempkey = data_model.Key(key.struct_id, key.member_id, 0, 2) tempval = int(val) >> 24 & 255 self.parent.parent.peers.set_by_key(self.parent.MAC, tempkey, tempval) try: temp = self.values[tempkey].read_val except KeyError: self.values[tempkey] = Unit_var() else: self.values[tempkey].read_val = tempval self.values[tempkey].read_val = tempval val = int(val) & 255 var.read_val = val var.read_ts = now self.parent.parent.peers.set_by_key(self.parent.MAC, key, val) while key in self.get_list: self.get_list.remove(key) try: self.get_time[key] = 0 self.get_counter[key] = 0 except: pass if struct_id == protocol.STRUCT_ID_MUTE: muted = True listed = False if self.parent.mute_channels == None: if key.channel == 0: listed = True if self.values[key].read_val == 0: muted = False if self.values[key].read_val == None: listed = False elif key.channel in self.parent.mute_channels: listed = True for channel in self.parent.mute_channels: testKey = data_model.Key(protocol.STRUCT_ID_MUTE, protocol.MEMBER_ID_MUTE, channel, 0) if testKey not in self.values or self.values[testKey].read_val == None: listed = False continue if self.values[testKey].read_val == 0: muted = False break if listed == True: self.muted = muted self.parent.parent.peers.units[self.parent.MAC].Muted = str(self.muted) return def getVarsForCommand(self, packetLen): if packetLen > 50 and len(self.get_list) > 5: key = self.choose_var_to_update(get=True) if key == None: return (None, None) if key in data_model.GET_replace_list: key = data_model.GET_replace_list[key] if key.member_id in (protocol.MEMBER_ID_AMP_READINGS, protocol.MEMBER_ID_AMP_READINGS_2): key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_CURRENT_USER, 0, 0) if key in self.commandKeys: return (None, None) return (key, None) else: key = self.choose_var_to_update() if key == None: return (None, None) if key in self.values: val = self.values[key].write_val else: val = None if val == None: if key in data_model.GET_replace_list: key = data_model.GET_replace_list[key] if key.member_id in (protocol.MEMBER_ID_AMP_READINGS, protocol.MEMBER_ID_AMP_READINGS_2): key = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_CURRENT_USER, 0, 0) return ( key, val) def build_command(self, HW_id, my_id): """Build a command for reading and optionally writing to interface variables. Computes checksum, prepents length.""" cmd = chr(5) + 'DDJ' packetLen = 4 self.commandKeys = [] if self.MK2 == True: maxLen = 768 else: maxLen = 16 if self.check_vars_delay <= 0: self.check_vars_delay = CHOOSE_VAR_TO_UPDATE_SKIP_CYCLES while packetLen < maxLen: try: (k, v) = self.getVarsForCommand(packetLen) except: traceback.print_exc(file=sys.stdout) if k == None: break self.commandKeys.append(k) (struct_id, member_id, channel, index) = k if channel is None or channel < 0: print mytime.displayTime() + ' d_p.bc.polluted cache: channel =', channel channel = 0 v = None if v is None: opcode = protocol.OPCODE_GET if struct_id == protocol.STRUCT_ID_FIR and member_id & 128 == 128: if self.buildNumber > 44356: if channel not in self.firStartBlockByChannel or self.firBlockSize < 2: if self.full_config != None: print mytime.displayTime(), 'd_p.bc.FIR map Get error for channel', channel, '-> probeer FIR map te maken', self.firStartBlockByChannel try: self.makeFirMap() mytime.sleep(0.1) if one_unit.app.application_stopping: return cmd except: print mytime.displayTime(), 'd_p.failed to make FIR map' traceback.print_exc(file=sys.stdout) continue try: startBlock = self.firStartBlockByChannel[channel] inIndex = index channel = startBlock + index / self.firBlockSize blockIndex = index / (self.firBlockSize / 2) * (self.firBlockSize / 2) if index != blockIndex: safeRemove(self.get_list, k) continue index = blockIndex struct_id = protocol.STRUCT_ID_FIR_BLOCK index = index % self.firBlockSize except: print mytime.displayTime(), 'd_p. FIR map command error' traceback.print_exc(file=sys.stdout) continue else: findex = index index = findex % 256 member_id += findex / 256 if member_id >= 1000: try: self.get_list.remove(k) except: pass else: continue try: cmd += ('').join([_[1] for i in (opcode, 7, struct_id, member_id, channel, index)]) + 'j' except: print mytime.displayTime(), 'd_p. error building command', opcode, struct_id, member_id, channel, index traceback.print_exc(file=sys.stdout) else: packetLen += 7 else: opcode = protocol.OPCODE_SET if self.factory == True: opcode = protocol.OPCODE_FACTORY if struct_id == protocol.STRUCT_ID_FIR and member_id & 128 == 128: if self.buildNumber > 44356: if channel not in self.firStartBlockByChannel: print mytime.displayTime(), 'd_p.bc.FIR map Set error for channel', channel, '-> aborting', self.firStartBlockByChannel continue try: startBlock = self.firStartBlockByChannel[channel] if packetLen + 6 + self.firBlockSize / 2 * 4 > maxLen: break process = startBlock + index / self.firBlockSize index = index / (self.firBlockSize / 2) * (self.firBlockSize / 2) struct_id = protocol.STRUCT_ID_FIR_BLOCK new_val = '' for i in range(self.firBlockSize / 2): key = data_model.Key(protocol.STRUCT_ID_FIR, protocol.MEMBER_ID_FIR, channel, index + i) try: var = self.values[key] v = var.write_val if v == None: v = var.read_val else: var.SetCount = var.SetCount + 1 var.set_ts = mytime.clock() if v == None: print mytime.displayTime(), 'd_p.bc. FIR block: No write val, no read val for key', key, ', defaulting to 0' v = 0 except: v = 0 new_val += struct.pack('>l', v) sentIndex = index % self.firBlockSize cmd += ('').join([_[2] for i in (opcode, 6 + len(new_val) / 4, struct_id, member_id, process, sentIndex)]) + new_val packetLen += 6 + len(new_val) continue except: print mytime.displayTime(), 'd_p. FIR map command error' traceback.print_exc(file=sys.stdout) continue else: findex = index index = findex % 256 member_id += findex / 256 new_val = struct.pack(protocol.get_member_format(member_id), v) else: new_val = struct.pack(protocol.get_member_format(member_id), v) cmd += ('').join([_[3] for i in (opcode, 6 + len(new_val), struct_id, member_id, channel, index)]) + new_val packetLen += 6 + len(new_val) else: self.check_vars_delay -= 1 if packetLen > 4: decoded_buf = '' i = 0 for encoded_byte in cmd[4:]: decoded_byte = ord(encoded_byte) ^ CodeTable[i % 32] i += 1 decoded_buf += chr(decoded_byte) cmd = cmd[:4] + decoded_buf cmd += chr(253) + chr(HW_id) + chr(255) + chr(my_id) if self.MK2 == True: cmd = chr(packetLen / 256) + chr(packetLen % 256) + cmd[2:] cs = Checksum() cs.add(cmd) cmd += cs.get() return cmd def print_hex(cmd): s = '' for c in cmd: s += hex(ord(c)) + ':' s = s[:-1] return s class Announcement(): """The announcement broadcast by hardware units over USB""" def __init__(self): """Constructor""" self.UnitType2 = None self.UnitType1 = None self.MAC = None self.PC_PacketId = None self.HW_PacketId = None self.skin_high = None self.skin_mid = None self.skin_low = None self.broadcasted_skin = None self.MK2 = False return def __str__(self): return 'Announcement(%s, Type1=%s, Type2=%s)' % (self.MAC, self.UnitType1, self.UnitType2) class Data_packet(): """The announcement broadcast by hardware units over USB""" def __init__(self): """Constructor""" self.fragments = [] self.PC_PacketId = None self.HW_PacketId = None self.invalid_packet_counter = 0 self.MK2 = False return def __str__(self): return 'Data_packet ' class NACK_packet(): """The packet is sent by the HW unit to indicate that it was not able to process the latest command from me for whatever internal reason. The command can be repeated, the sequence numbers in the session should not change.""" def __init__(self): """Constructor""" self.PC_PacketId = None self.HW_PacketId = None self.MK2 = False return def __str__(self): return 'NACK packet ' class Checksum(): """This one-byte checksum helps ensuring the data integrity in communication between hardware units and our software. """ def __init__(self): self.cs = 170 return def add(self, s): """Update the checksum with the string 's'.""" for c in s: self.cs ^= ord(c) return def get(self): """Get the accumulated checksum as a character.""" return chr(self.cs) def parse_announce(data): """Parse the data sent by MakeConfigData(void) in DDEthernet.c, line 537. This data can be found in UDP broadcasts and in TCP responces to the 'J' command from the user. """ if len(data) < 42 or data[41] != 'Q' or data[:3] != 'DDB': return None else: res = Announcement() res.UnitType2 = ord(data[4]) res.UnitType1 = ord(data[5]) res.MAC = data[6:22] res.PC_PacketID = ord(data[39]) res.HW_PacketID = ord(data[40]) res.skin_high = ord(data[33]) res.skin_mid = ord(data[34]) res.skin_low = ord(data[35]) res.broadcasted_skin = '' res.broadcasted_skin += chr(ord('0') + res.skin_high) + '_' + chr(ord('0') + res.skin_mid) + '_' + chr(ord('0') + res.skin_low) return res def parse_NACK(data): if len(data) < 42 or data[41] != 'Q' or data[:3] != 'DDN' and data[:3] != 'DDM': return None else: res = NACK_packet() res.PC_PacketID = ord(data[39]) res.HW_PacketID = ord(data[40]) return res def parse_data_packet(data, length=32): res = Data_packet() if data[:3] == 'DDA': res.PC_PacketID = ord(data[39]) res.HW_PacketID = ord(data[40]) if len(data) < length + 10 or data[length + 9] != 'Q' or data[:3] != 'DDA': res.invalid_packet_counter = 1 return res try: if length == 32: if ord(data[3]) == 233: if ord(data[4]) == 213: opcode = 9 else: opcode = 5 try: next_opcode = ord(data[ord(data[4]) + 3]) if next_opcode == 2: opcode = 1 if next_opcode == 8: opcode = 7 except: pass new_data = data[:3] + chr(opcode) + data[4:] data = new_data except: pass else: pos = 3 elif data[:3] == 'DDW': res.PC_PacketID = ord(data[7]) res.HW_PacketID = ord(data[8]) res.MK2 = True pos = 10 else: print mytime.displayTime() + ' Got strange packet:' print mytime.displayTime() + (' ').join([_[1] for c in data[:len(data)]]) return checksum_ok = False while pos + 2 < len(data): opcode = ord(data[pos]) pos += 1 if opcode == protocol.OPCODE_DATA_END: break elif opcode == protocol.OPCODE_CHECKSUM: checksum = 213 if data[:3] == 'DDA': for i in range(3, pos - 1): checksum = checksum ^ ord(data[i]) else: for i in range(10, pos - 1): checksum = checksum ^ ord(data[i]) result = checksum - ord(data[pos]) pos += 1 if result != 0: res.fragments = [] res.invalid_packet_counter = res.invalid_packet_counter + 1 print mytime.displayTime() + ' Checksum error, packet discarded' return res checksum_ok = True continue elif opcode == protocol.OPCODE_ACTIVITY_LOG: size = 513 res.fragments.append((opcode, data[pos:pos + size])) pos += 513 continue elif opcode in (protocol.OPCODE_ADC, protocol.OPCODE_TEST_RESULT): size = ord(data[pos]) pos += 1 size -= 2 if size < 1: print mytime.displayTime() + ' Too small fragment 2, opcode: ', opcode, ' size:', size + 2, ',data:', print (' ').join([_[2] for c in data[:len(data)]]) res.fragments = [] res.invalid_packet_counter = res.invalid_packet_counter + 1 return res if pos + size >= len(data): res.invalid_packet_counter = res.invalid_packet_counter + 1 res.fragments = [] return res res.fragments.append((opcode, data[pos:pos + size])) pos += size else: size = ord(data[pos]) pos += 1 if opcode == protocol.OPCODE_RSP: strid = ord(data[pos]) if strid == protocol.STRUCT_ID_FIR_BLOCK: size = (size - 6) * 4 + 6 size -= 2 if size < 1: print mytime.displayTime() + ' Too small fragment 3, opcode: ', opcode, ' size:', size + 2, ',data:', print (' ').join([_[3] for c in data[:len(data)]]) res.fragments = [] res.invalid_packet_counter = res.invalid_packet_counter + 1 return res if pos + size >= len(data): res.invalid_packet_counter = res.invalid_packet_counter + 1 res.fragments = [] return res res.fragments.append((opcode, data[pos:pos + size])) pos += size if checksum_ok != True: res.fragments = [] res.invalid_packet_counter = res.invalid_packet_counter + 1 return res def setkeepalives(sck): sck.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) return def read_packet(ser): buf = '' try: waiting = ser.inWaiting() if waiting < 42: return buf = ser.read(42) return parse_packet(buf) except: return return def readableErrorcode(code): if code == 1: return '1: response_len < 9' if code == 2: return '2: validLen != response_len-5' if code == 3: return "3: nw_rx_buffer[3]!='J'" if code == 4: return '4: Checksum failed' if code == 5: return '5: response_len>1200' if code == 7: return '7: send while send_flag True' return str(code) + ': unregistered error' def parse_packet(buf, length=32): if buf.find('DD') < 0: buf = '' return else: if buf[:3] == 'DDW': length += 10 if length < 12: return if length - 10 != 256 * ord(buf[8]) + ord(buf[9]) or length != len(buf): return try: decoded_buf = buf[:10] for i in range(10, length): decoded_byte = ord(buf[i]) ^ CodeTable[(i - 10) % 34] decoded_buf += chr(decoded_byte) except: traceback.print_exc(file=sys.stdout) return else: try: pkt = parse_data_packet(decoded_buf + 'Q', length) except: traceback.print_exc(file=sys.stdout) return if pkt == None: return return pkt if buf[length + 9] != 'Q': if len(buf) == 10 and buf[:3] == 'DDN': errorcode = ord(buf[5]) errornumber1 = ord(buf[6]) * 256 + ord(buf[7]) errornumber2 = ord(buf[8]) * 256 + ord(buf[9]) return return pkt = None if buf[:3] == 'DDB': pkt = parse_announce(buf) elif buf[:3] == 'DDA' or buf[:3] == 'DDN': try: if ord(buf[3]) == 0 and ord(buf[4]) == 0: packet_empty = True else: packet_empty = False decoded_buf = '' i = 0 for encoded_byte in buf[3:length + 7]: if packet_empty: decoded_byte = 0 else: decoded_byte = ord(encoded_byte) ^ CodeTable[i] i += 1 if i > 31: i = 0 decoded_buf += chr(decoded_byte) buf = 'DDA' + decoded_buf + buf[length + 7:] except: traceback.print_exc(file=sys.stdout) else: try: pkt = parse_data_packet(buf, length) except: traceback.print_exc(file=sys.stdout) else: if pkt == None: return elif buf[:3] == 'DDN': return if buf[:3] == 'DDC': pkt = parse_NACK(buf) elif buf[:3] == 'DDM': pkt = parse_NACK(buf) else: return return pkt # okay decompiling pycode/d_protocol.pyc