def queueWrite(self, name, dataU32, addrOffset = 0):
"""Create a register write (RMW-bits) transaction element and add it to the transaction queue.
This works in the same way as a normal write(), except that many can be queued
into a packet and dispatched all at once rather than individually. Run the
queued transactions with queueRun().
Only single-register reads/writes can be queued. Block reads/writes, etc, cannot
be queued.
"""
if len(self._queuedRequests) < ChipsBus.MAX_QUEUED_REQUESTS:
dataU32 = dataU32 & 0xffffffff # Ignore oversize input.
chipsLog.debug("Write queued: dataU32 = 0x" + uInt32HexStr(dataU32) + " to register '"
+ name + "' with addrOffset = 0x" + uInt32HexStr(addrOffset))
addrTableItem = self.addrTable.getItem(name) # Get the details of the relevant item from the addr table.
if not addrTableItem.getWriteFlag():
raise ChipsException("Write transaction creation error: write is not allowed on register '" + addrTableItem.getName() + "'.")
self._queuedRequests.append(self._createRMWBitsTransactionElement(addrTableItem, dataU32, addrOffset))
self._queuedAddrTableItems.append(addrTableItem)
self._queuedIsARead.append(False)
else:
chipsLog.warning("Warning: transaction not added to queue as transaction queue has reached its maximum length!\n" +
"\tPlease either run or clear the transaction queue before continuing.\n")
def queueWrite(self, name, dataU32, addrOffset = 0):
"""Create a register write (RMW-bits) transaction element and add it to the transaction queue.
This works in the same way as a normal write(), except that many can be queued
into a packet and dispatched all at once rather than individually. Run the
queued transactions with queueRun().
Only single-register reads/writes can be queued. Block reads/writes, etc, cannot
be queued.
"""
if len(self._queuedRequests) < ChipsBus.MAX_QUEUED_REQUESTS:
dataU32 = dataU32 & 0xffffffff # Ignore oversize input.
chipsLog.debug("Write queued: dataU32 = 0x" + uInt32HexStr(dataU32) + " to register '"
+ name + "' with addrOffset = 0x" + uInt32HexStr(addrOffset))
addrTableItem = self.addrTable.getItem(name) # Get the details of the relevant item from the addr table.
if not addrTableItem.getWriteFlag():
raise ChipsException("Write transaction creation error: write is not allowed on register '" + addrTableItem.getName() + "'.")
# self._queuedRequests.append(self._createRMWBitsTransactionElement(addrTableItem, dataU32, addrOffset))
# self._queuedAddrTableItems.append(addrTableItem)
# self._queuedIsARead.append(False)
self._queuedRequests.append(self._createWriteTransactionElement(addrTableItem, [dataU32], addrOffset))
self._queuedAddrTableItems.append(addrTableItem)
self._queuedIsARead.append(False)
else:
chipsLog.warning("Warning: transaction not added to queue as transaction queue has reached its maximum length!\n" +
"\tPlease either run or clear the transaction queue before continuing.\n")
def write(self, name, dataU32, addrOffset=0):
"""Write to a single register (masked, or otherwise).
This write transaction runs straight away - i.e it's not queued at all.
Warning: using this method clears any previously queued transactions
that have not yet been run!
name: the register name of the register you want to read from.
dataU32: the 32-bit value you want writing
addrOffset: optional - provide a 32-bit word offset if you wish.
Notes:
Use the addrOffset at your own risk! No checking is done to
see if offsets are remotely sensible!
Under the hood, this is implemented as an RMW-bits transaction.
"""
if len(self._queuedRequests):
chipsLog.warning("Warning: Individual write requested, clearing previously queued transactions!\n")
self.queueClear()
dataU32 = dataU32 & 0xffffffff # Ignore oversize input.
self.queueWrite(name, dataU32, addrOffset)
self.queueRun()
def write(self, name, dataU32, addrOffset=0):
"""Write to a single register (masked, or otherwise).
This write transaction runs straight away - i.e it's not queued at all.
Warning: using this method clears any previously queued transactions
that have not yet been run!
name: the register name of the register you want to read from.
dataU32: the 32-bit value you want writing
addrOffset: optional - provide a 32-bit word offset if you wish.
Notes:
Use the addrOffset at your own risk! No checking is done to
see if offsets are remotely sensible!
Under the hood, this is implemented as an RMW-bits transaction.
"""
if len(self._queuedRequests):
chipsLog.warning("Warning: Individual write requested, clearing previously queued transactions!\n")
self.queueClear()
dataU32 = dataU32 & 0xffffffff # Ignore oversize input.
self.queueWrite(name, dataU32, addrOffset)
self.queueRun()
def read(self, name, addrOffset=0):
"""Read from a single masked/unmasked 32-bit register. The result is returned from the function.
This read transaction runs straight away - i.e it's not queued at all.
Warning: using this method clears any previously queued transactions
that have not yet been run!
name: the register name of the register you want to read from.
addrOffset: optional - provide a 32-bit word offset if you wish.
Notes: Use the addrOffset at your own risk! No checking is done to
see if offsets are remotely sensible!
"""
if len(self._queuedRequests):
chipsLog.warning(
"Warning: Individual read requested, clearing previously queued transactions!\n"
)
self.queueClear()
self.queueRead(name, addrOffset)
result = self.queueRun()
return result[0][0]
def serveForever(self):
"""The only function any user of this class needs to run!
Receives, acts on, and responds to TCP control packets as the Mini-T (or similar hardware) would.
Packets are received by the main thread and queued for action and response by a second thread.
"""
chipsLog.info("Dummy Hardware TCP Server starting")
# This starts the packet "act and respond" handler thread
self.start()
try:
chipsLog.debug("Awaiting connection...")
self._connectedSocket, addr = self._socket.accept() # TCP
chipsLog.debug("Client connection accepted.")
except KeyboardInterrupt:
chipsLog.warning(
"\nKeyboard interrupt (ctrl-c) received whilst waiting for a TCP connection"
)
self._stopServingAndJoinThreads()
return
while not self.stopServing:
try:
data = self._connectedSocket.recv(
DummyHardware.SOCKET_BUFFER_SIZE) # TCP
except KeyboardInterrupt:
chipsLog.warning(
"\nKeyboard interrupt (ctrl-c) received whilst waiting for incoming TCP packet"
)
self._stopServingAndJoinThreads()
return
except:
chipsLog.warning(
"\nException caught whilst waiting for incoming TCP packet"
)
self._stopServingAndJoinThreads()
return
if not data:
chipsLog.debug("TCP socket received an empty packet from " +
repr(addr) + ": assuming connection closed.")
try:
chipsLog.debug("Awaiting new connection...")
self._connectedSocket, addr = self._socket.accept() # TCP
chipsLog.debug("Client connection accepted.")
continue
except KeyboardInterrupt:
chipsLog.warning(
"\nKeyboard interrupt (ctrl-c) received whilst waiting for a TCP connection"
)
self._stopServingAndJoinThreads()
return
chipsLog.debug("\nReceived TCP packet from " + repr(addr))
transaction = Transaction.constructHostTransaction(data, addr)
self._transaction_queue.put(transaction)
chipsLog.info("Dummy Hardware TCP Server stopping.")
def serveForever(self):
"""The only function any user of this class needs to run!
Receives, acts on, and responds to UDP control packets as the Mini-T (or similar hardware) would.
Packets are received by the main thread and queued for action and response by a second thread.
"""
chipsLog.info("Dummy Hardware UDP Server starting")
# This starts the packet "act and respond" handler thread
self.start()
while not self.stopServing:
try:
data, addr = self._socket.recvfrom(DummyHardware.SOCKET_BUFFER_SIZE)
except KeyboardInterrupt:
chipsLog.warning("\nKeyboard interrupt (ctrl-c) received whilst waiting for incoming UDP packet")
self._stopServingAndJoinThreads()
return
except:
chipsLog.warning("\nException caught whilst waiting for incoming UDP packet")
self._stopServingAndJoinThreads()
return
if not data:
chipsLog.warning("Socket received an empty packet from " + repr(addr) + \
". Assuming socket now closed.\nTerminating dummy hardware server...")
self._stopServingAndJoinThreads()
return
else:
chipsLog.debug("\nReceived packet from " + repr(addr))
transaction = Transaction.constructHostTransaction(data, addr)
self._transaction_queue.put(transaction)
def serveForever(self):
"""The only function any user of this class needs to run!
Receives, acts on, and responds to TCP control packets as the Mini-T (or similar hardware) would.
Packets are received by the main thread and queued for action and response by a second thread.
"""
chipsLog.info("Dummy Hardware TCP Server starting")
# This starts the packet "act and respond" handler thread
self.start()
try:
chipsLog.debug("Awaiting connection...")
self._connectedSocket, addr = self._socket.accept() # TCP
chipsLog.debug("Client connection accepted.")
except KeyboardInterrupt:
chipsLog.warning("\nKeyboard interrupt (ctrl-c) received whilst waiting for a TCP connection")
self._stopServingAndJoinThreads()
return
while not self.stopServing:
try:
data = self._connectedSocket.recv(DummyHardware.SOCKET_BUFFER_SIZE) # TCP
except KeyboardInterrupt:
chipsLog.warning("\nKeyboard interrupt (ctrl-c) received whilst waiting for incoming TCP packet")
self._stopServingAndJoinThreads()
return
except:
chipsLog.warning("\nException caught whilst waiting for incoming TCP packet")
self._stopServingAndJoinThreads()
return
if not data:
chipsLog.debug("TCP socket received an empty packet from " + repr(addr) + ": assuming connection closed.")
try:
chipsLog.debug("Awaiting new connection...")
self._connectedSocket, addr = self._socket.accept() # TCP
chipsLog.debug("Client connection accepted.")
continue
except KeyboardInterrupt:
chipsLog.warning("\nKeyboard interrupt (ctrl-c) received whilst waiting for a TCP connection")
self._stopServingAndJoinThreads()
return
chipsLog.debug("\nReceived TCP packet from " + repr(addr))
transaction = Transaction.constructHostTransaction(data, addr)
self._transaction_queue.put(transaction)
chipsLog.info("Dummy Hardware TCP Server stopping.")
def read(self, name, addrOffset=0):
"""Read from a single masked/unmasked 32-bit register. The result is returned from the function.
This read transaction runs straight away - i.e it's not queued at all.
Warning: using this method clears any previously queued transactions
that have not yet been run!
name: the register name of the register you want to read from.
addrOffset: optional - provide a 32-bit word offset if you wish.
Notes: Use the addrOffset at your own risk! No checking is done to
see if offsets are remotely sensible!
"""
if len(self._queuedRequests):
chipsLog.warning("Warning: Individual read requested, clearing previously queued transactions!\n")
self.queueClear()
self.queueRead(name, addrOffset)
result = self.queueRun()
return result[0][0]
def serveForever(self):
"""The only function any user of this class needs to run!
Receives, acts on, and responds to UDP control packets as the Mini-T (or similar hardware) would.
Packets are received by the main thread and queued for action and response by a second thread.
"""
chipsLog.info("Dummy Hardware UDP Server starting")
# This starts the packet "act and respond" handler thread
self.start()
while not self.stopServing:
try:
data, addr = self._socket.recvfrom(
DummyHardware.SOCKET_BUFFER_SIZE)
except KeyboardInterrupt:
chipsLog.warning(
"\nKeyboard interrupt (ctrl-c) received whilst waiting for incoming UDP packet"
)
self._stopServingAndJoinThreads()
return
except:
chipsLog.warning(
"\nException caught whilst waiting for incoming UDP packet"
)
self._stopServingAndJoinThreads()
return
if not data:
chipsLog.warning("Socket received an empty packet from " + repr(addr) + \
". Assuming socket now closed.\nTerminating dummy hardware server...")
self._stopServingAndJoinThreads()
return
else:
chipsLog.debug("\nReceived packet from " + repr(addr))
transaction = Transaction.constructHostTransaction(data, addr)
self._transaction_queue.put(transaction)
def __init__(self, port = 50001):
DummyHardwareUdp.__init__(self, port)
chipsLog.warning("Please note: this class has been deprecated - use DummyHardwareUdp in the future.")
def __init__(self, addrTable, hostIp, hostPort, localPort = None):
ChipsBusUdp.__init__(self, addrTable, hostIp, hostPort, localPort)
chipsLog.warning("Please note: this class has been deprecated - use ChipsBusUdp"\
" in the future if you want the same functionality.")
def __init__(self, addrTable, hostIp, hostPort, localPort = None):
ChipsBusUdp.__init__(self, addrTable, hostIp, hostPort, localPort)
chipsLog.warning("Please note: this class has been deprecated - use ChipsBusUdp"\
" in the future if you want the same functionality.")
chipsLog.debug("Read queued: register '" + name + "' with addrOffset = 0x" + uInt32HexStr(addrOffset))
item = self.addrTable.getItem(name) # Get the details of the relevant item from the addr table.
try:
self._checkRWFlag(item)
except ChipsException, err:
raise ChipsException("Read error on register '" + name + "':\n\t" + str(err))
self._transactionQueue.append(self._createReadTransactionElement(item, 1, addrOffset))
self._transactionItemQueue.append(item)
self._transactionRWFlagQueue.append(1)
else:
chipsLog.warning("Warning: transaction not added to queue as transaction queue has reached its maximum length!\n" +
"\tPlease either run or clear the transaction queue before continuing.\n")
def queueWrite(self, name, dataU32, addrOffset = 0):
"""Create a register write (RMW-bits) transaction element and add it to the transaction queue.
This works in the same way as a normal write(), except that many can be queued
into a packet and dispatched all at once rather than individually. Run the
queued transactions with queueRun().
Only single-register reads/writes can be queued. Block reads/writes, etc, cannot
be queued.
"""
if len(self._transactionQueue) <= 50:
def __init__(self, port=50001):
DummyHardwareUdp.__init__(self, port)
chipsLog.warning(
"Please note: this class has been deprecated - use DummyHardwareUdp in the future."
)
