Esempio n. 1
0
    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
Esempio n. 2
0
 def get_network_data(self, integrity=False):
     supervision_period = 0x2D0
     enrollment_sate = 1
     data = prutils.num_to_chars(self._long_id, 4, 0) + self._dev_type_code + \
         chr(self._short_id) + chr(enrollment_sate) # + prutils.num_to_chars(supervision_period, 2, 0)
     # data = prutils.str_l(data)
     log.write("network data = %s" % prutils.hexdump(data))
     if integrity:
         return prutils.crc_PGH_20(data)
     return data
Esempio n. 3
0
    def dispatch_message(self, dpr_list):
        # 24 00 00 00 00 00 02 04 B5 02 0D 01
        if not self._auto_response:
            return None
        # log.write('got [%d] dpr  messages: %s' % (len(dpr_list), dpr_list),  "console")
        for dpr_msg in dpr_list:
            # if len(dpr_msg) < 3 : return None
            seq = ord(dpr_msg[2])
            # filter out wrong messages
            if seq !=0 and seq == self.prev_seq:
                log.write('Got repetition of command')
                # continue
            seq = self.prev_seq

            mcode = ord(dpr_msg[6])
            tldv_len = ord(dpr_msg[7])
            tldv = dpr_msg[7 : 8 + tldv_len]
            tldv_type = ord(tldv[1])
            log.write("camera [%d:%d] got mcode[%d] type=%02X, tldv = %s, seq = %d" % \
                (self._short_id, self._long_id, mcode, tldv_type, prutils.hexdump(tldv), seq))
            # FIXME: snum !!!!
            if mcode    == 2: # GET 
                if tldv_type == 0xB5:   # file info
                    requested_film_id = ord(tldv[3])
                    requested_row = ord(tldv[4])
                    log.write("Requested file info:film id=0x%02X, row=0x%02X" % (requested_film_id, requested_row))
                    self.report_file_info(self.film_type, self.film_id, self.file_size, self.row, self.crc16, self.index, self.zone, 0, seq)
                    dpr_list.remove(dpr_msg)

            elif mcode  == 9: # file request - ONLY IF File info request was before
                requested_film_id = ord(tldv[1])
                requested_row = ord(tldv[2])
                log.write("Requested for FILE, film id=%d, row=%d" % (requested_film_id, requested_row))
                requested_chunk_size = ord(tldv[3])
                if self.film_id != requested_film_id:
                    log.write("Wrong requested film id:%d" % requested_film_id)
                self.send_file_body(self.image_data, requested_row)
                self.row += 1
                if self.row == self.files_amount:
                    self.set_autoresponse_activity(False)
                    self.row = 0
                dpr_list.remove(dpr_msg)

            elif mcode  == 7: # confirm
                if tldv_len == 1 and ord(tldv[1]) == 0x00: # OK
                    # Confirmationion must be check on HPR sequence level
                    log.write("Confirmation")
                    self.message_confirmed = True
                dpr_list.remove(dpr_msg)


        # if message not processed run default dispatcher 
        if(len(dpr_list)):
            Device.dispatch_message(self, dpr_list)
Esempio n. 4
0
    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'
