class AudioEventRx(object):
def __init__(self, ip, cmd,src):
# print "AudioEventRx::__init__"
self.ip = ip
self.eio = NetEventIO(ip)
self.eio.addRXMask(cmd,src)
self.eio.start()
self.buffer = ""
self.count = 0
def getAudioBuffer(self, size):
if len(self.buffer)<size:
self.getData()
data = self.buffer[:size]
self.buffer = self.buffer[size:]
return data
def getData(self):
self.count +=1
erx = self.eio.getEvents()
if self.count%10==0: print len(erx)
if len(erx)>640:
erx = erx[640:]
for event in erx:
self.buffer += struct.pack('<h', event.data[1])
self.buffer += struct.pack('<h', event.data[2])
self.buffer += struct.pack('<h', event.data[3])
self.buffer += struct.pack('<h', event.data[4])
def pingset(dspboardaddrs):
eio = NetEventIO("10.0.0.2")
eio.addRXMask(0xF1, xrange(256))
eio.start()
# Create event and set mask
N = 40
x = n.zeros(N)
for i in range(N):
e = Event()
e.src = eaddr.NETWORK
e.cmd = 0xF0
e.data[0] = 0x1234
ea = eaddr.TXDest()
for d in dspboardaddrs:
ea[d] = 1
eio.sendEvent(ea, e)
erx = eio.getEvents()
x[i] = len(erx)
eio.stop()
pylab.figure()
pylab.hist(x)
def __init__(self, somaIP, tgts):
self.eio = NetEventIO(somaIP)
self.pingtgts = set(tgts)
for i in self.pingtgts:
#self.eio.addRXMask(0x09, i)
self.eio.addRXMask(PING_RESPONSE_CMD, i)
self.eio.start()
def __init__(self, *args):
dbus.service.Object.__init__(self, *args)
# State Variables
self.playing = False
self.audioChan = 0x20;
self.selectedAudioChan = self.audioChan
self.subChan = 0; #most likely will refere to a tetrode sub-channel
self.selectedSubChan = self.subChan
self.eio = NetEventIO("10.0.0.2")
# AudioControl Event Constants setup on 10/13/08
self.AUDIO_EVENT_CMD = 0x12
self.ENABLE_AUDIO_EVENTS = 1
self.DISABLE_AUDIO_EVENTS = 0
self.AUDIO_REQUEST = 0
self.AUDIO_UPDATE = 1
#Create GST elements - pipeline will not be created
gobject.type_register(SomaAudioEventFilter)
self.eventSource = gst.element_factory_make('somaeventsource', "SomaEventSource")
self.audioEventFilter = SomaAudioEventFilter()
self.AUDIO_SINK = "pulsesink"
self.audioSink = gst.element_factory_make(self.AUDIO_SINK)
self.audioConverter = gst.element_factory_make("audioconvert")
self.audioResampler= gst.element_factory_make("audioresample")
self.queue = gst.element_factory_make("queue")
self.pipeline = None
def __init__(self, SOMAIP):
self.eio = NetEventIO(SOMAIP)
self.src = eaddr.NETWORK
self.eio.addRXMask(xrange(256), eaddr.SYSCONTROL)
self.eio.start()
def __init__(self, ip, cmd,src): # print "AudioEventRx::__init__" self.ip = ip self.eio = NetEventIO(ip) self.eio.addRXMask(cmd,src) self.eio.start() self.buffer = "" self.count = 0
def __init__(self, somaIP, tgts):
self.eio = NetEventIO(somaIP)
self.pingtgts = set(tgts)
for i in self.pingtgts:
# self.eio.addRXMask(0x09, i)
self.eio.addRXMask(PING_RESPONSE_CMD, i)
self.eio.start()
def youare(devicenums):
eio = NetEventIO("10.0.0.2")
for d in devicenums:
eio.addRXMask(xrange(256), int(d))
eio.start()
EVENTCMD_YOUARE = 0x01
for i in devicenums:
devicelinknum = int(i)
for device in xrange(4):
e = Event()
e.cmd = EVENTCMD_YOUARE
e.src = eaddr.NETWORK
deviceid = 8 + devicelinknum * 4 + device
e.data[0] = deviceid
ea = eaddr.TXDest()
ea[deviceid] = 1
print "Sending youare for ", deviceid, e
reallysend(eio, ea, e)
eio.stop()
class FPGAPing(object):
def __init__(self, somaIP, tgts):
self.eio = NetEventIO(somaIP)
self.pingtgts = set(tgts)
for i in self.pingtgts:
# self.eio.addRXMask(0x09, i)
self.eio.addRXMask(PING_RESPONSE_CMD, i)
self.eio.start()
def ping(self):
# Create event and set mask
e = Event()
e.src = eaddr.NETWORK
e.cmd = 0x08
e.data[0] = 0x1234
e.data[1] = 0x5678
ea = eaddr.TXDest()
for i in self.pingtgts:
ea[i] = 1
self.eio.sendEvent(ea, e)
starttime = time.time()
PINGWAIT = 1.0
eventsrxed = []
while len(eventsrxed) < len(self.pingtgts):
erx = self.eio.getEvents(blocking=False)
if erx != None:
for eias in erx:
print eias
eventsrxed += erx
if time.time() > starttime + PINGWAIT:
break
rxset = set()
for e in eventsrxed:
rxset.add(e.src)
missing = self.pingtgts.difference(rxset)
return (rxset, missing)
def stop(self):
self.eio.stop()
class FPGAPing(object):
def __init__(self, somaIP, tgts):
self.eio = NetEventIO(somaIP)
self.pingtgts = set(tgts)
for i in self.pingtgts:
#self.eio.addRXMask(0x09, i)
self.eio.addRXMask(PING_RESPONSE_CMD, i)
self.eio.start()
def ping(self):
# Create event and set mask
e = Event()
e.src = eaddr.NETWORK
e.cmd = 0x08
e.data[0] = 0x1234
e.data[1] = 0x5678
ea = eaddr.TXDest()
for i in self.pingtgts:
ea[i] = 1
self.eio.sendEvent(ea, e)
starttime = time.time()
PINGWAIT = 1.0
eventsrxed = []
while len(eventsrxed) < len(self.pingtgts):
erx = self.eio.getEvents(blocking=False)
if erx != None:
for eias in erx:
print eias
eventsrxed += erx
if time.time() > starttime + PINGWAIT:
break
rxset = set()
for e in eventsrxed:
rxset.add(e.src)
missing = self.pingtgts.difference(rxset)
return (rxset, missing)
def stop(self):
self.eio.stop()
def debug(dspboardaddrs):
eio = NetEventIO("10.0.0.2")
eio.addRXMask(0x38, dspboardaddrs)
eio.start()
print "Sending to ", dspboardaddrs
# Create event and set mask
e = Event()
e.src = eaddr.NETWORK
e.cmd = 0x38
for d in dspboardaddrs:
ea = eaddr.TXDest()
ea[d] = 1
eio.sendEvent(ea, e)
print "sending", e
erx = eio.getEvents()
print erx[0]
eio.stop()
def ping_digital_out(ip):
addr = DIGITAL_OUT
eio = NetEventIO(ip)
eio.addRXMask(PING_RESPONSE_CMD, [addr])
eio.start()
e = Event()
e.src = eaddr.NETWORK
e.cmd = 0x08
e.data[0] = 0x1234
e.data[1] = 0x5678
ea = eaddr.TXDest()
ea[addr] = 1
eio.sendEvent(ea, e)
erx = eio.getEvents(blocking=True)
for e in erx:
print e
eio.stop()
"""
Uses the EchoProc on the DSP to measure our current RAM use
"""
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
eio = NetEventIO("10.0.0.2")
DSPBOARDADDR = int(sys.argv[1])
ECMD_ECHOPROC_MEMCHECK = 0xF8
ECMD_ECHOPROC_MEMCHECK_RESP = 0xF9
eio.addRXMask(ECMD_ECHOPROC_MEMCHECK_RESP, xrange(256))
eio.start()
# Create event and set mask
e = Event()
e.src = eaddr.NETWORK
e.cmd = ECMD_ECHOPROC_MEMCHECK
ea = eaddr.TXDest()
ea[DSPBOARDADDR] = 1
eio.sendEvent(ea, e)
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
eio = NetEventIO("10.0.0.2")
stattgts = set()
for who in sys.argv[1:]:
if '-' in who:
# this is a range
(startstr, endstr) = who.split("-")
for r in range(int(startstr), int(endstr) + 1):
stattgts.add(r)
else:
stattgts.add(int(who))
for i in stattgts:
eio.addRXMask(xrange(256), i)
eio.start()
# Create event and set mask
e = Event()
e.src = eaddr.NETWORK
e.cmd = 0x40 # query link status status
e.data[0] = 0 # param 0 , link status
e.data[1] = 0
"""
Monitor and print all acqdatasource events
"""
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
eio = NetEventIO("10.0.0.2")
DSPBOARDADDR = int(sys.argv[1])
ACQDATASOURCE_CMDRESP = 0x42
eio.addRXMask(ACQDATASOURCE_CMDRESP, DSPBOARDADDR)
eio.start()
while True:
erx = eio.getEvents()
for q in erx:
print q
eio.stop()
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
eio = NetEventIO("10.0.0.2")
timerid = 0
timecmd = 0x10
eio.addRXMask(timecmd, timerid)
eio.start()
erx = eio.getEvents()
for event in erx:
print event
eio.stop()
"""
Dump the DSPboard's echoproc counter information
(for benchmarking)
"""
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
eio = NetEventIO("10.0.0.2")
DSPBOARDADDR = int(sys.argv[1])
eio.addRXMask([0xF4], DSPBOARDADDR)
eio.start()
CMD = 0xF4
# Create event and set mask
N = 8
for i in xrange(4):
e = Event()
e.src = eaddr.NETWORK
e.cmd = CMD
e.data[0] = i
ea = eaddr.TXDest()
ea[DSPBOARDADDR] = 1
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
ECMD_ECHOPROC_MEMCHECK = 0xF8
ECMD_ECHOPROC_MEMCHECK_RESP = 0xF9
ECMD_ECHOPROC_BENCHMARK = 0xF4
ECMD_ECHOPROC_BENCHMARK_RESP = 0xF4
dspboardaddrs = [int(x) for x in sys.argv[1:]]
eio = NetEventIO("10.0.0.2")
eio.addRXMask(ECMD_ECHOPROC_MEMCHECK_RESP, dspboardaddrs)
eio.addRXMask(ECMD_ECHOPROC_BENCHMARK_RESP, dspboardaddrs)
eio.start()
for d in dspboardaddrs:
print "Device %02x ----------------------------------------" % (d, )
# Create event and set mask
e = Event()
e.src = eaddr.NETWORK
e.cmd = ECMD_ECHOPROC_MEMCHECK
ea = eaddr.TXDest()
ea[d] = 1
import sys
sys.path.append("../")
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
eio = NetEventIO("10.0.0.2")
ECMD_PINGREQ = 0x08
ECMD_PINGRESP = 0x09
eio.addRXMask(ECMD_PINGRESP, eaddr.SYSCONTROL)
eio.start()
e = Event()
e.src = eaddr.NETWORK
e.cmd = ECMD_PINGREQ
ea = eaddr.TXDest()
ea[eaddr.SYSCONTROL] = 1
print "sending request", e
eio.sendEvent(ea, e)
eio.sendEvent(ea, e)
eio.sendEvent(ea, e)
eio.sendEvent(ea, e)
rxevents = []
while len(rxevents) < 4:
erx = eio.getEvents()
rxevents += erx
def pingset(dspboardaddrs):
eio = NetEventIO("10.0.0.2")
eio.addRXMask(0xF1, xrange(256))
eio.start()
# Create event and set mask
N = 40
x = n.zeros(N)
for i in range(N):
e = Event()
e.src = eaddr.NETWORK
e.cmd = 0xF0
e.data[0] = 0x1234
ea = eaddr.TXDest()
for d in dspboardaddrs:
ea[d] = 1
eio.sendEvent(ea, e)
erx = eio.getEvents()
x[i] = len(erx)
eio.stop()
pylab.figure()
pylab.hist(x)
import sys
sys.path.append("../")
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
eio = NetEventIO("10.0.0.2")
eio.addRXMask(xrange(256), eaddr.NETWORK)
eio.start()
e = Event()
for i in xrange(4):
e.src = eaddr.NETWORK
e.cmd = 0x20
e.data[0] = 0x0123
e.data[1] = 0x4564
e.data[2] = 0x1122
e.data[3] = 0x89AB
e.data[4] = i
ea = eaddr.TXDest()
ea[eaddr.NETWORK] = 1
eio.sendEvent(ea, e)
events = []
import sys from somapynet.event import Event from somapynet import eaddr from somapynet.neteventio import NetEventIO import struct import time somaip = sys.argv[1] eio = NetEventIO(somaip) DSPBOARDADDR = int(sys.argv[2]) eio.addRXMask(xrange(256), DSPBOARDADDR) eio.start() # Create event and set mask e = Event() e.src = eaddr.NETWORK e.cmd = 0x40 # query link status status e.data[0] = 0 # param 0 , link status e.data[1] = 0 ea = eaddr.TXDest() ea[DSPBOARDADDR] = 1 eio.sendEvent(ea, e) print "acq link status query sent, waiting for response"
"""
Try and PING the DSPboard
"""
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
eio = NetEventIO("10.0.0.2")
DSPBOARDADDR = 0x08
#eio.addRXMask(xrange(256), DSPBOARDADDR)
eio.addRXMask(xrange(256), 0xAB)
eio.start()
# Create event and set mask
## e = Event()
## e.src = eaddr.NETWORK
## e.cmd = 0x30
## e.data[0] = 0x1234
## e.data[1] = 0x5678
## ea = eaddr.TXDest()
## ea[DSPBOARDADDR] = 1
## eio.sendEvent(ea, e)
erx = eio.getEvents()
"""
Dump the DSPboard's echoproc counter information
(for benchmarking)
"""
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
eio = NetEventIO("10.0.0.2")
DSPBOARDADDR = int(sys.argv[1])
eio.addRXMask([0xF4], DSPBOARDADDR)
eio.start()
CMD = 0xF4
# Create event and set mask
N = 8
for i in xrange(4):
e = Event()
e.src = eaddr.NETWORK
e.cmd = CMD
e.data[0] = i
ea = eaddr.TXDest()
ea[DSPBOARDADDR] = 1
def main():
dspaddrs = set()
for who in sys.argv[2:]:
if '-' in who:
# this is a range
(startstr, endstr) = who.split("-")
for r in range(int(startstr), int(endstr)+1):
dspaddrs.add(r)
else:
dspaddrs.add(int(who))
if len(dspaddrs) == 0:
raise Exception("Must specify at least one dsp board target")
eio = NetEventIO("10.0.0.2")
#DSPBOARDADDR = tgt
for d in dspaddrs:
eio.addRXMask(xrange(256), d)
eio.start()
ea = eaddr.TXDest()
for d in dspaddrs:
ea[d] = 1
print "Asserting DSP reset"
e = Event()
e.src = eaddr.NETWORK
e.cmd = EVENTRXCMD_DSPRESET
e.data[0] = 0x0000
reallysend(eio, ea, e)
print "Deasserting DSP reset"
e = Event()
e.src = eaddr.NETWORK
e.cmd = EVENTRXCMD_DSPRESET
e.data[0] = 0xFFFF
reallysend(eio, ea, e)
print "Acquiring DSP SPI interface for FPGA"
e = Event()
e.src = eaddr.NETWORK
e.cmd = EVENTRXCMD_DSPSPIEN
e.data[0] = 0xFFFF
reallysend(eio, ea, e)
print "Deasserting SPISS"
e = Event()
e.src = eaddr.NETWORK
e.cmd = EVENTRXCMD_DSPSPISS
e.data[0] = 0xFFFF
reallysend(eio, ea, e)
print "Reasserting SPISS"
e = Event()
e.src = eaddr.NETWORK
e.cmd = EVENTRXCMD_DSPSPISS
e.data[0] = 0x0000
reallysend(eio, ea, e)
time.sleep(1)
# load up the blocks and send
blocks = loadfiles()
blockpos = 0
for byteblock in blocks:
MAXLEN = 1024
chunks = chunk(byteblock, MAXLEN)
print "byteblock, len = ", len(byteblock), len(chunks), "chunks"
cpos = 0
for b in chunks:
pos = 0
while pos < len(b):
bytes = b[pos:pos+2]
words = struct.unpack(">H", bytes)
e = Event()
e.src = eaddr.NETWORK
e.cmd = EVENTRXCMD_DATABUF
e.data[0] = words[0]
e.data[1] = pos / 2
ea = eaddr.TXDest()
for d in dspaddrs:
ea[d] = 1
reallysend(eio, ea, e) # idempotent
pos += 2
e = Event()
e.src = eaddr.NETWORK
e.cmd = EVENTRXCMD_DATABUFTX
# this is the length
e.data[0] = pos/2
# now the nonce
e.data[1] = cpos * 256 + pos
ea = eaddr.TXDest()
for d in dspaddrs:
ea[d] = 1
reallysend(eio, ea, e)
print "sent databuftx event, blockpos =%d, block len = %d, chunk number %d" % (blockpos, len(b), cpos)
# we need to get events from everyone
ecnt = 0
while ecnt < len(dspaddrs):
erx = eio.getEvents()
for q in erx:
ecnt += 1
print "Heard back from ", q.src, q
cpos += 1
blockpos += 1
e = Event()
e.src = eaddr.NETWORK
e.cmd = EVENTRXCMD_DSPSPISS
e.data[0] = 0xFFFF
ea = eaddr.TXDest()
for d in dspaddrs:
ea[d] = 1
reallysend(eio, ea, e)
# Give DSP control of SPI interface
e = Event()
e.src = eaddr.NETWORK
e.cmd = EVENTRXCMD_DSPSPIEN
e.data[0] = 0x0000
ea = eaddr.TXDest()
for d in dspaddrs:
ea[d] = 1
reallysend(eio, ea, e)
time.sleep(1)
# now send all of the UART settings
e = Event()
e.src = eaddr.NETWORK
e.cmd = 0x37
for d in dspaddrs:
e.data[0] = d
e.data[1] = d
e.data[2] = d
e.data[3] = d
e.data[4] = d
ea = eaddr.TXDest()
ea[d] = 1
reallysend(eio, ea, e)
eio.stop()
v = struct.unpack("L", s)[0]
print "git sha-1 begins: %16.16x" % v
def print_build_time(evt):
print evt
x = evt.data[1] << 16 | evt.data[2]
print "build time:", time.asctime(time.localtime(x))
funcs = {8: print_name, 9: print_version, 10: print_hash, 11: print_build_time}
somaip = sys.argv[1]
eio = NetEventIO(somaip)
DSPBOARDADDR = int(sys.argv[2])
ECMD_VERSION_QUERY = 0x04
eio.addRXMask(ECMD_VERSION_QUERY, DSPBOARDADDR)
eio.start()
for field in range(0, 4):
# Create event and set mask
e = Event()
e.src = eaddr.NETWORK
e.cmd = ECMD_VERSION_QUERY
e.data[0] = (1 << 15) | field
ea = eaddr.TXDest()
def digital_out(ip):
addr = ADDR_DIGITAL_OUT
eio = NetEventIO(ip)
eio.addRXMask(xrange(256), [addr])
eio.start()
vals = True
while True:
e = Event()
e.src = eaddr.NETWORK
e.cmd = DIGITALOUT_WRITE
e.data[0] = 0xFFFF
e.data[1] = 0xFFFF
if vals:
e.data[2] = 0xFFFF
e.data[3] = 0xFFFF
else:
e.data[2] = 0x0
e.data[3] = 0x0
ea = eaddr.TXDest()
ea[addr] = 1
eio.sendEvent(ea, e)
# now read
e = Event()
e.src = eaddr.NETWORK
e.cmd = DIGITALOUT_READ
ea = eaddr.TXDest()
ea[addr] = 1
eio.sendEvent(ea, e)
erx = eio.getEvents(blocking=True)
for e in erx:
print e
vals = not vals
time.sleep(0.2)
eio.stop()
action="store_true",
dest="query",
default=False,
help="Query the status")
parser.add_option("-t",
"--set-threshold",
dest="threshold",
help="Set the threshold to this mV")
(options, args) = parser.parse_args()
# args are the non-captured arguments
devices = [int(x) for x in args]
if options.query:
eio = NetEventIO("10.0.0.2")
thresholds = {}
for d in devices:
eio.addRXMask(ECMD_RESPONSE, d)
eio.start()
for chan in range(4):
e = Event()
e.src = eaddr.NETWORK
e.cmd = ECMD_QUERY
e.data[0] = PARAM_THRESHOLD
e.data[1] = chan
ea = eaddr.TXDest()
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
somaIP = "127.0.0.1"
eio = NetEventIO(somaIP)
dev = 40
eio.addRXMask(xrange(256), dev)
eio.start()
e = Event()
e.src = eaddr.NETWORK
e.cmd = 0x30
e.data[0] = 1
e.data[1] = 1
e.data[2] = 1
e.data[3] = 0
ea = eaddr.TXDest()
ea[dev] = 1
eio.sendEvent(ea, e)
for i in range(100):
def debug(dspboardaddrs):
eio = NetEventIO("10.0.0.2")
eio.addRXMask(0x38, dspboardaddrs)
eio.start()
print "Sending to ", dspboardaddrs
# Create event and set mask
e = Event()
e.src = eaddr.NETWORK
e.cmd = 0x38
for d in dspboardaddrs:
ea = eaddr.TXDest()
ea[d] = 1
eio.sendEvent(ea, e)
print "sending", e
erx = eio.getEvents()
print erx[0]
eio.stop()
"""
Try and flash the DSPboard FPGA EVENT leds
"""
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
eio = NetEventIO("10.0.0.2")
eio.start()
CMD = 0x31
# Create event and set mask
N = 8
def getiset(j):
return [q for q in range(j * 4 + 8, j*4 + 12)]
def setLED(addrs, stateon):
e = Event()
e.src = eaddr.NETWORK
e.cmd = CMD
if stateon:
e.data[0] = 0xFFFF
else:
e.data[0] = 0x0000
class DeviceLinkStatus(object):
def __init__(self, SOMAIP):
self.eio = NetEventIO(SOMAIP)
self.src = eaddr.NETWORK
self.eio.addRXMask(xrange(256), eaddr.SYSCONTROL)
self.eio.start()
def getLinkStatus(self, DEVN):
# get the link status event
e = Event()
e.src = self.src
e.cmd = 0x20
ea = eaddr.TXDest()
ea[eaddr.SYSCONTROL] = 1
self.eio.sendEvent(ea, e)
erx = self.eio.getEvents()
linkstatus_event = erx[0]
# now parse the link status event
status = []
for i in range(DEVN):
if (linkstatus_event.data[1] >> i) & 0x1 > 0:
status.append(True)
else:
status.append(False)
return status
def getLinkCycleCount(self, DEVN):
# now get all of the counter events
rx_set = {}
for i in range(DEVN):
e = Event()
e.src = self.src
e.cmd = 0x21
e.data[0] = i
ea = eaddr.TXDest()
ea[eaddr.SYSCONTROL] = 1
self.eio.sendEvent(ea, e)
erx = self.eio.getEvents()
rx_set[i] = erx
cyclecnt = []
for i in range(DEVN):
cyclecnt.append(rx_set[i][0].data[2])
return cyclecnt
## print debug_event
## for i in range(DEVN):
## dly = (-1, -1)
## if i in delays:
## dly = (delays[i] >> 8, delays[1] & 0xFF)
## if (linkstatus_event.data[1] >> i) & 0x1 > 0:
## print "Device %2d : UP" % i,
## else:
## print "Device %2d : " % i,
## print "%d link cycles" % (rx_set[i][0].data[2] )
def getDLTiming(self):
# now get the debug counters
e = Event()
e.src = self.src
e.cmd = 0x22
ea = eaddr.TXDest()
ea[eaddr.SYSCONTROL] = 1
self.eio.sendEvent(ea, e)
erx = self.eio.getEvents()
for e in erx:
debug_event = erx[0]
timings = []
for ei in range(4):
tpos = (debug_event.data[ei] >> 8 ) & 0xFF
tlen = debug_event.data[ei] & 0xFF
timings.append((tpos, tlen))
return timings
def stop(self):
self.eio.stop()
"""
Ping the DSP on the DSPboard
The first argument is the deviceID of the DSP
"""
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
eio = NetEventIO("10.0.0.2")
pingtgts = set()
for who in sys.argv[1:]:
if '-' in who:
# this is a range
(startstr, endstr) = who.split("-")
for r in range(int(startstr), int(endstr) + 1):
pingtgts.add(r)
else:
pingtgts.add(int(who))
for i in pingtgts:
eio.addRXMask(xrange(256), i)
eio.addRXMask(xrange(256), xrange(1, 0x4c))
eio.start()
This is a port from the jtag debug 'readpointers.py'
"""
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
sys.path.append("../../jtag")
import jtag
if len(sys.argv) > 1 and sys.argv[1] == "jtag":
eio = jtag.JTAGEventIO()
src = eaddr.JTAG
else:
eio = NetEventIO("10.0.0.2")
src = eaddr.NETWORK
eio.addRXMask(xrange(256), eaddr.NETCONTROL)
eio.start()
def readreg(val):
e = Event()
e.src = src
e.cmd = 0x30
e.data[0] = 0
e.data[1] = val
e.data[2] = 0
"""
Set the UART ID of the DSPboard
Not necessary with newest dspboot.py
"""
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
eio = NetEventIO("10.0.0.2")
DSPBOARDADDR = int(sys.argv[1])
eio.addRXMask(xrange(256), DSPBOARDADDR)
eio.start()
# Create event and set mask
e = Event()
e.src = eaddr.NETWORK
e.cmd = 0x37
e.data[0] = DSPBOARDADDR
e.data[1] = DSPBOARDADDR
e.data[2] = DSPBOARDADDR
e.data[3] = DSPBOARDADDR
e.data[4] = DSPBOARDADDR
from somapynet.neteventio import NetEventIO
import struct
import time
ECMD_ECHOPROC_MEMCHECK = 0xF8
ECMD_ECHOPROC_MEMCHECK_RESP = 0xF9
ECMD_ECHOPROC_BENCHMARK = 0xF4
ECMD_ECHOPROC_BENCHMARK_RESP = 0xF4
dspboardaddrs = [int(x) for x in sys.argv[1:]]
eio = NetEventIO("10.0.0.2")
eio.addRXMask(ECMD_ECHOPROC_MEMCHECK_RESP, dspboardaddrs)
eio.addRXMask(ECMD_ECHOPROC_BENCHMARK_RESP, dspboardaddrs)
eio.start()
for d in dspboardaddrs:
print "Device %02x ----------------------------------------" % (d,)
# Create event and set mask
e = Event()
e.src = eaddr.NETWORK
e.cmd = ECMD_ECHOPROC_MEMCHECK
ea = eaddr.TXDest()
ea[d] = 1
class AcqBoardInterface(object):
CMDFIBERCMD = 0x50
CMDFIBERDATAA = 128
CMDFIBERDATAB = 129
CMDFIBERRESP = 0x82
DESTSRCID = 76
def __init__(self, IP="10.0.0.2", set = 'A'):
self.eio = NetEventIO(IP)
self.set = set
def sendCommandAndBlock(self, acqboardcmd):
"""
acqboardcmd is an AcqBoardCommand object whose state represents
the most recent state change to the board;
we retreive the encoded string with acqboardcmd.latestString
and the most recent commandID with .
"""
# setup rx
self.eio.addRXMask(self.CMDFIBERRESP, xrange(256) )
SRC = 3
acmdstr = acqboardcmd.latestString
# this is a total hack, we extract out the command byte
bytes = struct.unpack("BBBBBB", acmdstr)
cmdid = bytes[0] >> 4
cmd = bytes[0] & 0xF
assert cmdid == acqboardcmd.cmdid
self.eio.start()
ea = eaddr.TXDest()
ea[:] = 1
e = Event()
e.cmd = self.CMDFIBERCMD
e.src = SRC
e.data[0] = (cmdid << 8) | cmd
e.data[1] = bytes[4] << 8 | bytes[3]
e.data[2] = bytes[2] << 8 | bytes[1]
## Substantial debugging
#cmdtuple = (0x50, 4, (cmdid << 8) | (cmd & 0xF), 1, 0, 0, 0)
#self.pne.sendEvent(addrtuple, cmdtuple)
print "sending event", e
self.eio.sendEvent(ea, e)
success = False
while success == False:
erx = self.eio.getEvents()
# extract out events
for e in erx:
#print e
if e.cmd == self.CMDFIBERRESP: # and e.src == self.DESTSRCID:
# response; extract out bits
cmdid = e.data[0]
if cmdid == acqboardcmd.cmdid:
success = True
self.eio.stop()
def getSamples(self, N):
""" Very simple interface to getting
samples -- at the moment we just return N samples
from either the A channels or the B channels"""
data = n.zeros((5, N), dtype=n.int16)
if self.set == "A":
self.eio.addRXMask(self.CMDFIBERDATAA, xrange(256) )
elif self.set == "B" :
self.eio.addRXMask(self.CMDFIBERDATAB, xrange(256) )
else:
# both
self.eio.addRXMask(self.CMDFIBERDATAA, xrange(256) )
self.eio.addRXMask(self.CMDFIBERDATAB, xrange(256) )
self.eio.start()
receivedN = 0
while (receivedN < N):
erx = self.eio.getEvents()
for e in erx:
if receivedN < N:
for i in xrange(5):
data[i][receivedN] = e.data[i]
receivedN += 1
self.eio.stop()
return data
def getNormSamplesA(self, N):
"""
Return 5xN "normal", that is not-raw-mode, samples, from
the A tetrode set of channels
"""
self.set = "A"
return self.getSamples(N)
def getNormSamplesB(self, N):
"""
Return 5xN "normal", that is not-raw-mode, samples, from
the B tetrode set of channels
"""
self.set = "B"
return self.getSamples(N)
def getRawSamples(self, N):
"""
return N sampes as if from "Raw"
"""
raise "Not implemented"
import sys
sys.path.append("../")
sys.path.append("../../jtag")
import time
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import jtag
if sys.argv[1] == "jtag":
eio = jtag.JTAGEventIO()
src = eaddr.JTAG
else:
eio = NetEventIO("10.0.0.2")
src = eaddr.NETWORK
eio.addRXMask(xrange(256), eaddr.SYSCONTROL)
eio.start()
e = Event()
e.src = src
e.cmd = 0x20
ea = eaddr.TXDest()
ea[eaddr.SYSCONTROL] = 1
eio.sendEvent(ea, e)
erx = eio.getEvents()
"""
Try and flash the DSPboard FPGA EVENT leds
"""
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
eio = NetEventIO("10.0.0.2")
eio.start()
CMD = 0x31
# Create event and set mask
N = 8
def getiset(j):
return [q for q in range(j * 4 + 8, j * 4 + 12)]
def setLED(addrs, stateon):
e = Event()
e.src = eaddr.NETWORK
e.cmd = CMD
if stateon:
e.data[0] = 0xFFFF
else:
"""
Try and PING the DSPboard
"""
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
eio = NetEventIO("10.0.0.2")
DSPBOARDADDR = 0x08
#eio.addRXMask(xrange(256), DSPBOARDADDR)
eio.addRXMask(xrange(256), 0xAB)
eio.start()
# Create event and set mask
## e = Event()
## e.src = eaddr.NETWORK
## e.cmd = 0x30
## e.data[0] = 0x1234
## e.data[1] = 0x5678
## ea = eaddr.TXDest()
## ea[DSPBOARDADDR] = 1
## eio.sendEvent(ea, e)
"""
Monitor and print all acqdatasource events
"""
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
eio = NetEventIO("10.0.0.2")
DSPBOARDADDR = int(sys.argv[1])
ACQDATASOURCE_CMDRESP = 0x42
eio.addRXMask(ACQDATASOURCE_CMDRESP, DSPBOARDADDR)
eio.start()
while True:
erx = eio.getEvents()
for q in erx:
print q
eio.stop()
"""
Try and flash the DSPboard LED
"""
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
eio = NetEventIO("10.0.0.2")
dspaddrs = set()
delay = float(sys.argv[1])
for who in sys.argv[2:]:
if '-' in who:
# this is a range
(startstr, endstr) = who.split("-")
for r in range(int(startstr), int(endstr) + 1):
dspaddrs.add(r)
else:
dspaddrs.add(int(who))
if len(dspaddrs) == 0:
raise Exception("Must specify at least one dsp board target")
eio.start()
CMD = 0xF2
# Create event and set mask
while (1):
"""
Try and flash the DSPboard LED
"""
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
eio = NetEventIO("10.0.0.2")
dspaddrs = set()
delay = float(sys.argv[1])
for who in sys.argv[2:]:
if '-' in who:
# this is a range
(startstr, endstr) = who.split("-")
for r in range(int(startstr), int(endstr)+1):
dspaddrs.add(r)
else:
dspaddrs.add(int(who))
if len(dspaddrs) == 0:
raise Exception("Must specify at least one dsp board target")
eio.start()
CMD = 0xF2
# Create event and set mask
import sys from somapynet.event import Event from somapynet import eaddr from somapynet.neteventio import NetEventIO import struct import time somaip = sys.argv[1] eio = NetEventIO(somaip) DSPBOARDADDR = int(sys.argv[2]) eio.addRXMask(xrange(256), DSPBOARDADDR) eio.start() # Create event and set mask e = Event() e.src = eaddr.NETWORK e.cmd = 0x40 # query link status status e.data[0] = 0 # param 0 , link status e.data[1] = 0 ea = eaddr.TXDest() ea[DSPBOARDADDR] = 1 eio.sendEvent(ea, e)
"""
Uses the EchoProc on the DSP to measure our current RAM use
"""
import sys
from somapynet.event import Event
from somapynet import eaddr
from somapynet.neteventio import NetEventIO
import struct
import time
eio = NetEventIO("10.0.0.2")
DSPBOARDADDR = int(sys.argv[1])
ECMD_ECHOPROC_MEMCHECK = 0xF8
ECMD_ECHOPROC_MEMCHECK_RESP = 0xF9
eio.addRXMask(ECMD_ECHOPROC_MEMCHECK_RESP, xrange(256))
eio.start()
# Create event and set mask
e = Event()
e.src = eaddr.NETWORK
e.cmd = ECMD_ECHOPROC_MEMCHECK
ea = eaddr.TXDest()
ea[DSPBOARDADDR] = 1
eio.sendEvent(ea, e)
def __init__(self, IP="10.0.0.2", set = 'A'):
self.eio = NetEventIO(IP)
self.set = set
def manual_boot_device(filename, devicenums, youares):
"""
Devicenums are the device link nums. Note that they do not
map directly onto the configuration bit lines
"""
eio = NetEventIO("10.0.0.2")
eio.addRXMask(xrange(256), eaddr.SYSCONTROL)
eio.start()
MANBOOTSER_SETMASK = 0xA0
MANBOOTSER_TOGPROG = 0xA1
MANBOOTSER_WRITEBYTES = 0xA2
MANBOOTSER_SENDBYTES = 0xA3
EVENTCMD_YOUARE = 0x01
EVENTCMD_LINKSTATUS = 0x20
e = Event()
e.src = eaddr.NETWORK
e.cmd = MANBOOTSER_SETMASK
wrd = 0
#int_devicenums = [int(x) for x in devicenums]
for d in devicenums: # [device_to_config_mapping[x] for x in int_devicenums]:
cfg_line = device_to_config_bits[d]
wrd |= (1 << cfg_line)
#print "word = %8.8X" % wrd
# FIXME:
e.data[0] = wrd >> 16
e.data[1] = wrd & 0xFFFF
ea = eaddr.TXDest()
ea[eaddr.SYSCONTROL] = 1
eio.sendEvent(ea, e)
# toggle FPROG
e.cmd = MANBOOTSER_TOGPROG
eio.sendEvent(ea, e)
# send the actual data
fid = file(filename)
fid.seek(72)
data = fid.read(8)
pos = 0
ecnt = 0
while data:
e.cmd = MANBOOTSER_WRITEBYTES
e.src = eaddr.NETWORK
ea = eaddr.TXDest()
ea[eaddr.SYSCONTROL] = 1
if len(data) < 8:
#print "The end"
data = data + " "
for i in xrange(4):
e.data[i] = struct.unpack(">H", data[(i*2):(i*2+2)])[0]
reallysend(eio, ea, e)
# now push the bytes to the client device
e.cmd = MANBOOTSER_SENDBYTES
e.src = eaddr.NETWORK
ea = eaddr.TXDest()
ea[eaddr.SYSCONTROL] = 1
reallysend(eio, ea, e)
erx = eio.getEvents()
data =fid.read(8)
pos += 8
ecnt += 1
# loop and query the linkstatus register to see if our links
# are up yet, and once they are, go.
up_delay = False
allup = False
for i in range(20):
e = Event()
e.cmd = EVENTCMD_LINKSTATUS
e.src = eaddr.NETWORK
ea = eaddr.TXDest()
ea[eaddr.SYSCONTROL] = 1
reallysend(eio, ea, e)
erx = eio.getEvents(False)
device_status_event = None
if erx != None:
for e in erx:
if e.cmd == EVENTCMD_LINKSTATUS:
device_status_event = e
if device_status_event:
stat = parse_linkstatus(device_status_event)
allup = True
for i in devicenums:
if not stat[i]:
allup = False
if allup:
break
up_delay += 1
time.sleep(1)
if not allup:
print "Was unable to bring up the requested links"
sys.exit(1)
else:
print "links up after", up_delay, "secs"
#now send the YOUARE so the device knows who it is
for deviceid in youares:
e = Event()
e.cmd = EVENTCMD_YOUARE
e.src = eaddr.NETWORK
e.data[0] = deviceid
ea = eaddr.TXDest()
ea[deviceid] = 1
print "Sending youare for ", deviceid, e
reallysend(eio, ea, e)
eio.stop()
