async def change_button(caller, xml):
"""
#<change_button btn_id="btn_pwd" attr="enable" value="true"/>
<change_button>
<btn_enabled btn_id="btn_pwd" value="true"/>
</change_button>
"""
change = xml[0]
button = caller.btn_dict[change.get('btn_id')]
if debug:
log.write(f'CHG BUT {change.attrib} {button.ref} {change.tag}\n\n')
if change.tag == 'btn_label':
attr_name = 'label'
attr_value = change.get('value')
if change.tag == 'font_weight':
attr_name = 'weight'
attr_value = change.get('value')
elif change.tag == 'btn_dflt':
attr_name = 'default'
attr_value = None
elif change.tag == 'btn_enabled':
attr_name = 'enabled'
attr_value = change.get('state') == 'true'
elif change.tag == 'btn_show':
attr_name = 'show'
attr_value = change.get('state') == 'true'
button.change_button(attr_name, attr_value)
async def case(caller, xml):
for child in xml:
if child.tag == 'default' or await globals()[child.tag](caller, child):
for step in child:
if debug: log.write('STEP {} {}\n\n'.format(caller, step.tag))
await globals()[step.tag](caller, step)
break
def open_automation(self, port_number):
if (not self.is_AUTO_port_ready()): return False
# 1 - UART 0 (GSM)
# 2 - UART 1 (PLink)
if port_number.upper() == "GSM":
port_number = 1
elif port_number.upper() == "PLINK":
port_number = 2
else:
log.write("Wrong port")
return False
if not (self.open_test_mode()):
log.write("Can't open test mode")
return False
packet = prutils.make_f0_packet(
2, 55, "\x00\x3B\xFF\x01\x00\x00\x00" + chr(port_number))
self._Communicator.send(packet)
result = self._Communicator.wait(0x01, 3)
if result:
result = self._Communicator.wait(0x04, 3, 5)
if result and ord(result[6]) == 55:
result = True
time.sleep(1)
self.close_test_mode()
return result
def get_all_devices(self):
if len(self._devices_pool) == 0:
log.write("No devices was registered")
return None
for device in self._devices_pool:
self._print_device_info(device)
return self._devices_pool
def send_file_body(self,
long_id,
short_id,
image_data,
film_id,
row,
sequence=-1): # reply with file body
file_block = 0
if not image_data:
return False
chunk_size = 176 # packet size = 0xC0
offset = 0
# sent_data = ''
while (offset < len(image_data)):
if len(image_data) - offset > chunk_size:
bytes_to_send = chunk_size
else:
bytes_to_send = len(image_data) - offset
packet = dpr.file_block(long_id, short_id,
image_data[offset:offset + bytes_to_send],
film_id, row, file_block, sequence)
# sent_data += image_data[offset: offset + bytes_to_send]
file_block += 1
offset += bytes_to_send
self._Communicator.send(packet)
log.write("File block[%d], size:%d" % (file_block, bytes_to_send))
def remove_device(self, short_id):
remove_result = False
if (not self.is_AUTO_port_ready()): return False
remove_packet = prutils.make_f0_packet(2, 54, chr(short_id))
#log.write(prutils.hexdump(remove_packet))
if not (self.open_test_mode()):
log.write("Can't open test mode")
return False
self._Communicator.send(remove_packet)
result = self._Communicator.wait(0x01, 3)
if result:
#0D F0 04 43 00 02 36 01 09 91 0A
result = self._Communicator.wait(0x04, 3)
if result and (ord(result[6]) == 54):
if (ord(result[7]) == 1):
remove_result = True
#pc_ack = "\xF0\x01\x00\x00\x00"
#pc_ack = '\x0D' + pc_ack + prutils.num_to_chars(prutils.crc16_F0(remove_packet), 2, 0) + '\x0A'
#self._Communicator.send(ack)
#log.write("ACK")
time.sleep(1)
self.close_test_mode()
return remove_result
def remove_device(self, short_id):
remove_result = False
if (not self.is_AUTO_port_ready()): return False
remove_packet = prutils.make_f0_packet(2, 54, chr(short_id))
#log.write(prutils.hexdump(remove_packet))
if not (self.open_test_mode()):
log.write("Can't open test mode")
return False
self._Communicator.send(remove_packet)
result = self._Communicator.wait(0x01, 3)
if result :
#0D F0 04 43 00 02 36 01 09 91 0A
result = self._Communicator.wait(0x04, 3)
if result and (ord(result[6]) == 54):
if(ord(result[7]) == 1):
remove_result = True
#pc_ack = "\xF0\x01\x00\x00\x00"
#pc_ack = '\x0D' + pc_ack + prutils.num_to_chars(prutils.crc16_F0(remove_packet), 2, 0) + '\x0A'
#self._Communicator.send(ack)
#log.write("ACK")
time.sleep(1)
self.close_test_mode()
return remove_result
def open_automation(self, port_number):
if (not self.is_AUTO_port_ready()): return False
# 1 - UART 0 (GSM)
# 2 - UART 1 (PLink)
if port_number.upper() == "GSM":
port_number = 1
elif port_number.upper() == "PLINK":
port_number = 2
else:
log.write("Wrong port")
return False
if not (self.open_test_mode()):
log.write("Can't open test mode")
return False
packet = prutils.make_f0_packet(2, 55, "\x00\x3B\xFF\x01\x00\x00\x00" + chr(port_number))
self._Communicator.send(packet)
result = self._Communicator.wait(0x01, 3)
if result:
result = self._Communicator.wait(0x04, 3, 5)
if result and ord(result[6]) == 55:
result = True
time.sleep(1)
self.close_test_mode()
return result
def run(self):
while (not self._stop_needed):
log.write(self.NAME + " > ", "nolog")
command = raw_input()
self._execute_command(command)
if command.strip().upper() == "EXIT":
self._xmlrpc.stop()
break
def run(self):
while (not self._stop_needed):
log.write(self.NAME + " > " , "nolog")
command = raw_input()
self._execute_command(command)
if command.strip().upper() == "EXIT":
self._xmlrpc.stop()
break
def get_lcd(self):
msg = '\xF2\x03\x00\x00\x00'
msg = '\x0D' + msg + crc16(msg) + '\x0A'
self._Procedures._Communicator.send(msg)
ans = self._Procedures._Communicator.wait(0x01)
if ans:
log.write("get_lcd:%s" % self.extract_lcd(ans))
return self.extract_lcd(ans)
return ''
def _wrapper(self, *params):
device = self._find_device(int(params[0], 0), int(params[1],0))
if(device):
log.write("Waiting for transmitter delay end...")
# this one is virtual device, check if it in transmitter delay now
while device.get_transmitter_delay_flag() == True:
time.sleep(0.1)
device.set_transmitter_delay()
return cmd_function(self, *params)
def check_devices_modes(self, expected_mode):
result = ''
for device in self._devices_pool:
mode = device.get_device_state()
if mode.upper() != expected_mode.upper():
log.write("Device [%d] mode = %s" % (device._short_id, mode))
if result:
result += "," + str(device._short_id)
else:
result = str(device._short_id)
return result
def send_key(self, name, plcd='', timeout=0.5):
prev_lcd = plcd
if prev_lcd == '':
prev_lcd = self.get_lcd()
log.write("send key:%s" % name)
if name.isdigit():
self.send_auto_cmd('1', name)
elif name.upper() == 'NEXT':
self.send_auto_cmd('1', '0x12')
elif name.upper() == 'OK':
self.send_auto_cmd('1', '0x10')
elif name.upper() == 'AWAY':
self.send_auto_cmd('1', '0x0A')
elif name.upper() == 'HOME':
self.send_auto_cmd('1', '0x0B')
elif name.upper() == 'OFF':
self.send_auto_cmd('1', '0x0C')
elif name == '*':
self.send_auto_cmd('1', '0x0D')
elif name == '#':
self.send_auto_cmd('1', '0x0E')
elif name.upper() == 'BACK':
self.send_auto_cmd('1', '0x0F')
elif name.upper() == 'PANIC':
self.send_auto_cmd('1', '0x11')
elif name.upper() == 'RECORD_OFF':
self.send_auto_cmd('1', '0x13')
elif name.upper() == 'FIRE':
self.send_auto_cmd('1', '0x14')
elif name.upper() == 'EMERGENCY':
self.send_auto_cmd('1', '0x15')
else:
return False
# key_pressed = False
# ans = self._Procedures._Communicator.wait(0x03, 0.2)
# if ans and ord(ans[6]) == 14:
# log.write("key pressed")
# key_pressed = True
# ans = self._Procedures._Communicator.wait(0x01, timeout)
# if ans:
# if self.extract_lcd(ans) == prev_lcd:
# ans = self._Procedures._Communicator.wait(0x01, 0.5)
# if not ans:
# return self.send_key(name, prev_lcd)
# log.write("got lcd:%s" % self.extract_lcd(ans))
# return self.extract_lcd(ans)
# else:
# if not key_pressed:
# return self.send_key(name, prev_lcd)
# else:
# ans = self._Procedures._Communicator.wait(0x01, 0.5)
return
def get_lcd(self):
msg = '\xF2\x03\x00\x00\x00'
msg = '\x0D' + msg + crc16(msg) + '\x0A'
self._Procedures._Communicator.send(msg)
ans = self._Procedures._Communicator.wait(0x01)
if ans:
lcd = self.extract_lcd(ans)
lcd = lcd.replace(chr(0xff), '#')
log.write("get_lcd:%s" % lcd)
# return lcd.decode('cp866')
return lcd
return ''
def get_all_devices(self):
devices = []
if len(self._devices_pool) == 0:
log.write("No devices was registered")
return None
for device in self._devices_pool:
dinfo = dict(zip(['type', 'num','sid', 'lid'],\
[str(device._dev_type), str(device._dev_num), str(device._short_id), str(device._long_id)]))
devices.append(dinfo)
self._print_device_info(device)
return devices
def enroll_to_zone(self, long_id, dev_type, zone_num):
# non works on the GSM automation
if (not self.is_AUTO_port_ready()): return False
if (dev_type.upper() in _DeviceType):
dev_type = _DeviceType[dev_type.upper()]
else:
log.wrte("Incorrect device type specified")
return -1
if not (self.open_test_mode()):
log.write("Can't open test mode")
return -1
ack = '\x0D\xF0\x01\x43\x00\x00\x80\x40\x0A'
enroll = '\x0D\xF0\x02\x00\x00\x26\x33\x01' + chr(zone_num) + '\x22\x41' + prutils.num_to_chars(long_id, 4, 0) + \
'\x32\x01\x00\x00\x08\x00' + dev_type + \
'\x01\x14\x03\x00\x00\x01\x03\x00\x00\x00\x02\x07\x00\x70\x09\x28\x03\x08\x01\xC7\x0A'
crc = prutils.crc16_F0(enroll[1:])
enroll = enroll + prutils.num_to_chars(crc, 2, 0) + '\x0A'
# enroll = dpr.enroll_F0(long_id, dev_type, zone_num)
short_id = -1
self._Communicator.send(enroll)
result = self._Communicator.wait(0x01, 3)
if result and result == ack :
result = self._Communicator.wait(0x04, 10) # enroll answer
if result:
if ord(result[7]) != 1:
log.write('Device rejected')
else:
short_id = ord(result[13])
self._Communicator.send(ack)
log.write('ShortId=%d' % short_id)
else:
log.write('Can\'t enroll device, no answer')
else:
log.write('Can\'t enroll device, no ACK')
self.close_test_mode()
return short_id
pass
def _change_panel_state(self, short_id, long_id, partition, action, user_code):
long_id = int(long_id, 0)
short_id = int(short_id, 0)
#convert partiton from number to bitmap
partition = int(partition, 0)
if(partition):
part_bitmap = 1<<(partition - 1)
else:
part_bitmap = partition
#action = int(action, 0)
user_code = int(user_code, 0)
log.write("part_bitmap=" + str(part_bitmap))
result = self._Procedures.change_panel_state(long_id, short_id, part_bitmap, action, user_code)
def OnSaveAs(self, event):
dlg = SaveAsDialog()
dlg.ShowModal()
if dlg.what == "OK":
print 'SaveAs: handling ok clicked'
log.write('SaveAs: You selected %d files: %s' % (len(dlg.path),str(dlg.path)))
if self.isPrjLoaded(dlg.path): return
project = Project()
project.projectFilename = dlg.path
currentActivePrj = self.latest()
project.saveAs(currentActivePrj)
self.guiPlaces.statusbar.SetStatusText("Saving as completed",0);
def enroll(self, long_id, dev_type, customer_mid = 0, customer_did = 0):
if (not self.is_AUTO_port_ready()): return False
#Algorithm:
# 1. Send enroll packet (0x13)
# 2. Wait answer packet (0x11)
enroll_packet = dpr.enroll(long_id, dev_type, customer_mid, customer_did)
self._Communicator.send(enroll_packet)
answer_packet = self._Communicator.wait(11)
if (answer_packet):
if len(answer_packet) < 15:
log.write("EnrollFailed. Invalid answer")
return None
# Answer packet: 0D F2 0B 00 00 0A 01 05 36 08 00 00 0F 03 02 08 67 01 0A
# [0x0D] [0xF2] [0x0B] [0x00] [0x00] [LEN = 0x0A] [OK/REJECT] [N/A] [LongID = 4 bytes] [DEV_NUM] [N/A = 3 bytes] [CS = 2 bytes] [0x0A]
#print "Answer packet: " + hexdump(answer_packet)
enroll_result = ord(answer_packet[6])
if (not enroll_result):
log.write("EnrollFailed. PowerMaster rejected device")
return None
short_id = ord(answer_packet[12])
dev_num = '%02d' % ord(answer_packet[14])
dev_type = ord(answer_packet[13])
log.write('After wait cmd #11. short_id: {0}, DevType: {1}, DevNum: {2}'.format( short_id, dev_type, dev_num ))
return [short_id, dev_num]
else:
log.write("EnrollFailed. No CMD=11 received")
return None
def OnSaveAs(self, event):
dlg = SaveAsDialog()
dlg.ShowModal()
if dlg.what == "OK":
print 'SaveAs: handling ok clicked'
log.write('SaveAs: You selected %d files: %s' %
(len(dlg.path), str(dlg.path)))
if self.isPrjLoaded(dlg.path): return
project = Project()
project.projectFilename = dlg.path
currentActivePrj = self.latest()
project.saveAs(currentActivePrj)
self.guiPlaces.statusbar.SetStatusText("Saving as completed", 0)
def enroll(self, long_id, dev_type, customer_mid=0, customer_did=0):
if (not self.is_AUTO_port_ready()): return False
#Algorithm:
# 1. Send enroll packet (0x13)
# 2. Wait answer packet (0x11)
enroll_packet = dpr.enroll(long_id, dev_type, customer_mid,
customer_did)
self._Communicator.send(enroll_packet)
answer_packet = self._Communicator.wait(11)
if (answer_packet):
if len(answer_packet) < 15:
log.write("EnrollFailed. Invalid answer")
return None
# Answer packet: 0D F2 0B 00 00 0A 01 05 36 08 00 00 0F 03 02 08 67 01 0A
# [0x0D] [0xF2] [0x0B] [0x00] [0x00] [LEN = 0x0A] [OK/REJECT] [N/A] [LongID = 4 bytes] [DEV_NUM] [N/A = 3 bytes] [CS = 2 bytes] [0x0A]
#print "Answer packet: " + hexdump(answer_packet)
enroll_result = ord(answer_packet[6])
if (not enroll_result):
log.write("EnrollFailed. PowerMaster rejected device")
return None
short_id = ord(answer_packet[12])
dev_num = '%02d' % ord(answer_packet[14])
dev_type = ord(answer_packet[13])
log.write(
'After wait cmd #11. short_id: {0}, DevType: {1}, DevNum: {2}'.
format(short_id, dev_type, dev_num))
return [short_id, dev_num]
else:
log.write("EnrollFailed. No CMD=11 received")
return None
def run(self):
while not (self._stop_needed):
try:
priority, index, packet, delay_after = heapq.heappop(self._out_pool)
except IndexError:
time.sleep(0.01)
else:
#with self._lock:
log.write("in queue: %d, pr = %d" % (len(self._out_pool), priority), "debug")
log.write ("{0} *[TX]*: {1}".format(self._port.port, hexdump(packet)), "debug")
self._port.write(packet)
if delay_after:
time.sleep(delay_after)
print 'Message Writer - End of RUN cycle'
async def validate(self, save=False):
# 2016-07-28 - don't know when this gets called, or if save is ever True
# default save to False, monitor
print('HOW DO WE GET HERE?')
if debug:
log.write('validate tree {} {}\n\n'.format(self.ref,
self.db_obj.dirty))
if self.db_obj.dirty:
if save:
if self.tree_frame is not None:
await self.tree_frame.validate_all()
await ht.form_xml.exec_xml(self.parent,
self.parent.methods['do_save'])
else:
print('DBOBJ NOT SAVED!')
def reset_to_factory_defaults(self):
if (not self.is_AUTO_port_ready()): return False
result = False
if not (self.open_test_mode()):
log.write("Can't open test mode")
return False
# cmd = 2, test = 47
packet = prutils.make_f0_packet(2, 47)
self._Communicator.send(packet)
time.sleep(5)
result = self._Communicator.wait(0x04, 3, 5)
if result and ord(result[6]) == 47:
result = True
time.sleep(1)
self.close_test_mode()
return result
def reset_to_factory_defaults(self):
if (not self.is_AUTO_port_ready()): return False
result = False
if not (self.open_test_mode()):
log.write("Can't open test mode")
return False
# cmd = 2, test = 47
packet = prutils.make_f0_packet(2,47)
self._Communicator.send(packet)
time.sleep(5)
result = self._Communicator.wait(0x04, 3, 5)
if result and ord(result[6]) == 47:
result = True
time.sleep(1)
self.close_test_mode()
return result
def OnNew(self,event):
dlg = NewPrjDialog()
dlg.ShowModal()
dlg.Destroy()
if dlg.what == "OK":
print 'handling ok clicked'
log.write('You selected %d files: %s; datamodel: %s' % (len(dlg.path),str(dlg.path), dlg.datamodel.GetTextCtrlValue()))
if not self.fillDataModel(dlg.datamodel.GetTextCtrlValue(), dlg.prjDir+os.sep+"SAFplusAmf.yang"):
return
project = Project()
project.projectFilename = dlg.path
project.new(dlg.datamodel.GetTextCtrlValue())
self.populateGui(project, self.root)
evt = ProjectNewEvent(EVT_PROJECT_NEW.evtType[0])
wx.PostEvent(self.parent,evt)
self.fileMenu.Enable(PROJECT_SAVE, True)
self.fileMenu.Enable(PROJECT_SAVE_AS, True)
def enroll_to_zone(self, long_id, dev_type, zone_num):
# non works on the GSM automation
if (not self.is_AUTO_port_ready()): return False
if (dev_type.upper() in _DeviceType):
dev_type = _DeviceType[dev_type.upper()]
else:
log.wrte("Incorrect device type specified")
return -1
if not (self.open_test_mode()):
log.write("Can't open test mode")
return -1
ack = '\x0D\xF0\x01\x43\x00\x00\x80\x40\x0A'
enroll = '\x0D\xF0\x02\x00\x00\x26\x33\x01' + chr(zone_num) + '\x22\x41' + prutils.num_to_chars(long_id, 4, 0) + \
'\x32\x01\x00\x00\x08\x00' + dev_type + \
'\x01\x14\x03\x00\x00\x01\x03\x00\x00\x00\x02\x07\x00\x70\x09\x28\x03\x08\x01\xC7\x0A'
crc = prutils.crc16_F0(enroll[1:])
enroll = enroll + prutils.num_to_chars(crc, 2, 0) + '\x0A'
# enroll = dpr.enroll_F0(long_id, dev_type, zone_num)
short_id = -1
self._Communicator.send(enroll)
result = self._Communicator.wait(0x01, 3)
if result and result == ack:
result = self._Communicator.wait(0x04, 10) # enroll answer
if result:
if ord(result[7]) != 1:
log.write('Device rejected')
else:
short_id = ord(result[13])
self._Communicator.send(ack)
log.write('ShortId=%d' % short_id)
else:
log.write('Can\'t enroll device, no answer')
else:
log.write('Can\'t enroll device, no ACK')
self.close_test_mode()
return short_id
pass
def OnNew(self, event):
dlg = NewPrjDialog()
dlg.ShowModal()
dlg.Destroy()
if dlg.what == "OK":
print 'handling ok clicked'
log.write('You selected %d files: %s; datamodel: %s' % (len(
dlg.path), str(dlg.path), dlg.datamodel.GetTextCtrlValue()))
if not self.fillDataModel(dlg.datamodel.GetTextCtrlValue(),
dlg.prjDir + os.sep + "SAFplusAmf.yang"):
return
project = Project()
project.projectFilename = dlg.path
project.new(dlg.datamodel.GetTextCtrlValue())
self.populateGui(project, self.root)
evt = ProjectNewEvent(EVT_PROJECT_NEW.evtType[0])
wx.PostEvent(self.parent, evt)
self.fileMenu.Enable(PROJECT_SAVE, True)
self.fileMenu.Enable(PROJECT_SAVE_AS, True)
def wait(self, commands, default_timeout = 2, not_occurences = True):
# not_occurences - defines which result will be sent back:answer packet or command occurence counter
if type(commands) is not list:
#support for multiple commands to wait
commands = [commands]
# if cmd_byte == 0:
cmd_byte = self._Protocol.CMD_BYTE
timeout = default_timeout
#Setting parameters that were passed with the function call
if (self.SET_PARAMS != None):
if (self.SET_PARAMS["ack"] != None):
not_occurences = self.SET_PARAMS["ack"]
self._EventReader._ack_needed = 0
elif not_occurences == False:
# we want to count packet occurences only,
# so disable acknowledge mechanism
self.SET_PARAMS["ack"] = False
if(self.SET_PARAMS["timeout"] != None):
timeout = self.SET_PARAMS["timeout"]
if (timeout <= 0):
return False
log.write("Waiting for command " + ', '.join([hexdump(x) for x in commands]) +". Timeout = " + str(timeout) + " seconds")
start_time = time.time()
index = 0
packet_occurences = 0
while(time.time() - start_time < timeout):
while (index < self.pool_size()):
#Checking message - optional, depend on protocol
current_message = self.get_message(index)
#Checking if correct command found
if (ord(current_message[cmd_byte - 1]) in commands):
log.write("Correct packet found: " + hexdump(current_message))
#_describe_command(current_message, self._Protocol.NAME, None)
#Removing current packet from pool
packet = self.pop_message(index)
packet_occurences += 1
if (not_occurences):
return packet
#else:
index += 1
#Waiting for next message
time.sleep(0.1)
if (not_occurences):
log.write("Failed to receive command [" + ', '.join([hexdump(x) for x in commands]) + "]")
return False
else:
log.write("Packet [" + ', '.join([hexdump(x) for x in commands]) + "] was received: " + str(packet_occurences) + " times")
return packet_occurences
def last_hop_info(self, *params):
bits_names = ['sync']
byte_names = ['D%d' % n for n in range(3,14)]
for param in params:
key, value = param.split('=')
if key in byte_names:
idx = byte_names.index(int(key.strip() - 3))
set_final_hop_info_byte(idx, int(value, 0))
elif key in bits_names:
if key.lower() == 'sync':
byte = get_final_hop_info_byte(4)
if int(value) == 1:
set_final_hop_info_byte(4, byte |0x80)
else:
set_final_hop_info_byte(4, byte & (~0x80))
else:
log.write('Unknown parameter name:`%s`' % key)
return False
return True
def OnLoad(self,event):
dlg = wx.FileDialog(
self, message="Choose a file",
defaultDir=common.getMostRecentPrjDir(),
defaultFile="",
wildcard=PROJECT_WILDCARD,
style=wx.OPEN | wx.CHANGE_DIR # | wx.MULTIPLE
)
if dlg.ShowModal() == wx.ID_OK:
paths = dlg.GetPaths()
log.write('You selected %d files: %s' % (len(paths),str(paths)))
#self.tree.SetItemImage(self.root, fldridx, wx.TreeItemIcon_Normal)
#self.tree.SetItemImage(self.root, fldropenidx, wx.TreeItemIcon_Expanded)
for p in paths:
if self.isPrjLoaded(p): return
project = Project(p)
self.populateGui(project, self.root)
evt = ProjectLoadedEvent(EVT_PROJECT_LOADED.evtType[0])
wx.PostEvent(self.parent,evt)
self.fileMenu.Enable(PROJECT_SAVE, True)
self.fileMenu.Enable(PROJECT_SAVE_AS, True)
def remove_device(self, short_id, long_id=0):
short_id = int(short_id, 0)
device = self._find_device(short_id, 0)
if not device:
log.write("Can't found such device")
return False
device.stop()
result = self._Procedures.remove_device(short_id)
self._devices_pool.remove(device)
devutils.save(self._devices_pool, self._pool_dump_path)
if not result:
log.write("Can't delete device")
return False
#log.write("device_idx=" + str(device_idx))
device.stop()
#log.write("Device stoped, is alive = " + str(device._ka_thread.isAlive()))
self._devices_pool.remove(device)
del(device)
devutils.save(self._devices_pool, self._pool_dump_path)
return True
def send_file_body(self, long_id, short_id, image_data, film_id, row, sequence=-1): # reply with file body
file_block = 0
if not image_data:
return False
chunk_size = 176 # packet size = 0xC0
offset = 0
# sent_data = ''
while(offset < len(image_data)):
if len(image_data) - offset > chunk_size:
bytes_to_send = chunk_size
else:
bytes_to_send = len(image_data) - offset
packet = dpr.file_block(long_id, short_id, image_data[offset: offset + bytes_to_send], film_id, row, file_block, sequence)
# sent_data += image_data[offset: offset + bytes_to_send]
file_block += 1
offset += bytes_to_send
self._Communicator.send(packet)
log.write("File block[%d], size:%d" % (file_block, bytes_to_send))
def OnLoad(self, event):
dlg = wx.FileDialog(
self,
message="Choose a file",
defaultDir=common.getMostRecentPrjDir(),
defaultFile="",
wildcard=PROJECT_WILDCARD,
style=wx.OPEN | wx.CHANGE_DIR # | wx.MULTIPLE
)
if dlg.ShowModal() == wx.ID_OK:
paths = dlg.GetPaths()
log.write('You selected %d files: %s' % (len(paths), str(paths)))
#self.tree.SetItemImage(self.root, fldridx, wx.TreeItemIcon_Normal)
#self.tree.SetItemImage(self.root, fldropenidx, wx.TreeItemIcon_Expanded)
for p in paths:
if self.isPrjLoaded(p): return
project = Project(p)
self.populateGui(project, self.root)
evt = ProjectLoadedEvent(EVT_PROJECT_LOADED.evtType[0])
wx.PostEvent(self.parent, evt)
self.fileMenu.Enable(PROJECT_SAVE, True)
self.fileMenu.Enable(PROJECT_SAVE_AS, True)
def key_load_test(self, cycles='100', delay='100'):
err_cnt = 0
cycles = int(cycles, 0)
delay = int(delay, 0)
LCD = ['USER SETTINGS', 'PERIODIC TEST', 'INSTALLER MODE', 'READY']
for i in range(cycles):
self.send_auto_cmd('1', '0x12')
ans = self._Procedures._Communicator.wait(0x03)
# if ord(ans[6]) == 14:
# log.write("key pressed")
ans = self._Procedures._Communicator.wait(0x01)
if ans:
lcd_text = self.extract_lcd(ans)
# log.write("LCD:%s" % lcd_text)
lcd_idx = i % 3
if lcd_text in LCD[lcd_idx]:
log.write("ERROR! `%s` != `%s`" % (LCD[lcd_idx], lcd_text))
err_cnt += 1
if delay != 0:
time.sleep(delay/1000.0)
log.write("Errors found:%d of %d" % (err_cnt, cycles))
async def validate(self, temp_data):
if debug:
log.write('validate {} {}\n\n'.format(self.col_name, temp_data))
if self.hidden: # unused subtype fields
return
if self.readonly:
return
fld = self.fld
# do not call setval() if non_amendable and db_obj exists [2015-06-09]
# reason - if user moves back to key field, then moves forward, calling setval
# on the key field will trigger read_row, which will over-write any changes
# not sure if this logic belongs in the ht module or in the db module
if not fld.col_defn.allow_amend and fld.db_obj.exists:
assert self.ref not in temp_data # user should not be able to enter a value
return
if self.ref in temp_data: # user has entered a value
temp_val = temp_data.pop(self.ref)
value = await fld.str_to_val(temp_val) # can raise AibError
self.dflt_val = None # in case it was set
elif self.dflt_val is not None: # user has not changed form_dflt
value = await fld.str_to_val(self.dflt_val)
self.dflt_val = None
else: # get current value, or if None, default value
value = await fld.getval()
if value is None:
value = await fld.get_dflt()
if self.after_input is not None: # steps to perform after input
fld.val_before_input = await fld.getval() # used in after_input()
await fld.setval(value, form_vlds=self.form_vlds) # can raise AibError
if self.after_input is not None: # steps to perform after input
await ht.form_xml.after_input(self)
del fld.val_before_input
def _dispatch(self, command, params):
#Checking if "timeout" or "ack" parameters were given
#print '*********************' + command, params
command_params = []
set_params = {"ack" : None,
"timeout" : None}
for param in params:
found_set_param = False
for key in set_params.keys():
if (param.find(key + "=") == 0):
set_params[key] = int(param.split("=")[1])
found_set_param = True
if (not found_set_param):
command_params.append(param)
log.write('%s %s' % (command, ' '.join(params)) , 'debug')
# Passing set_params dictionary to Communicator class
self._Procedures._Communicator.SET_PARAMS = set_params
if(self._SnifferCommunicator):
self._SnifferCommunicator.SET_PARAMS = set_params
# Removing all entries from Reader.Pool
# If "wait" command is specified, no need to clear_pool (to be able to catch previous data)
if (command not in ["wait", "sniffer_wait"]):
# log.write("Communicator: clear pool")
self._Procedures._Communicator.clear_pool()
if (config.DEBUG_MODE):
result = getattr(self, command)(*command_params)
log.write("XMLRPC return value: " + str(result), "debug")
return result
else:
try:
return getattr(self, command)(*params)
except SystemExit, e:
sys.exit(e)
except Exception:
log.write("Incorrect command specified")
return False
def _dispatch(self, command, params):
#Checking if "timeout" or "ack" parameters were given
command_params = []
set_params = {"ack" : None,
"timeout" : None}
for param in params:
found_set_param = False
for key in set_params.keys():
if (param.find(key + "=") == 0):
set_params[key] = int(param.split("=")[1])
found_set_param = True
if (not found_set_param):
command_params.append(param)
log.write('%s %s' % (command, ' '.join(params)) , 'debug')
# Passing set_params dictionary to Communicator class
self._Procedures._Communicator.SET_PARAMS = set_params
if(self._SnifferCommunicator):
self._SnifferCommunicator.SET_PARAMS = set_params
# Removing all entries from Reader.Pool
# If "wait" command is specified, no need to clear_pool (to be able to catch previous data)
if (command not in ["wait", "sniffer_wait"]):
# log.write("Communicator: clear pool")
self._Procedures._Communicator.clear_pool()
if (config.DEBUG_MODE):
result = getattr(self, command)(*command_params)
log.write("XMLRPC return value: " + str(result), "debug")
return result
else:
try:
return getattr(self, command)(*params)
except SystemExit, e:
sys.exit(e)
except Exception:
log.write("Incorrect command specified")
return False
def stop(self):
log.write("XML-RPC Server stopped")
self._Server.shutdown()
def run(self):
log.write("Launching XML-RPC server [" + str(self._Server.server_address[0]) + ":" + str(self._Server.server_address[1]) + "]")
self._Server.serve_forever()
def stop(self):
log.write("XML-RPC Server stopped")
self._Server.shutdown()
def run(self):
log.write("Launching XML-RPC server [" +
str(self._Server.server_address[0]) + ":" +
str(self._Server.server_address[1]) + "]")
self._Server.serve_forever()
def wrapper(*args, **kwargs):
if debug:
log.write('*{}.{}({}, {})\n\n'.format(
func.__module__, func.__name__,
', '.join(str(arg) for arg in args), kwargs))
return func(*args, **kwargs)
def _print_device_info(self, device):
log.write("Device: {0} , sid={1}, lid={2}".format(device._dev_type,device._short_id, device._long_id))
def add_to_queue(self, packet, priority, delay_after=0.5):
if self._MessageWriter.isAlive():
heapq.heappush(self._out_pool, (priority, self._msg_index.next(), packet, delay_after))
return True
log.write("Can't add message to queue - writer thread haven't been ran", "debug")
return False
def write(self, packet):
#TODO: Check if it works and create thread if needed
#self._Serial.send_packet(packet)
self._Serial.write(packet)
log.write ("{0} [TX]: {1}".format(self._port_name, hexdump(packet)), "debug")
def version(self):
log.write("Version: " + self.SIMULATOR_VERSION)
return self.SIMULATOR_VERSION