Esempio n. 5
0
 def dispatch_message(self, dpr_list):
     if not self._auto_response:
         return None
     # log.write('Device::dispatch_message')
     # dpr_list : ['\xA4\x00\x8E\x00\x00\x00\x04\x03\xF1\x01\x02','\x04\x00\xFF\x00\x00\x00\x04\x05\x3E\x03\x00\x84\x03']        
     response_amount = 0
     for dpr_msg in dpr_list:
         seq = ord(dpr_msg[2])
         mcode = ord(dpr_msg[6])
         tldv_len = ord(dpr_msg[7])
         tldv = dpr_msg[7 : 8 + tldv_len]
         log.write("device [%d:%d] got mcode[%d] type=%02X, tldv = %s, seq = %d" % \
             (self._short_id, self._long_id, mcode, ord(tldv[1]), prutils.hexdump(tldv), seq), "debug")
         if mcode == 0x04:
             # response_amount += 1
             if tldv[1] == '\xF1':
                 # log.write("set device state")
                 self._state = prutils.chars_to_int(tldv[3:].strip())
                 self.send_response(0x06, seq) #, response_amount)
                 # log.write("device [%d:%d]:state = %d, seq = %d" % (self._short_id, self._long_id, self._state, seq))
             elif tldv[1] == '\x3E':
                 # log.write("set notification period")
                 response_amount -= 1
                 notification_period = ord(tldv[3])
                 #log.write('** hello from [%d:%d] **' % (self._short_id, self._long_id))
                 self.send_hello(seq, notification_period)
                 #self._Procedures.hello(self._long_id, self._short_id, 0, notification_period)
             elif tldv[1] == '\xFC':
                 # log.write("set update config")
                 self.send_response(0x06, seq) #, response_amount)
                 # response comes first !!!
                 #response_amount -= 1
                 log.write('** update from [%d:%d] **' % (self._short_id, self._long_id))
                 self._Procedures.update(self._long_id, self._short_id)
             else:
                 # other set commands
                 self.send_response(0x06, seq) # , response_amount)
             # if response_amount > 0:
                 
         elif mcode == 5:
             if tldv[1] == '\x40': # hello
                 self.send_hello()
             # confirm to report
             self.send_response(0x07, seq)
Esempio n. 6
0
 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")
Esempio n. 7
0
 def _convert_result(self, value):
     if (value):
         # Packet received
         return hexdump(value)
     # Returning 'None' or 'False' values
     return value
Esempio n. 8
0
    def get_application_data(self, fn_sniffer_wait, integrity=False):
        # use request to get configuration according to device type
        config_cache = {} 
        cur_seq = 0xff
        snum = 0xff
        data = ''
        for cfg in self._config_types:
            device_config_template = self._get_config_type(cfg)
            if device_config_template is None:
                log.write("Don't know how to get the 0x%04X device configuration" % cfg) 
                return None
            dpr_type = device_config_template[1]
            # log.write("ASK FOR dpr_type = %x" % dpr_type)
            if dpr_type in config_cache.keys():
                packet = config_cache[dpr_type]
            else:
                packet = self._Procedures.request_configuration_data(self._short_id, self._long_id, dpr_type)

                # filter out retransmittions
                while snum == cur_seq:
                    packet = fn_sniffer_wait(0x10)
                    if packet == False:
                        break
                    packet = packet[5:]  # dpr only
                    dprp = DPR_Packet(packet) 
                    snum = dprp.snum.value
                    if snum == 0xff:
                        break # special case

                cur_seq = snum
                if packet :
                    config_cache[dpr_type] = packet
                    self.send_response(0x07, dprp.snum.value)

            if packet:
                dprp = DPR_Packet(packet) 
                rcv_dpr_type = ord(packet[8])
                # if dpr_type != rcv_dpr_type:
                    # log.write("wrong TLDV:%d != %d" % (dpr_type, rcv_dpr_type))
                value_len_off = dprp.data_len.offset + 2
                value_len = ord(packet[value_len_off])
                # add config to cash
                # log.write("len = %d " % value_len)
                
                add = prutils.num_to_chars(cfg, 2, 0)
                # add +=  prutils.num_to_chars(cfg, 2, 0)
                # BF [07 05 01 00 01 00 08 20]
                if len(device_config_template) > 2 :
                    # extract the tldv parameter
                    offset = device_config_template[2][0]
                    size = device_config_template[2][1]
                    tldv_data = dprp.data[offset + 2: offset + size + 2]
                    # log.write("template:%s" % device_config_template)
                    # log.write("dpr data = %s" % prutils.hexdump(dprp.data))
                    # log.write("0x%X:%d extraction: %s" % (offset, size, prutils.hexdump(tldv_data)))
                    add += chr(len(tldv_data)) + tldv_data
                # log.write("TLDV:%s => %s" % (prutils.hexdump(packet[8:11]), prutils.hexdump(add)))
                else:
                    add += chr(value_len)
                    add += packet[value_len_off + 1: value_len_off + value_len + 1]

                data += add
                # data = chr(len(data)) + data
                time.sleep(0.3)
            else:
                return None
        log.write("application data = %s" % prutils.hexdump(data))
        if integrity == True:
            if len(self._config_types) != 0:
                data = prutils.crc_PGH_20(data)
            else:
                data = 0x0000
        return data