def read_data_bytes(self, size, attempt=1):
"""Read data in chunks from the chip.
Automatically strips the two modem status bytes transfered during
every read."""
# Packet size sanity check
if not self.max_packet_size:
raise FtdiError("max_packet_size is bogus")
packet_size = self.max_packet_size
length = 1 # initial condition to enter the usb_read loop
data = Array('B')
# everything we want is still in the cache?
if size <= len(self.readbuffer) - self.readoffset:
data = self.readbuffer[self.readoffset:self.readoffset + size]
self.readoffset += size
return data
# something still in the cache, but not enough to satisfy 'size'?
if len(self.readbuffer) - self.readoffset != 0:
data = self.readbuffer[self.readoffset:]
# end of readbuffer reached
self.readoffset = len(self.readbuffer)
# read from USB, filling in the local cache as it is empty
try:
while (len(data) < size) and (length > 0):
while True:
tempbuf = self._read()
attempt -= 1
length = len(tempbuf)
# the received buffer contains at least one useful databyte
# (first 2 bytes in each packet represent the current modem
# status)
if length > 2:
if self.latency_threshold:
self.latency_count = 0
if self.latency != self.latency_min:
self.set_latency_timer(self.latency_min)
self.latency = self.latency_min
# skip the status bytes
chunks = (length + packet_size - 1) // packet_size
count = packet_size - 2
self.readbuffer = Array('B')
self.readoffset = 0
srcoff = 2
for i in xrange(chunks):
self.readbuffer += tempbuf[srcoff:srcoff + count]
srcoff += packet_size
length = len(self.readbuffer)
break
else:
# received buffer only contains the modem status bytes
# no data received, may be late, try again
if attempt > 0:
continue
# no actual data
self.readbuffer = Array('B')
self.readoffset = 0
if self.latency_threshold:
self.latency_count += 1
if self.latency != self.latency_max:
if self.latency_count > self.latency_threshold:
self.set_latency_timer(self.latency_max)
self.latency = self.latency_max
# no more data to read?
return data
if length > 0:
# data still fits in buf?
if (len(data) + length) <= size:
data += self.readbuffer[self.readoffset: \
self.readoffset+length]
self.readoffset += length
# did we read exactly the right amount of bytes?
if len(data) == size:
return data
else:
# partial copy, not enough bytes in the local cache to
# fulfill the request
part_size = min(size - len(data),
len(self.readbuffer) - self.readoffset)
if part_size < 0:
raise AssertionError("Internal Error")
data += self.readbuffer[self.readoffset:\
self.readoffset+part_size]
self.readoffset += part_size
return data
except usb.core.USBError as e:
raise FtdiError('UsbError: %s' % str(e))
# never reached
raise FtdiError("Internal error")
def soft_reset_low(self):
pins = self.f.read_pins()
pins &= ~(self.SOFT_RESET_PIN)
prog_cmd = Array('B', [0x00, pins])
self.f.write_data(prog_cmd)
def program_low(self):
pins = self.f.read_pins()
pins &= ~(self.PROGRAM_PIN)
prog_cmd = Array('B', [0x00, pins])
self.f.write_data(prog_cmd)
from array import Array a = Array(2) a[0] = 1 a[1] = 'socks' b = Array(2) b[0] = 1 b[1] = 'socks' print(a) print(b) print(b == a)
def __init__(self):
self._table = Array(7)
self._count = 0
self._maxCount = len(self._table) - len(self._table)//3
def sequence(self):
"""Return the internal representation as a new mutable sequence"""
return Array('B', self._seq)
def __ilshift__(self, count):
count %= len(self)
seq = Array('B', [0] * count)
seq.extend(self._seq[:-count])
self._seq = seq
return self
def checksum(cls, hexastr):
dsum = sum(Array('B', unhexlify(hexastr)))
dsum &= 0xff
return dsum ^ 0xff
def checksum(cls, hexastr):
csum = sum(Array('B', unhexlify(hexastr)))
csum = (-csum) & 0xff
return csum
def _get_next_chunk(self):
# test if the file size can be found...
try:
import sys
self._bytes = stat(self._src.name)[6]
except Exception:
pass
bc = 0
try:
for (l, line) in enumerate(self._src, start=1):
line = line.strip()
if self._verbose and self._bytes:
opc = (50 * bc) // self._bytes
bc += len(line)
pc = (50 * bc) // self._bytes
if pc > opc:
info = '\rAnalysing SREC file [%3d%%] %s' % \
(2*pc, '.' * pc)
sys.stdout.write(info)
sys.stdout.flush()
try:
# avoid line stripping, SREC files always use DOS format
if len(line) < 5:
continue
if line[0] != 'S':
raise SRecError("Invalid SREC header")
record = int(line[1])
if record == 1:
addrend = 3
address = int(line[4:8], 16)
type_ = RecordParser.DATA
elif record == 2:
addrend = 4
address = int(line[4:10], 16)
type_ = RecordParser.DATA
elif record == 3:
addrend = 5
address = int(line[4:12], 16)
type_ = RecordParser.DATA
elif record == 7:
addrend = 5
address = int(line[4:12], 16)
type_ = RecordParser.EXECUTE
elif record == 8:
addrend = 4
address = int(line[4:10], 16)
type_ = RecordParser.EXECUTE
elif record == 9:
addrend = 3
address = int(line[4:8], 16)
type_ = RecordParser.EXECUTE
elif record == 0:
addrend = 3
address = int(line[4:8], 16)
type_ = RecordParser.INFO
else:
raise SRecError("Unsupported SREC record")
try:
bytes_ = unhexlify(line[2:-2])
except TypeError:
raise SRecError("%s @ line %s" % (str(e), l))
size = int(line[2:4], 16)
effsize = len(bytes_)
if size != effsize:
raise SRecError("Expected %d bytes, got %d "
"@ line %d" % (size, effsize, l))
if self._verify:
csum = sum(Array('B', bytes_))
csum &= 0xff
csum ^= 0xff
rsum = int(line[-2:], 16)
if rsum != csum:
raise SRecError("Invalid checksum: 0x%02x / "
"0x%02x" % (rsum, csum))
if self._verify and record:
self._verify_address(address)
yield (type_, address, bytes_[addrend:])
except RecordError as ex:
raise ex.__class__("%s @ line %d:'%s'" % (ex, l, line))
finally:
if self._verbose:
print('')
def _get_next_chunk(self):
# test if the file size can be found...
try:
import sys
self._bytes = stat(self._src.name)[6]
except Exception:
pass
bc = 0
try:
for (lpos, line) in enumerate(self._src, start=1):
line = line.strip()
if self._verbose and self._bytes:
opc = (50 * bc) // self._bytes
bc += len(line)
pc = (50 * bc) // self._bytes
if pc > opc:
info = '\rAnalysing iHEX file [%3d%%] %s' % \
(2*pc, '.' * pc)
sys.stdout.write(info)
sys.stdout.flush()
try:
if len(line) < 5:
continue
if line[0] != ':':
raise IHexError("Invalid IHEX header")
size = int(line[1:3], 16)
address = int(line[3:7], 16)
record = int(line[7:9])
if record == 0:
type_ = RecordParser.DATA
elif record == 1:
type_ = RecordParser.EOF
if address != 0:
print("Unexpected non-zero address in EOF: %04x" %
address,
file=sys.stderr)
elif record == 2:
self._offset_addr &= ~((1 << 20) - 1)
self._offset_addr |= int(line[9:-2], 16) << 4
continue
elif record == 4:
self._offset_addr = int(line[9:-2], 16) << 16
continue
elif record == 3:
type_ = RecordParser.EXECUTE
cs = int(line[9:13], 16)
ip = int(line[13:-2], 16)
address = (cs << 4) + ip
else:
raise IHexError("Unsupported IHEX record: %d" % record)
try:
bytes_ = unhexlify(line[9:-2])
except TypeError:
raise IHexError("%s @ line %s" % (str(e), lpos))
effsize = len(bytes_)
if size != effsize:
raise IHexError("Expected %d bytes, got %d "
"@ line %d" % (size, effsize, lpos))
if self._verify:
csum = sum(Array('B', unhexlify(line[1:-2])))
csum = (-csum) & 0xff
rsum = int(line[-2:], 16)
if rsum != csum:
raise IHexError("Invalid checksum: 0x%02x / "
"0x%02x" % (rsum, csum))
if type_ == RecordParser.DATA:
address += self._offset_addr
if self._verify and record:
self._verify_address(address)
yield (type_, address, bytes_)
except RecordError as ex:
raise ex.__class__("%s @ line %d:'%s'" % (ex, lpos, line))
finally:
if self._verbose:
print('')
def create_empty_buf(count):
buf = Array('B')
for i in range(count):
buf.append(0x00)
return buf
def create_inc_buf(count):
buf = Array('B')
for i in range(count):
buf.append(i % 256)
return buf
def __init__(self, trst=False, frequency=3E06):
self._ctrl = JtagController(trst, frequency)
self._sm = JtagStateMachine()
self._seq = Array('B')
from userland import olympus
from userland.dionysus import dionysus
from userland.drivers import spi
from userland.drivers import gpio
#GPIOs
DATA_COMMAND_MODE = 2
RESET = 3
VBAT_ENABLE = 4
VDD_ENABLE = 5
#SS bit
SLAVE_SELECT_BIT = 0
#COMMANDS
CONTRAST = Array('B', [0x81, 0x00])
EN_CHARGE_PUMP = Array('B', [0x8D, 0x14])
DIS_CHARGE_PUMP = Array('B', [0x8D, 0x10])
PRE_CHARGE_PER = Array('B', [0xD9, 0x00])
COMM_SEQ = Array('B', [0xDA, 0x20])
RESUME_FROM_RAM = Array('B', [0xA4])
RESUME_DISPLAY = Array('B', [0xA5])
NON_INVERT_DISPLAY = Array('B', [0xA6])
INVERT_DISPLAY = Array('B', [0xA7])
DISPLAY_OFF = Array('B', [0xAE])
DISPLAY_ON = Array('B', [0xAF])
SET_LOW_ADDRESS = Array('B', [0x00])
SET_HIGH_ADDRESS = Array('B', [0x10])
def _create_table(self):
"""Create Array filled with LinkedList"""
table = Array(self.size)
for i in range(self.size):
table[i] = LinkedList()
return table
def put_buffer(self, column_index):
for i in range((column_index * 128), ((column_index * 128) + 128)):
self.send_command(Array('B', [self.bitmap[i]]))
def coordinates(x, y):
''' Creates array containing coordinates (x, y) '''
if (x == -2) and (y == -2): # if (x, y) = (-2, -2)
return Array('h') # create an empty array in which
return Array('h', [x, y]) # to append new coordinates
def invert(self):
"""In-place invert sequence values"""
self._seq = Array('B', [x ^ 1 for x in self._seq])
return self
def __init__(self, maxSize):
self._count = 0
self._front = 0
self._back = maxSize - 1
self._qArray = Array(maxSize)
def unit_test(self):
"""unit_test
Run the unit test of the UART
"""
print "Testing UART config"
baudrate = self.get_baudrate()
print "Initial baudrate = %d" % baudrate
print "Setting baudrate to 115200"
self.set_baudrate(115200)
print "Testing if baudrate is correct"
if self.get_baudrate() > (115200 -
(115200 * .01)) and self.get_baudrate() < (
115200 + (115200 * .01)):
print "Baudrate is within 1% of target"
else:
print "Baudrate is not correct!"
print "Changing baurdrate to initial version"
self.set_baudrate(baudrate)
print "\tXXXX: Cannot test hardware flow control!"
print "Writing a string"
self.write_string("COSPAN DESIGN ROXORS TEH BIG ONE!!1!\n")
time.sleep(1)
print "Read: %s: " % self.read_string(-1)
print "disable all interrupts"
self.disable_interrupts()
print "Testing receive interrupt"
self.enable_read_interrupt()
print "Waiting 10 second for receive interrupts"
if self.o.wait_for_interrupts(1) > 0:
if self.o.is_interrupt_for_slave(self.dev_id):
print "Found a read interrupt"
print "Read: %s" % self.read_string(-1)
self.disable_read_interrupt()
print "Testing write interrupt"
self.enable_write_interrupt()
print "Waiting 1 second for write interrupts"
if self.o.wait_for_interrupts(1) > 0:
if self.o.is_interrupt_for_slave(self.dev_id):
print "Found a write interrupt!"
self.disable_write_interrupt()
print "Testing write"
print "Writing the maximum amount of data possible"
write_max = self.get_write_available() - 2
print "Max: %d" % write_max
data_out = Array('B')
num = 0
try:
for i in range(0, write_max):
num = (i) % 255
if (i / 256) % 2 == 1:
data_out.append(255 - (num))
else:
data_out.append(num)
except OverflowError as err:
print "Overflow Error: %d >= 256" % num
sys.exit(1)
self.write_raw(data_out)
print "Testing read: Type something"
time.sleep(3)
fail = False
fail_count = 0
data = self.read_all_data()
if len(data_out) != len(data):
print "data_in length not equal to data_out length:"
print "\totugoing: %d incomming: %d" % (len(data_out), len(data))
fail = True
else:
for i in range(0, len(data_out)):
if data[i] != data_out[i]:
fail = True
print "Mismatch at %d: READ DATA %d != WRITE DATA %d" % (
i, data[i], data_out[i])
fail_count += 1
if len(data) > 0:
print "Read some data from the UART"
print "data (raw): %s" % str(data)
print "data (string): %s" % str(data.tostring())
if not fail:
print "Memory test passed!"
elif (fail_count == 0):
print "Data length of data_in and data_out do not match"
else:
print "Failed: %d mismatches" % fail_count
self.write_raw(data_out)
print "look for the status conditions"
print "Status: " + hex(self.get_status())
if self.is_read_overflow():
print "Read overflow"
def setUp(self): self.array = Array(10, 0) self.offarray = Array(5, 5)
def test_device(self):
if self.d is None:
return
if self.n.get_board_name() == "sim":
self.s.Warning("Unable to run Device test with simulator")
return
self.d.reset_i2c_core()
'''
print "Check if core is enabled"
print "enabled: " + str(self.d.is_i2c_enabled())
print "Disable core"
self.d.enable_i2c(False)
print "Check if core is enabled"
print "enabled: " + str(self.d.is_i2c_enabled())
print "Check if core is enabled"
print "enabled: " + str(self.d.is_i2c_enabled())
print "Check if interrupt is enabled"
print "enabled: " + str(self.d.is_interrupt_enabled())
print "Enable interrupt"
self.d.enable_interrupt(True)
print "Check if interrupt is enabled"
print "enabled: " + str(self.d.is_interrupt_enabled())
clock_rate = self.d.get_clock_rate()
print "Clock Rate: %d" % clock_rate
print "Get clock divider"
clock_divider = self.d.get_clock_divider()
print "Clock Divider: %d" % clock_divider
print "Set clock divider to generate 100kHz clock"
self.d.set_speed_to_100khz()
print "Get clock divider"
clock_divider = self.d.get_clock_divider()
print "Clock Divider: %d" % clock_divider
print "Set clock divider to generate 400kHz clock"
self.d.set_speed_to_400khz()
print "Get clock divider"
clock_divider = self.d.get_clock_divider()
print "Clock Divider: %d" % clock_divider
print "Set a custom clock divider to get 1MHz I2C clock"
self.d.set_custom_speed(1000000)
print "Get clock divider"
clock_divider = self.d.get_clock_divider()
print "Clock Divider: %d" % clock_divider
print "Setting clock rate back to 100kHz"
'''
print "Enable core"
self.d.enable_i2c(True)
self.d.enable_interrupt(True)
self.d.get_status()
self.d.set_speed_to_100khz()
print "Check if core is enabled"
print "enabled: " + str(self.d.is_i2c_enabled())
print "Check if interrupt is enabled"
print "enabled: " + str(self.d.is_interrupt_enabled())
#PMOD AD2 (this is used on PMODA with config file:
#dionysus_i2c_pmod.json file
#The following reads ADC Channel 0
i2c_id = 0x28
data = Array('B', [0x15])
self.d.write_to_i2c(i2c_id, data)
#reading from I2C device
#print "Reading from register"
#data = Array('B', [0x02])
read_data = self.d.read_from_i2c(i2c_id, None, 2)
print "Read Data: %s" % str(read_data)
def sync(self):
if not self._ftdi:
raise JtagError("FTDI controller terminated")
if self._write_buff:
self._ftdi.write_data(self._write_buff)
self._write_buff = Array('B')
def soft_reset_high(self):
pins = self.f.read_pins()
pins |= self.SOFT_RESET_PIN
prog_cmd = Array('B', [0x01, pins])
self.f.write_data(prog_cmd)
def __init__(self, numRows, numCols):
self._numCols = numCols
self._listOfRows = Array(numRows)
def program_high(self):
pins = self.f.read_pins()
pins |= self.PROGRAM_PIN
prog_cmd = Array('B', [0x01, pins])
self.f.write_data(prog_cmd)
def read_from_i2c(self, i2c_id, i2c_write_data, read_length):
"""read_from_i2c_register
read from a register in the I2C device
Args:
i2c_id: Identification byte of the I2C (7-bit)
this value will be shifted left by 1
i2c_write_data: data to write to that register (Array of bytes)
in order to read from an I2C device the user must write some
data to set up the device to read
read_length: Length of bytes to read from the device
Returns:
Array of bytes read from the I2C device
Raises:
NysaCommError: Error in communication
I2CError: Errors associated with the I2C protocol
"""
#self.debug = False
if self.debug: print "read_from_i2c: ENTERED"
#set up a write command
read_command = (i2c_id << 1) | 0x01
read_data = Array('B')
self.reset_i2c_core()
if self.debug:
print "\t\tGetting status before a read"
self.print_status(self.read_register(STATUS))
print "\t\tGetting status before a read"
self.print_status(self.read_register(STATUS))
#setup the registers to read
if i2c_write_data is not None:
if self.debug: print "Writing to I2C"
self.write_to_i2c(i2c_id, i2c_write_data)
#set up interrupts
self.enable_interrupt(True)
#send the write command / i2c identification
self.write_register(TRANSMIT, read_command)
command = COMMAND_START | COMMAND_WRITE
if self.debug:
self.print_command(command)
#send the command to the I2C command register to initiate a transfer
self.write_register(COMMAND, command)
#wait 1 second for interrupt
if self.wait_for_interrupts(wait_time=1):
if self.debug:
print "got interrupt for start"
#if self.is_interrupt_for_slave():
status = self.get_status()
if self.debug:
self.print_status(status)
if (status & STATUS_READ_ACK_N) > 0:
raise I2CError("Did not recieve an ACK while writing I2C ID")
else:
if self.debug:
self.print_status(self.get_status())
raise I2CError(
"Timed out while waiting for interrupt durring a start")
#send the data
count = 0
if read_length > 1:
while count < read_length - 1:
self.get_status()
if self.debug:
print "\tReading %d" % count
self.write_register(COMMAND, COMMAND_READ)
if self.wait_for_interrupts(wait_time=1):
if self.get_status() & 0x01:
#print "Status: 0x%08X" % self.get_status()
if self.debug:
print "got interrupt for data"
#if self.is_interrupt_for_slave(self.dev_id):
status = self.get_status()
#if (status & STATUS_READ_ACK_N) > 0:
# raise I2CError("Did not receive an ACK while reading data")
value = self.read_register(RECEIVE)
if self.debug:
print "value: %s" % str(value)
read_data.append((value & 0xFF))
else:
raise I2CError(
"Timed out while waiting for interrupt during read data"
)
count = count + 1
#read the last peice of data
self.write_register(COMMAND,
COMMAND_READ | COMMAND_NACK | COMMAND_STOP)
if self.wait_for_interrupts(wait_time=1):
if self.debug:
print "got interrupt for the last byte"
if self.get_status() & 0x01:
#if self.is_interrupt_for_slave(self.dev_id):
#status = self.get_status()
#if (status & STATUS_READ_ACK_N) > 0:
# raise I2CError("Did not receive an ACK while writing data")
value = self.read_register(RECEIVE)
if self.debug:
print "value: %d" % value
read_data.append(value & 0xFF)
else:
raise I2CError(
"Timed out while waiting for interrupt while reading the last byte"
)
#self.debug = False
return read_data
def pins_off(self):
prog_cmd = Array('B', [0x01, 0x00])
self.f.write_data(prog_cmd)
def program_mcu(self, filepath):
if self.is_attached():
if self.is_prometheus_attached():
if self.debug:
print "Prometheus attached, issuing reset to boot command..."
self.reset_to_boot_mode()
print "Was in FX3 Mode, change to boot mode..."
time.sleep(2)
self.connect_to_boot()
if not self._is_boot_connected():
d = usb.core.show_devices()
raise PrometheusUSBError(
"BUG: pyusb doesn't re-enumerate very well so re-run this script to program MCU"
)
f = open(filepath, 'r')
buf = Array('B')
buf.fromstring(f.read())
f.close()
pos = 0
cyp_id = "%c%c" % (buf[0], buf[1])
image_cntrl = buf[2]
image_type = buf[3]
length = float(len(buf[4:]))
pos = 4
checksum = 0
program_entry = 0x00
if cyp_id != "CY":
raise PrometheusUSBError(
"Image File does not start with Cypress ID: 'CY': %s" %
str(buf[0:1]))
if image_cntrl & 0x01 != 0:
raise PrometheusUSBError(
"Image Control Byte bit 0 != 1, this file is not an executable"
)
if image_type != 0xB0:
raise PrometheusUSBError("Not a normal FW Binary with Checksum")
while True:
size = (buf[pos + 3] << 24) + (buf[pos + 2] << 16) + (
buf[pos + 1] << 8) + buf[pos]
pos += 4
address = (buf[pos + 3] << 24) + (buf[pos + 2] << 16) + (
buf[pos + 1] << 8) + buf[pos]
pos += 4
if size > 0:
data = buf[pos:(pos + size * 4)]
self._write_program_data(address, data)
for i in range(0, (size * 4), 4):
checksum += ((data[i + 3] << 24) + (data[i + 2] << 16) +
(data[i + 1] << 8) + (data[i]))
checksum = checksum & 0xFFFFFFFF
pos += (size * 4)
else:
program_entry = address
break
if self.debug:
sys.stdout.write("\r%%% 3.1f" % (100 * pos / length))
if self.debug: sys.stdout.flush()
if self.debug: print ""
read_checksum = (buf[pos + 3] << 24) + (buf[pos + 2] << 16) + (
buf[pos + 1] << 8) + buf[pos]
if read_checksum != checksum:
raise PrometheusUSBError(
"Checksum from file != Checksum from Data: 0x%X != 0x%X" %
(read_checksum, checksum))
time.sleep(1)
if self.debug: print "Sending Reset"
try:
write_len = self.dev.ctrl_transfer(
bmRequestType=0x40, #VRequest, To the devce, Endpoint
bRequest=0xA0, #Vendor Specific
wValue=program_entry & 0x0000FFFF, #Entry point of the program
wIndex=program_entry >> 16,
#data_or_wLength = 0, #No Data
timeout=1000) #Timeout = 1 second
except usb.core.USBError, err:
pass
