Python array.tostring方法代码示例

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import tostring [as 别名]
  def read_string(self, count = 1):
    """read_string
    
    Read a string of characters

    Args:
      count: the number of characters and returns a string
              if -1 read all characters

    Returns:
      string

    Raises:
      OlympusCommError: Error in communication
    """
    if self.debug:
      print "read_string"

    data = Array('B')
    if count == -1:
      data = self.read_all_data()
    else:
      data = self.read_raw(count)
    
    string = data.tostring()
    return string

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import tostring [as 别名]
    def serial_number(self):
        data = self.raw_data
        d = Array('B')
        for i in range (20, 38, 4):
            d.append(data[i + 2])
            d.append(data[i + 3])
            d.append(data[i + 0])
            d.append(data[i + 1])

        return d.tostring()

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import tostring [as 别名]
 def _ping(self):
     self.dev.flush()
     self.dev.write(PING_CMD)
     self.log.debug("See if the device is there?")
     #data = Array('B', self.dev.read(4))
     data = Array('B', self._read_response())
     print "Data: %s" % str(data)
     if data.tostring()[1] == "S":
         self.log.debug("Ping Response Successful")
         return True
     else:
         self.log.debug("Ping Response Fail")
         return False

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import tostring [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 tostring [as 别名]
 def test_flashdevice_long_rw(self):
     # 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
     buf = Array('I')
     length = len(self.flash)
     #length = 4096
     print "Build sequence"
     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
     print "Swap sequence"
     buf.byteswap()
     print "Erase flash (may take a while...)"
     self.flash.erase(0, length)
     # Cannot use buf, as it's an I-array, and SPI expects a B-array
     bufstr = buf.tostring()
     print "Write flash", len(bufstr)
     self.flash.write(0, bufstr)
     wmd = sha1()
     wmd.update(buf.tostring())
     refdigest = wmd.hexdigest()
     print "Read flash"
     data = self.flash.read(0, length)
     #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:
         raise AssertionError('Data comparison mismatch')

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import tostring [as 别名]
    def upload_fpga_image(self, bit_buf):
        max_size = 512
        if self.dev is None:
            raise USBDeviceError("Device is None")

        bit_buf_length = len(bit_buf)
        length_buf = Array('B', [0, 0, 0, 0])
        length_buf[3] = (bit_buf_length >> 24)  & 0x000000FF
        length_buf[2] = (bit_buf_length >> 16)  & 0x000000FF
        length_buf[1] = (bit_buf_length >> 8)   & 0x000000FF
        length_buf[0] = (bit_buf_length)        & 0x000000FF

        print "bit buf packets [3] [2] [1] [0]: %X %X %X %X" % (length_buf[3],
                                                                length_buf[2],
                                                                length_buf[1],
                                                                length_buf[0])

        print "Length: (Hex): 0x%08X, (Dec): %d" % (bit_buf_length, bit_buf_length)

        with self.usb_lock:
            try:
                self.dev.ctrl_transfer(
                    bmRequestType   = 0x40,   #VRequest, To the devce, Endpoint
                    bRequest        = 0xB2,   #FPGA Configuration mode
                    wValue          = 0x00,
                    wIndex          = 0x00,
                    data_or_wLength = length_buf.tostring(),
                    timeout         = 1000)   #Timeout    = 1 second
            except usb.core.USBError, err:
                if err.errno == 110:
                    raise USBDeviceError("Device Timed Out while attempting to send FPGA Config")
                if err.errno == 5:
                    self.usb_server.update_usb()
                    raise USBDeviceError("Device was disconnected")

                if err.errno == 16:
                    self.usb_server.update_usb()
                    raise USBDeviceError("Device was disconnected")

                else:
                    raise USBDeviceError("Unknown USB Device Error: %s" % str(err))

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import tostring [as 别名]
    def write_program_data(self, address, data):
        print "Write data to the device"
        start_address = address
        buf = Array('B', [])

        index = 0
        #Size is maximum of 4096
        finished = False
        write_len = 0
        while True:
            if len(data[index:]) > 4096:
                buf = data[index: index+ 4096]
            else:
                buf = data[index:]

            print "Writing: %d bytes to address: 0x%X" % (len(buf), address)
            try:
                write_len = self.dev.ctrl_transfer(
                    bmRequestType = 0x40,            #VRequest, to device, endpoint
                    bRequest = 0xA0,                 #Vendor Spcific write command
                    wValue = 0x0000FFFF & address,   #Addr Low 16-bit value
                    wIndex = address >> 16,          #Addr High 16-bit value
                    data_or_wLength = buf.tostring(),              #Data
                    timeout = 1000)                                #Timeout 1 second
            except usb.core.USBError, err:
                pass

            #Check if there was an error in the transfer
            if write_len != len(buf):
                raise BootFX3Error("Write Size != Length of buffer")

            #Update the index
            index += write_len
            address += write_len

            #Check if we wrote all the data out
            if index >= len(data):
                #We're done
                print "Sent: %d bytes to address %d" % (len(data), start_address)
                break

# 需要导入模块: from array import array [as 别名]
# 或者: from array.array import tostring [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 tostring [as 别名]
 def test_flashdevice_4_long_rw(self):
     """Long R/W test
     """
     # 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
     buf = Array('B')
     # 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), 1<<20)
     start = len(self.flash)-length
     print "Erase %s from flash (may take a while...)" % \
         pretty_size(length)
     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"
     buf.extend((randint(0, 255) for x in range(0, length)))
     # 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
     # print "Swap sequence"
     # buf.byteswap()
     # Cannot use buf, as it's an I-array, and SPI expects a B-array
     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:
         raise AssertionError('Data comparison mismatch')