Python array.fromstring方法代码示例

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import fromstring [as 别名]
  def wait_for_interrupts(self, wait_time = 1):
    """wait_for_interrupts
    
    listen for interrupts for the specified amount of time

    Args:
      wait_time: the amount of time in seconds to wait for an interrupt

    Returns:
      True: Interrupts were detected
      False: No interrupts detected

    Raises:
      Nothing
    """
    timeout = time.time() + wait_time

    temp = Array ('B')
    while time.time() < timeout:
      response = self.dev.read_data(1)
      rsp = Array('B')
      rsp.fromstring(response)
      temp.extend(rsp)
      if 0xDC in rsp:
        if self.debug:
          print "Got a response"  
        break

    if not 0xDC in rsp:
      if self.debug:
        print "Response not found"  
      return False

    read_total = 9
    read_count = len(rsp)

    #print "read_count: %s" % str(rsp)
    while (time.time() < timeout) and (read_count < read_total):
      response = self.dev.read_data(read_total - read_count)
      temp  = Array('B')
      temp.fromstring(response)
      #print "temp: %s", str(temp)
      if (len(temp) > 0):
        rsp += temp
        read_count = len(rsp)

    #print "read_count: %s" % str(rsp)
   

    index  = rsp.index(0xDC) + 1

    read_data = Array('B')
    read_data.extend(rsp[index:])
    #print "read_data: " + str(rsp)

    self.interrupts = read_data[-4] << 24 | read_data[-3] << 16 | read_data[-2] << 8 | read_data[-1]
    
    if self.debug:
      print "interrupts: " + str(self.interrupts)
    return True

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import fromstring [as 别名]
 def read_dma_data(self, count):
     d = Array('B')
     self.write_command(CMD_DMA_READ, count, 0x00)
     print "Send Peripheral Read Command"
     data = Array('B')
     data.fromstring(os.read(self.f, count * 4))
     print "Data: %s" % str(data)
     print_32bit_hex_array(d)

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import fromstring [as 别名]
 def load_callback(self):
     filename = self.loader.get_filename()
     self.read_data_count.setText("0x00")
     if not os.path.exists(filename):
         self.f2m_button.setEnabled(False)
         return
     self.f2m_button.setEnabled(True)
     f = open(filename, "rb")
     d = Array('B')
     d.fromstring(f.read())
     f.close()
     self.write_data_count.setText(hex(len(d)))

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import fromstring [as 别名]
  def ping(self):
    """ping

    Pings the Olympus image

    Args:
      Nothing

    Returns:
      Nothing

    Raises:
      OlympusCommError
    """
    data = Array('B')
    data.extend([0XCD, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
    if self.debug:
      print "Sending ping...",
    self.dev.write_data(data)
    rsp = Array('B')
    temp = Array('B')

    timeout = time.time() + self.read_timeout

    while time.time() < timeout:
      response = self.dev.read_data(5)
      if self.debug:
        print ".",
      rsp = Array('B')
      rsp.fromstring(response)
      temp.extend(rsp)
      if 0xDC in rsp:
        if self.debug:
          print "Got a response"  
          print "Response: %s" % str(temp)
        break

    if not 0xDC in rsp:
      if self.debug:
        print "ID byte not found in response"  
        print "temp: " + str(temp)
      raise OlympusCommError("Ping response did not contain ID: %s" % str(temp))

    index  = rsp.index(0xDC) + 1

    read_data = Array('B')
    read_data.extend(rsp[index:])
    num = 3 - index
    read_data.fromstring(self.dev.read_data(num))
    if self.debug:
      print "Success!"
    return

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import fromstring [as 别名]
 def file_2_memory(self, filename, address, count = None):
     """
     Data should be in the form of a byte array
     """
     f = open(filename, 'rb')
     d = Array('B')
     d.fromstring(f.read())
     f.close()
     if count is None:
         count = len(d)
     mem_base = self.n.get_device_address(self.urn)
     print "Writing %d bytes down" % len(d[0:count])
     self.n.write_memory(mem_base + address, d[0:count])

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import fromstring [as 别名]
	def ping(self):
		data = Array('B', '0000'.decode('hex'))
		print "writing"
		for a in data:
			print "Data: %02X" % (a)

		self.dev.write_data(data)
		print "reading"

		time.sleep(.1)
		response = self.dev.read_data(4)
		rsp = Array('B')
		rsp.fromstring(response)
		print "rsp: " + str(rsp)

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import fromstring [as 别名]
    def read_periph_data(self, address, count):
        d = Array('B')
        data_count = count
        if data_count == 0:
            data_count = 1
        d.extend(dword_to_array(IDWORD))
        d.extend(dword_to_array(0x00000002))
        d.extend(dword_to_array(data_count))
        d.extend(dword_to_array(address))

        self.write_command(CMD_PERIPHERAL_WRITE, len(d) / 4, 0x00)
        os.write(self.f, d)
        self.write_command(CMD_PERIPHERAL_READ, data_count, 0x00)
        print "Send Peripheral Read Command"
        data = Array('B')
        data.fromstring(os.read(self.f, data_count * 4))
        print "Data: %s" % str(data)

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import fromstring [as 别名]
 def _exchange(self, frequency, cs_cmd, out, readlen):
     """Perform a half-duplex transaction with the SPI slave"""
     if not self._ftdi:
         raise SpiIOError("FTDI controller not initialized")
     if len(out) > SpiController.PAYLOAD_MAX_LENGTH:
         raise SpiIOError("Output payload is too large")
     if readlen > SpiController.PAYLOAD_MAX_LENGTH:
         raise SpiIOError("Input payload is too large")
     if self._frequency != frequency:
         self._ftdi.set_frequency(frequency)
         # store the requested value, not the actual one (best effort)
         self._frequency = frequency
     write_cmd = struct.pack('<BH', Ftdi.WRITE_BYTES_NVE_MSB, len(out)-1)
     cmd = Array('B', cs_cmd)
     if PY3:
         cmd.frombytes(write_cmd)
     else:
         cmd.fromstring(write_cmd)
     cmd.extend(out)
     if readlen:
         read_cmd = struct.pack('<BH', Ftdi.READ_BYTES_NVE_MSB, readlen-1)
         if PY3:
             cmd.frombytes(read_cmd)
         else:
             cmd.fromstring(read_cmd)
         cmd.extend(self._immediate)
         if self._turbo:
             cmd.extend(self._cs_high)
             self._ftdi.write_data(cmd)
         else:
             self._ftdi.write_data(cmd)
             self._ftdi.write_data(self._cs_high)
         # USB read cycle may occur before the FTDI device has actually
         # sent the data, so try to read more than once if no data is
         # actually received
         data = self._ftdi.read_data_bytes(readlen, 4)
     else:
         if self._turbo:
             cmd.extend(self._cs_high)
             self._ftdi.write_data(cmd)
         else:
             self._ftdi.write_data(cmd)
             self._ftdi.write_data(self._cs_high)
         data = Array('B')
     return data

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import fromstring [as 别名]
  def write_string(self, string = ""):
    """write_string
    
    Writes a string of data over the UART

    Args:
      string: String to send

    Return:
      Nothing

    Raises:
      OlympusCommError
    """
    if self.debug:
      print "Writing a string"

    data = Array('B')
    data.fromstring(string)
    self.write_raw(data)

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import fromstring [as 别名]
	def test_rw_sector_1(self):
		from hashlib import sha1
		buf = Array('I')
#		length = 65536
		length = len(self.flash)
		print "length: " + str(length)
		print "Build Sequence"
		for address in range (0, length):
			buf.append(address)
		print "Swap sequence"
		buf = buf.byteswap()
		#print "Erase flash from %08X to %08X" % (0, length)
		print "Erase all of the flash"
		self.flash.erase(0, len(self.flash))
		bufstr = buf.tostring()
		dout = Array('B')
		dout.fromstring(bufstr)
		self.flash.write(0, bufstr)
		print "Verify Flash"
		wmd = sha1()
		wmd.update(buf.tostring())
		refdigest = wmd.hexdigest()
		print "Read Flash"
		din = self.flash.read(0, length)
		print "Dump Flash"
		print hexdump(din.tostring())
		print "Verify Flash"
		rmd = sha1()
		rmd.update(din.tostring())
		newdigest = rmd.hexdigest()
		print "Reference: ", refdigest
		print "Retrieved: ", newdigest

		try:
			f = open("din.hex", "w")
			din.tofile(f)
			f.close()
		except IOError, err:
			print "Error writing to din file"

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import fromstring [as 别名]
 def test_flashdevice_4_long_rw(self):
     """Long R/W test
     """
     # Max size to perform the test on
     size = 1<<20
     # Whether to test with random value, or contiguous values to ease debug
     randomize = True
     # Fill in the whole flash with a monotonic increasing value, that is
     # the current flash 32-bit address, then verify the sequence has been
     # properly read back
     from hashlib import sha1
     # limit the test to 1MiB to keep the test duration short, but performs
     # test at the end of the flash to verify that high addresses may be
     # reached
     length = min(len(self.flash), size)
     start = len(self.flash)-length
     print "Erase %s from flash @ 0x%06x(may take a while...)" % \
         (pretty_size(length), start)
     delta = time.time()
     self.flash.unlock()
     self.flash.erase(start, length, True)
     delta = time.time()-delta
     self._report_bw('Erased', length, delta)
     if str(self.flash).startswith('SST'):
         # SST25 flash devices are tremendously slow at writing (one or two
         # bytes per SPI request MAX...). So keep the test sequence short
         # enough
         length = 16<<10
     print "Build test sequence"
     if not randomize:
         buf = Array('I')
         back = Array('I')
         for address in range(0, length, 4):
             buf.append(address)
         # Expect to run on x86 or ARM (little endian), so swap the values
         # to ease debugging
         # A cleaner test would verify the host endianess, or use struct
         # module
         buf.byteswap()
         # Cannot use buf directly, as it's an I-array,
         # and SPI expects a B-array
     else:
         from random import seed
         seed(0)
         buf = Array('B')
         back = Array('B')
         buf.extend((randint(0, 255) for x in range(0, length)))
     bufstr = buf.tostring()
     print "Writing %s to flash (may take a while...)" % \
         pretty_size(len(bufstr))
     delta = time.time()
     self.flash.write(start, bufstr)
     delta = time.time()-delta
     length = len(bufstr)
     self._report_bw('Wrote', length, delta)
     wmd = sha1()
     wmd.update(buf.tostring())
     refdigest = wmd.hexdigest()
     print "Reading %s from flash" % pretty_size(length)
     delta = time.time()
     data = self.flash.read(start, length)
     delta = time.time()-delta
     self._report_bw('Read', length, delta)
     #print "Dump flash"
     #print hexdump(data.tostring())
     print "Verify flash"
     rmd = sha1()
     rmd.update(data.tostring())
     newdigest = rmd.hexdigest()
     print "Reference:", refdigest
     print "Retrieved:", newdigest
     if refdigest != newdigest:
         errcount = 0
         back.fromstring(data)
         for pos in xrange(len(buf)):
             if buf[pos] != data[pos]:
                 print 'Invalid byte @ offset 0x%06x: 0x%02x / 0x%02x' % \
                     (pos, buf[pos], back[pos])
                 errcount += 1
                 # Stop report after 16 errors
                 if errcount >= 32:
                     break
         raise AssertionError('Data comparison mismatch')

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import fromstring [as 别名]
 def _write_bytes_raw(self, out):
     """Output bytes on TDI"""
     olen = len(out)-1
     cmd = Array('B', [Ftdi.WRITE_BYTES_NVE_LSB, olen&0xff, (olen>>8)&0xff])
     cmd.fromstring(out)
     self._stack_cmd(cmd)

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import fromstring [as 别名]
    def load_rom(self, filename):
        f = open(filename, 'r')
        #data = f.read()
        data = Array('B')
        data.fromstring(f.read())
        print "Length of data: %d" % len(data)
        print "Type: %s" % str(type(data))
        f.close()
        #if ((data[0] != 'N') or (data[1] != 'E') or (data[2] != 'S') or (data[3] != 0x1A)):
        if ((data[0] != 0x4E) or (data[1] != 0x45) or (data[2] != 0x53) or (data[3] != 0x1A)):
            raise NESError("Invalid ROM header")


        prg_rom_banks = data[4]
        chr_rom_banks = data[5]
        if (prg_rom_banks > 2) or (chr_rom_banks > 1):
            raise NESError("Too many ROM banks: PRG_ROM: %d CHR ROM: %d" % (prg_rom_banks, chr_rom_banks))

        mapper = (((data[6] & 0xF0) >> 4) | ((data[7] & 0xF0)) != 0)
        if mapper != 0:
            raise NESError("Only mapper 0 is supported")

        # Issue a debug break
        yield self.enter_debug()

        #Disable PPU
        yield self.disable_ppu()

        #Set header info to config mapper
        config = [0] * 5
        config[0] = data[4]
        config[1] = data[5]
        config[2] = data[6]
        config[3] = data[7]
        config[4] = data[8]
        yield self.set_cart_config(config)

        #Calculate all the sizes
        prg_rom_size = prg_rom_banks * 0x4000
        chr_rom_size = chr_rom_banks * 0x2000
        total_size = prg_rom_size + chr_rom_size
        transfer_block_size = 0x400

        prg_rom = data[16:16 + prg_rom_size]
        chr_rom = data[16 + prg_rom_size: 16 + prg_rom_size + chr_rom_size]
        
        #XXX: SIMULATION Don't write too much data
        if SIM:
            load_prg_rom = prg_rom[0:256]
            load_chr_rom = prg_rom[0:256]

        prg_offset = 0x8000
        #Copy PRG ROM data
        if SIM:
            yield self.write_cpu_mem(prg_offset, load_prg_rom)
        else:
            yield self.write_cpu_mem(prg_offset, prg_rom)

        #Copy CHR ROM data
        #chr_offset = prg_offset + len(prg_rom)
        chr_offset = 0x00
        #yield self.write_cpu_mem(chr_offset, chr_rom)
        if SIM:
            yield self.write_ppu_mem(chr_offset, load_chr_rom)
        else:
            yield self.write_ppu_mem(chr_offset, chr_rom)

        #Update PC to point to the reset interrupt vector location
        pcl_val = data[16 + prg_rom_size - 4]
        pch_val = data[16 + prg_rom_size - 3]
        print "PCH:PCL: %02X:%02X" % (pch_val, pcl_val)

        yield self.write_cpu_register(CPU_REG_PCL, pcl_val) 
        yield self.write_cpu_register(CPU_REG_PCH, pch_val)

        #Issue a debug run command
        yield self.exit_debug()

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import fromstring [as 别名]
  def dump_core(self):
    """dump_core

    reads the state of the wishbone master prior to a reset, useful for
    debugging

    Args:
      Nothing

    Returns:
      Array of 32-bit values to be parsed by core_analyzer

    Raises:
      AssertionError: This function must be overriden by a board specific
      implementation
      OlympusCommError: A failure of communication is detected
    """

    data = Array('B')
    data.extend([0xCD, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
    print "Sending core dump request..."

    self.dev.purge_buffers()
    self.dev.write_data(data)

    core_dump = Array('L')
    wait_time = 5
    timeout = time.time() + wait_time

    temp = Array ('B')
    while time.time() < timeout:
      response = self.dev.read_data(1)
      rsp = Array('B')
      rsp.fromstring(response)
      temp.extend(rsp)
      if 0xDC in rsp:
        print "Got a response"  
        break

    if not 0xDC in rsp:
      print "Response not found"  
      raise OlympusCommError("Response Not Found")

    rsp = Array('B')
    read_total = 4
    read_count = len(rsp)

    #get the number of items from the address
    timeout = time.time() + wait_time
    while (time.time() < timeout) and (read_count < read_total):
      response = self.dev.read_data(read_total - read_count)
      temp  = Array('B')
      temp.fromstring(response)
      if (len(temp) > 0):
        rsp += temp
        read_count = len(rsp)

    print "Length of read: %d" % len(rsp)
    print "Data: %s" % str(rsp)
    count  = ( rsp[1] << 16 | rsp[2] << 8 | rsp[3]) * 4
    print "Number of core registers: %d" % (count / 4)

    #get the core dump data
    timeout = time.time() + wait_time
    read_total  = count
    read_count  = 0
    temp = Array ('B')
    rsp = Array('B')
    while (time.time() < timeout) and (read_count < read_total):
      response = self.dev.read_data(read_total - read_count)
      temp  = Array('B')
      temp.fromstring(response)
      if (len(temp) > 0):
        rsp += temp
        read_count = len(rsp)

    print "Length read: %d" % (len(rsp) / 4)
    print "Data: %s" % str(rsp)
    core_data = Array('L')
    for i in range (0, count, 4):
      print "count: %d" % i
      core_data.append(rsp[i] << 24 | rsp[i + 1] << 16 | rsp[i + 2] << 8 | rsp[i + 3])
    
    #if self.debug:
    print "core data: " + str(core_data)

    return core_data

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import fromstring [as 别名]
  def write(self, device_id, address, data=None, mem_device = False):
    """write

    Write data to an Olympus image

    Args:
      device_id: Device identification number, found in the DRT
      address: Address of the register/memory to read
      mem_device: True if the device is on the memory bus
      data: Array of raw bytes to send to the device

    Returns:
      Nothing

    Raises:
      OlympusCommError
    """
    length = len(data) / 4

    # ID 01 NN NN NN OO AA AA AA DD DD DD DD
      # ID = ID BYTE (0xCD)
      # 01 = Write Command
      # NN = Size of write (3 bytes)
      # OO = Offset of device
      # AA = Address (4 bytes)
      # DD = Data (4 bytes)

    #create an array with the identification byte (0xCD)
    #and code for write (0x01)

    data_out = Array('B', [0xCD, 0x01]) 
    if mem_device:
      if self.debug:
        print "memory device"
      data_out = Array ('B', [0xCD, 0x11])
    
    """
    print "write command:\n\t" + str(data_out[:9])
    for i in range (0, len(data_out)):
      print str(hex(data_out[i])) + ", ",
    print " "
    """

 

    #append the length into the frist 32 bits
    fmt_string = "%06X" % (length) 
    data_out.fromstring(fmt_string.decode('hex'))
    offset_string = "00"
    if not mem_device:
      offset_string = "%02X" % device_id
    data_out.fromstring(offset_string.decode('hex'))
    addr_string = "%06X" % address
    data_out.fromstring(addr_string.decode('hex'))
    
    data_out.extend(data)

    """
    #if (self.debug):
    print "data write string:\n"
    print "write command:\n\t" + str(data_out[:9])
    for i in range (0, 9):
      print str(hex(data_out[i])) + ", ",
    print " "
    """


    #print "write data:\n" + str(data_out[9:])

    #avoid the akward stale bug
    self.dev.purge_buffers()

    self.dev.write_data(data_out)
    rsp = Array('B')

    timeout = time.time() + self.read_timeout
    while time.time() < timeout:
      response = self.dev.read_data(1)
      if len(response) > 0:
        rsp = Array('B')
        rsp.fromstring(response)
        if rsp[0] == 0xDC:
          if self.debug:
            print "Got a response"  
          break

    if (len(rsp) > 0):
      if rsp[0] != 0xDC:
        if self.debug:
          print "Response not found"  
        raise OlympusCommError("Did not find identification byte (0xDC): %s" % str(rsp))

    else:
      if self.debug:
        print "No Response"
      raise OlympusCommError("Timeout while waiting for a response")

    response = self.dev.read_data(8)
    rsp = Array('B')
    rsp.fromstring(response)
#.........这里部分代码省略.........