public static void ReadI2CWorker(object data)
{
WiiReaderV1 reader = ((WiiReaderV1)data);
while (!reader.inShutdown)
{
I2CPacket packet = reader.packetPool[reader.currentPacketInPool];
reader.currentPacketInPool += 1;
reader.currentPacketInPool %= 100;
uint status = 0;
ulong timeSop = 0;
ulong timeDuration = 0;
uint timeDataOffset = 0;
packet.Length = BeagleApi.bg_i2c_read(
((WiiReaderV1)data).hBeagle, ref status, ref timeSop,
ref timeDuration, ref timeDataOffset, 1024, packet.Data);
if (packet.Length >= 1)
{
reader.packetsToBeProcessed.Enqueue(packet);
}
}
}
public static void ReadUSBWorker(object data)
{
XboxReader reader = ((XboxReader)data);
while (!reader.inShutdown)
{
USBPacket packet = reader.packetPool[reader.currentPacketInPool];
reader.currentPacketInPool += 1;
reader.currentPacketInPool %= 100;
uint status = 0;
uint events = 0;
ulong timeSop = 0;
ulong timeDuration = 0;
uint timeDataOffset = 0;
packet.Length = BeagleApi.bg_usb2_read(
((XboxReader)data).hBeagle, ref status, ref events, ref timeSop,
ref timeDuration, ref timeDataOffset, 1024, packet.Packet);
if (packet.Length == 23 &&
(packet.Packet[0] == BeagleApi.BG_USB_PID_DATA1 || packet.Packet[0] == BeagleApi.BG_USB_PID_DATA0) &&
packet.Packet[1] == 0x00 &&
packet.Packet[2] == 0x14)
{
reader.packetsToBeProcessed.Enqueue(packet);
}
}
}
/*=====================================================================
| GENERIC DETECTION ROUTINE
| ====================================================================*/
static void find_devices()
{
ushort[] ports = new ushort[16];
uint[] unique_ids = new uint[16];
int nelem = 16;
// Find all the attached devices
int count = BeagleApi.bg_find_devices_ext(nelem, ports,
nelem, unique_ids);
int i;
Console.Write("{0:d} device(s) found:\n", count);
// Print the information on each device
if (count > nelem)
{
count = nelem;
}
for (i = 0; i < count; ++i)
{
// Determine if the device is in-use
String status = "(avail) ";
if ((ports[i] & BeagleApi.BG_PORT_NOT_FREE) != 0)
{
ports[i] &= unchecked ((ushort)~BeagleApi.BG_PORT_NOT_FREE);
status = "(in-use)";
}
// Display device port number, in-use status, and serial number
Console.Write(" port={0,-3:d} {1:s} ({2:d4}-{3:d6})\n",
ports[i], status,
unique_ids[i] / 1000000,
unique_ids[i] % 1000000);
}
}
/*=====================================================================
| BUFFER CONFIGURATION
| ====================================================================*/
static void usbConfigBuffer()
{
uint pretrig_kb = 0;
uint capture_kb = 0;
// Configure Beagle 5000 for capturing USB 3.0, and waiting for a
// trigger event.
if (BeagleApi.bg_usb5000_configure(
beagle,
BeagleApi.BG_USB5000_CAPTURE_USB3,
BeagleUsb5000TriggerMode.BG_USB5000_TRIGGER_MODE_EVENT) !=
(int)BeagleStatus.BG_OK)
{
Console.Write(
"error: could not configure Beagle 5000 with desired mode\n");
Environment.Exit(1);
}
// Configure the onboard USB 3.0 buffer for 1MB of pretrigger and
// 3MB of posttrigger.
if (BeagleApi.bg_usb5000_usb3_capture_config(beagle, 1024, 4096) < 0)
{
Console.Write("error: configuring capture buffer failed!\n");
Environment.Exit(1);
}
BeagleApi.bg_usb5000_usb3_capture_config_query(beagle,
ref pretrig_kb,
ref capture_kb);
Console.Write("Configured capture buffer: " +
"pretrig = {0:d}KB total capture = {1:d}KB\n\n",
pretrig_kb, capture_kb);
}
private void open_handle()
{
handle = BeagleApi.bg_open(port);
if (handle <= 0)
{
Console.WriteLine("Unable to open Beagle device on port {0}", port);
Console.WriteLine("error: {0}", BeagleApi.bg_status_string(handle));
}
}
public WiiReaderV1(int controllerId)
{
if (!Environment.Is64BitProcess)
{
throw new IOException("WiiReaderV1 is only support in 64 bit RetroSpy!");
}
wm_rand = new byte[10];
wm_key = new byte[6];
wm_ft = new byte[8];
wm_sb = new byte[8];
// Setup the Beagle
hBeagle = BeagleApi.bg_open(controllerId);
if (hBeagle <= 0)
{
throw new IOException(String.Format("WiiReaderV1 could not find Beagle USB Protocol Analyzer on port {0}.", controllerId));
}
isOpened = true;
int samplerate = 10000;
samplerate = BeagleApi.bg_samplerate(hBeagle, samplerate);
if (samplerate < 0)
{
Finish();
throw new IOException(String.Format("WiiReaderV1 error: {0:s}\n", BeagleApi.bg_status_string(samplerate)));
}
BeagleApi.bg_timeout(hBeagle, milliseconds: 500);
BeagleApi.bg_latency(hBeagle, milliseconds: 0);
BeagleApi.bg_target_power(hBeagle, BeagleApi.BG_TARGET_POWER_OFF);
BeagleApi.bg_i2c_pullup(hBeagle, BeagleApi.BG_I2C_PULLUP_OFF);
if (BeagleApi.bg_enable(hBeagle, BeagleProtocol.BG_PROTOCOL_I2C) != (int)BeagleStatus.BG_OK)
{
Finish();
throw new IOException("WiiReaderV1 error: could not enable I2C capture\n");
}
isEnabled = true;
packetPool = new I2CPacket[1024];
for (int i = 0; i < 100; ++i)
{
packetPool[i] = new I2CPacket();
}
Thread usbParsingThread = new Thread(ProcessPacketWorker);
Thread usbReadingThread = new Thread(ReadI2CWorker);
usbParsingThread.Start(this);
usbReadingThread.Start(this);
}
public XboxReader(int controllerId)
{
if (!Environment.Is64BitProcess)
{
throw new IOException("XboxReader is only support in 64 bit RetroSpy!");
}
// Setup the Beagle
hBeagle = BeagleApi.bg_open(controllerId);
if (hBeagle <= 0)
{
throw new IOException(String.Format("XboxReader could not find Beagle USB Protocol Analyzer on port {0}.", controllerId));
}
isOpened = true;
int samplerate = 0;
samplerate = BeagleApi.bg_samplerate(hBeagle, samplerate);
if (samplerate < 0)
{
Finish();
throw new IOException(String.Format("XboxReader error: {0:s}\n", BeagleApi.bg_status_string(samplerate)));
}
BeagleApi.bg_timeout(hBeagle, milliseconds: 500);
BeagleApi.bg_latency(hBeagle, milliseconds: 0);
BeagleApi.bg_target_power(hBeagle, BeagleApi.BG_TARGET_POWER_OFF);
if (BeagleApi.bg_enable(hBeagle, BeagleProtocol.BG_PROTOCOL_USB) != (int)BeagleStatus.BG_OK)
{
Finish();
throw new IOException("XboxReader error: could not enable USB capture\n");
}
isEnabled = true;
packetPool = new USBPacket[100];
for (int i = 0; i < 100; ++i)
{
packetPool[i] = new USBPacket();
}
Thread usbParsingThread = new Thread(ProcessPacketWorker);
Thread usbReadingThread = new Thread(ReadUSBWorker);
usbParsingThread.Start(this);
usbReadingThread.Start(this);
}
public void Finish()
{
inShutdown = true;
Thread.Sleep(1000);
if (isEnabled)
{
BeagleApi.bg_disable(hBeagle);
}
if (isOpened)
{
BeagleApi.bg_close(hBeagle);
}
}
public static List <uint> GetDevices()
{
var result = new List <uint>();
ushort[] ports = new ushort[16];
uint[] unique_ids = new uint[16];
int nelem = 16;
if (Environment.Is64BitProcess)
{
int count = BeagleApi.bg_find_devices_ext(nelem, ports, nelem, unique_ids);
for (uint i = 0; i < count; i++)
{
result.Add(ports[i]);
}
}
return(result);
}
private void setup_i2c() //set timing bit size, sample rate, and timeout
{
// Get the size of the timing information for a transaction of
// max_bytes length
timing_size = BeagleApi.bg_bit_timing_size(BeagleProtocol.BG_PROTOCOL_I2C, max_bytes);
timing = new uint[timing_size];
sample_rate = BeagleApi.bg_samplerate(handle, 200); //sampling rate in khz
if (BeagleApi.bg_timeout(handle, 500) != (int)BeagleStatus.BG_OK) //set the timeout to 1s
{
Console.WriteLine("error: Could not set Beagle timeout; exiting...\n");
//throw new InvalidOperationException("Could not set Beagle timeout; exiting...");
}
if (BeagleApi.bg_enable(handle, BeagleProtocol.BG_PROTOCOL_I2C) != (int)BeagleStatus.BG_OK) //start polling bus
{
Console.WriteLine("error: could not enable I2C capture; exiting...\n");
//throw new InvalidOperationException("error: could not enable I2C capture; exiting...");
}
}
/*=========================================================================
| DIGITAL INPIT/OUTPUT CONFIG
| ========================================================================*/
static void setupDigitalLines()
{
// Digital input mask
byte input_enable_mask =
BeagleApi.BG_USB2_DIGITAL_IN_ENABLE_PIN1 |
BeagleApi.BG_USB2_DIGITAL_IN_ENABLE_PIN2 |
BeagleApi.BG_USB2_DIGITAL_IN_ENABLE_PIN3 |
BeagleApi.BG_USB2_DIGITAL_IN_ENABLE_PIN4;
// Define the packet and data match structures. By using 'new'
// to define these structures, their value type elements are
// initialized to 0 and the reference type elements (including
// the arrays) are set to null.
BeagleApi.BeagleUsb2PacketMatch packet_match =
new BeagleApi.BeagleUsb2PacketMatch();
BeagleApi.BeagleUsb2DataMatch data_match =
new BeagleApi.BeagleUsb2DataMatch();
// Enable digital input pins
BeagleApi.bg_usb480_digital_in_config(beagle, input_enable_mask);
Console.Write("Configuring digital input with {0:x}\n",
input_enable_mask);
// Configure digital out pins. Only those fields that we want
// enabled need to be set here since everything was initialized
// above.
packet_match.pid_match_type =
BeagleUsb2MatchType.BG_USB2_MATCH_TYPE_EQUAL;
packet_match.pid_match_val = BeagleApi.BG_USB_PID_PING;
// Enable digital output pin 4
BeagleApi.bg_usb480_digital_out_config(beagle,
BeagleApi.BG_USB2_DIGITAL_OUT_ENABLE_PIN4,
BeagleApi.BG_USB2_DIGITAL_OUT_PIN4_ACTIVE_HIGH);
// Configure digital output pin 4 match pattern
BeagleApi.bg_usb480_digital_out_match(beagle,
BeagleUsb2DigitalOutMatchPins.BG_USB2_DIGITAL_OUT_MATCH_PIN4,
packet_match, data_match);
Console.Write("Configuring digital output pin 4.\n");
}
string print_general_status(uint status)
{
string status_string = " ";
Console.Write(" ");
// General status codes
if (status == BeagleApi.BG_READ_OK)
{
status_string += ("OK");
}
if (status != 0)
{
buffer_available = BeagleApi.bg_host_buffer_used(handle);
status_string += "(" + buffer_available + ":" + BeagleApi.bg_host_buffer_size(handle, 0) + ")";
}
if ((status & BeagleApi.BG_READ_TIMEOUT) != 0)
{
status_string += ("TIMEOUT ");
}
if ((status & BeagleApi.BG_READ_ERR_MIDDLE_OF_PACKET) != 0)
{
status_string += ("MIDDLE ");
}
if ((status & BeagleApi.BG_READ_ERR_SHORT_BUFFER) != 0)
{
status_string += ("SHORT BUFFER ");
}
if ((status & BeagleApi.BG_READ_ERR_PARTIAL_LAST_BYTE) != 0)
{
status_string += string.Format("PARTIAL_BYTE(bit {0:d}) ", status & 0xff);
}
return(status_string);
}
public void find_device()
{
int device_num = 8;
var ports = Enumerable.Repeat <ushort>(9999, device_num).ToArray();
var ids = new uint[device_num];
try
{
int aa_num = AardvarkApi.aa_find_devices_ext(device_num, ports, device_num, ids);
if (aa_num > 0)
{
for (int i = 0; i < device_num; i++)
{
if (ports[i] != 9999 && !check_aardvark(ids[i])) //check if not there already
{
aardvarks.Add(new Aardvark(ports[i], ids[i]));
}
}
}
int bg_num = BeagleApi.bg_find_devices_ext(device_num, ports, device_num, ids);
if (bg_num > 0)
{
for (int i = 0; i < device_num; i++)
{
if (ports[i] != 9999 && !check_beagle(ids[i]))
{
beagles.Add(new Beagle(ports[i], ids[i]));
}
}
}
}
catch (System.TypeInitializationException)
{
MessageBox.Show("Application must target 64 bit");
}
}
static void usbDump(int numPackets, byte capMask)
{
// Setup variables
byte[] packet = new byte[1036];
byte[] packetKBits = new byte[130];
int packetnum = 0;
BeagleUsb5000CaptureStatus captureStatus =
BeagleUsb5000CaptureStatus.BG_USB5000_CAPTURE_STATUS_INACTIVE;
uint pretrigAmt = 0;
uint pretrigTotal = 0;
uint capAmt = 0;
uint capTotal = 0;
int ret = 0;
#if STATS_MODE
// Statistic mode variables
ulong dispTimeSop = 0;
ulong sstxByteCount = 0;
ulong ssrxByteCount = 0;
ulong sstxPacketCount = 0;
ulong ssrxPacketCount = 0;
ulong usb2ByteCount = 0;
ulong usb2PacketCount = 0;
#endif
// Configure Beagle 480 for realtime capture
if (BeagleApi.bg_usb5000_configure(
beagle, capMask,
BeagleUsb5000TriggerMode.BG_USB5000_TRIGGER_MODE_IMMEDIATE) !=
(int)BeagleStatus.BG_OK)
{
Console.Write(
"error: could not configure Beagle 5000 with desired mode\n");
Environment.Exit(1);
}
// Start the capture
if (BeagleApi.bg_enable(beagle, BeagleProtocol.BG_PROTOCOL_USB) !=
(int)BeagleStatus.BG_OK)
{
Console.Write("error: could not enable USB capture; exiting...\n");
Environment.Exit(1);
}
// Wait for the analyzer to trigger for up to 2 seconds...
if ((capMask & BeagleApi.BG_USB5000_CAPTURE_USB2) != 0)
{
ret = BeagleApi.bg_usb5000_usb2_capture_status(
beagle, 2000, ref captureStatus,
ref pretrigAmt, ref pretrigTotal,
ref capAmt, ref capTotal);
}
else
{
ret = BeagleApi.bg_usb5000_usb3_capture_status(
beagle, 2000, ref captureStatus,
ref pretrigAmt, ref pretrigTotal,
ref capAmt, ref capTotal);
}
if (ret != (int)BeagleStatus.BG_OK)
{
Console.Write(
"error: could not query capture status; exiting...\n");
Environment.Exit(1);
}
if (captureStatus <= BeagleUsb5000CaptureStatus.
BG_USB5000_CAPTURE_STATUS_PRE_TRIGGER)
{
Console.Write("did not trigger.\n");
Environment.Exit(1);
}
// Output the header...
#if STATS_MODE
Console.Write(
" SSTX PACKETS ( MB/s ) SSRX PACKETS ( MB/s ) USB2 PACKETS ( MB/s )\n");
#else
Console.Write(
"index,time(ns),source,event,status,data0 ... dataN(*)\n");
#endif
Console.Out.Flush();
// ...then start decoding packets
while (packetnum < numPackets || (numPackets == 0))
{
uint status = 0;
uint events = 0;
ulong timeSop = 0;
ulong timeDuration = 0;
uint timeDataOffset = 0;
BeagleUsb5000Source source =
BeagleUsb5000Source.BG_USB5000_SOURCE_ASYNC;
int length = BeagleApi.bg_usb5000_read(
beagle,
ref status, ref events, ref timeSop, ref timeDuration,
ref timeDataOffset, ref source,
1036, packet, 130, packetKBits);
// Make sure capture is triggered.
if (length == (int)BeagleStatus.BG_CAPTURE_NOT_TRIGGERED)
{
continue;
}
// Check for invalid packet or Beagle error
if (length < 0)
{
Console.Write("error={0:d}\n", length);
break;
}
// Exit if observed end of capture
if (status == BeagleApi.BG_READ_USB_END_OF_CAPTURE)
{
Console.Write("\n");
Console.Write("End of capture\n");
break;
}
#if STATS_MODE
// Count the number of packets and bytes
if (length > 0)
{
switch (source)
{
case BeagleUsb5000Source.BG_USB5000_SOURCE_USB2:
usb2PacketCount++;
usb2ByteCount += (ulong)length;
break;
case BeagleUsb5000Source.BG_USB5000_SOURCE_TX:
sstxPacketCount++;
sstxByteCount += (ulong)length;
break;
case BeagleUsb5000Source.BG_USB5000_SOURCE_RX:
ssrxPacketCount++;
ssrxByteCount += (ulong)length;
break;
default:
break;
}
}
// Periodically print out the stats
if ((timeSop - dispTimeSop) > DISPLAY_TIME_TICKS)
{
double timeS = (double)timestampToNS(timeSop - dispTimeSop,
samplerateKHz) / 1E9;
double sstxMBps =
((double)sstxByteCount) / (1024 * 1024L) / timeS;
double ssrxMBps =
((double)ssrxByteCount) / (1024 * 1024L) / timeS;
double usb2MBps =
((double)usb2ByteCount) / (1024 * 1024L) / timeS;
Console.Write("\r{0,15:d} ({1,6:##0.00})" +
" {2,15:d} ({3,6:##0.00})" +
" {4,15:d} ({5,6:##0.00})",
sstxPacketCount, sstxMBps,
ssrxPacketCount, ssrxMBps,
usb2PacketCount, usb2MBps);
sstxByteCount = 0;
ssrxByteCount = 0;
usb2ByteCount = 0;
dispTimeSop = timeSop;
}
#else
// Grab the next packet on a timeout.
if (length == 0 &&
status == BeagleApi.BG_READ_TIMEOUT &&
events == 0)
{
continue;
}
// Print the packet details
Console.Write("{0},", packetnum);
Console.Write("{0},", timestampToNS(timeSop, samplerateKHz));
printSource(source);
Console.Write(",");
printEvents(source, events);
Console.Write(",");
printStatus(source, status);
Console.Write(",");
printPacket(source, packet, packetKBits, length);
Console.Write("\n");
#endif
packetnum++;
}
// Stop the capture
BeagleApi.bg_disable(beagle);
}
/*=====================================================================
| MAIN PROGRAM
| ====================================================================*/
public static void Main(String[] args)
{
int port = 0; // open port 0 by default
int samplerate = 10000; // in kHz
uint timeout = 500; // in milliseconds
uint latency = 200; // in milliseconds
int len = 0;
int num = 0;
if (args.Length < 2)
{
print_usage();
Environment.Exit(1);
}
len = Convert.ToInt32(args[0]);
num = Convert.ToInt32(args[1]);
// Open the device
beagle = BeagleApi.bg_open(port);
if (beagle <= 0)
{
Console.Write("Unable to open Beagle device on port {0:d}\n",
port);
Console.Write("Error code = {0:d}\n", beagle);
Environment.Exit(1);
}
Console.Write("Opened Beagle device on port {0:d}\n", port);
// Set the samplerate
samplerate = BeagleApi.bg_samplerate(beagle, samplerate);
if (samplerate < 0)
{
Console.Write("error: {0:s}\n",
BeagleApi.bg_status_string(samplerate));
Environment.Exit(1);
}
Console.Write("Sampling rate set to {0:d} KHz.\n", samplerate);
// Set the idle timeout.
// The Beagle read functions will return in the specified time
// if there is no data available on the bus.
BeagleApi.bg_timeout(beagle, timeout);
Console.Write("Idle timeout set to {0:d} ms.\n", timeout);
// Set the latency.
// The latency parameter allows the programmer to balance the
// tradeoff between host side buffering and the latency to
// receive a packet when calling one of the Beagle read
// functions.
BeagleApi.bg_latency(beagle, latency);
Console.Write("Latency set to {0:d} ms.\n", latency);
Console.Write("Host interface is {0:s}.\n",
((BeagleApi.bg_host_ifce_speed(beagle)) != 0) ? "high speed" :
"full speed");
// Configure the device for SPI
BeagleApi.bg_spi_configure(
beagle,
BeagleSpiSSPolarity.BG_SPI_SS_ACTIVE_LOW,
BeagleSpiSckSamplingEdge.BG_SPI_SCK_SAMPLING_EDGE_RISING,
BeagleSpiBitorder.BG_SPI_BITORDER_MSB);
// There is usually no need for target power when using the
// Beagle as a passive monitor.
BeagleApi.bg_target_power(beagle, BeagleApi.BG_TARGET_POWER_OFF);
Console.Write("\n");
Console.Out.Flush();
spidump(len, num);
// Close the device
BeagleApi.bg_close(beagle);
return;
}
static void usbDump(int numPackets)
{
// Packets are saved during the collapsing process
PacketQueue pktQ = new PacketQueue();
// Info for the packet that was just read
PacketInfo curPacket;
// Collapsing counts and time collapsing started
CollapseInfo collapseInfo = new CollapseInfo();
CollapseState state = CollapseState.IDLE;
bool reRun = false;
byte pid = 0;
int signalErrors = 0;
int packetnum = 0;
samplerateKHz = BeagleApi.bg_samplerate(beagle, 0);
int idle_samples = IDLE_THRESHOLD * samplerateKHz;
// Configure Beagle 480 for realtime capture
BeagleApi.bg_usb480_capture_configure(beagle,
BeagleUsb480CaptureMode.BG_USB480_CAPTURE_REALTIME,
BeagleUsb2TargetSpeed.BG_USB2_AUTO_SPEED_DETECT);
// Filter packets intended for the Beagle analyzer. This is only
// relevant when one host controller is being used.
BeagleApi.bg_usb480_hw_filter_config(beagle,
BeagleApi.BG_USB2_HW_FILTER_SELF);
// Start the capture
if (BeagleApi.bg_enable(beagle, BeagleProtocol.BG_PROTOCOL_USB) !=
(int)BeagleStatus.BG_OK)
{
Console.Write("error: could not enable USB capture; exiting...\n");
Environment.Exit(1);
}
// Output the header...
Console.Write("index,time(ns),USB,status,pid,data0 ... dataN(*)\n");
Console.Out.Flush();
// ...then start decoding packets
while (packetnum < numPackets || (numPackets == 0))
{
curPacket = pktQ.getTail();
curPacket.length = BeagleApi.bg_usb480_read(
beagle,
ref curPacket.status,
ref curPacket.events,
ref curPacket.timeSop,
ref curPacket.timeDuration,
ref curPacket.timeDataOffset,
1024,
curPacket.data);
curPacket.timeSopNS =
timestampToNS(curPacket.timeSop, samplerateKHz);
// Exit if observed end of capture
if ((curPacket.status &
BeagleApi.BG_READ_USB_END_OF_CAPTURE) != 0)
{
usbPrintSummaryPacket(ref packetnum, collapseInfo,
ref signalErrors);
break;
}
// Check for invalid packet or Beagle error
if (curPacket.length < 0)
{
String errorStatus = "";
errorStatus += String.Format("error={0:d}", curPacket.length);
usbPrintPacket(packetnum, curPacket, errorStatus);
break;
}
// Check for USB error
if (curPacket.status == BeagleApi.BG_READ_USB_ERR_BAD_SIGNALS)
{
++signalErrors;
}
// Set the PID for collapsing state machine below. Treat
// KEEP_ALIVEs as packets.
if (curPacket.length > 0)
{
pid = curPacket.data[0];
}
else if ((curPacket.events &
BeagleApi.BG_EVENT_USB_KEEP_ALIVE) != 0 &&
(curPacket.status &
BeagleApi.BG_READ_USB_ERR_BAD_PID) == 0)
{
pid = (byte)PacketGroup.KEEP_ALIVE;
}
else
{
pid = 0;
}
// Collapse these packets approprietly:
// KEEP_ALIVE* SOF* (IN (ACK|NAK))* (PING NAK)*
// (SPLIT (OUT|SETUP) NYET)* (SPLIT IN (ACK|NYET|NACK))*
// If the time elapsed since collapsing began is greater than
// the threshold, output the counts and zero out the counters.
if (curPacket.timeSop - collapseInfo.timeSop >=
(ulong)idle_samples)
{
usbPrintSummaryPacket(ref packetnum, collapseInfo,
ref signalErrors);
}
while (true)
{
reRun = false;
switch (state)
{
// The initial state of the state machine. Collapse SOFs
// and KEEP_ALIVEs. Save IN, PING, or SPLIT packets and
// move to the next state for the next packet. Otherwise,
// print the collapsed packet counts and the current
// packet.
case CollapseState.IDLE:
switch (pid)
{
case (byte)PacketGroup.KEEP_ALIVE:
collapse(PacketGroup.KEEP_ALIVE, collapseInfo, pktQ);
break;
case BeagleApi.BG_USB_PID_SOF:
collapse(PacketGroup.SOF, collapseInfo, pktQ);
break;
case BeagleApi.BG_USB_PID_IN:
pktQ.savePacket();
state = CollapseState.IN;
break;
case BeagleApi.BG_USB_PID_PING:
pktQ.savePacket();
state = CollapseState.PING;
break;
case BeagleApi.BG_USB_PID_SPLIT:
pktQ.savePacket();
state = CollapseState.SPLIT;
break;
default:
usbPrintSummaryPacket(ref packetnum, collapseInfo,
ref signalErrors);
if (curPacket.length > 0 || curPacket.events != 0 ||
(curPacket.status != 0 &&
curPacket.status != BeagleApi.BG_READ_TIMEOUT))
{
usbPrintPacket(packetnum, curPacket, null);
packetnum++;
}
break;
}
break;
// Collapsing IN+ACK or IN+NAK. Otherwise, output any
// saved packets and rerun the collapsing state machine
// on the current packet.
case CollapseState.IN:
state = CollapseState.IDLE;
switch (pid)
{
case BeagleApi.BG_USB_PID_ACK:
collapse(PacketGroup.IN_ACK, collapseInfo, pktQ);
break;
case BeagleApi.BG_USB_PID_NAK:
collapse(PacketGroup.IN_NAK, collapseInfo, pktQ);
break;
default:
reRun = true;
break;
}
break;
// Collapsing PING+NAK
case CollapseState.PING:
state = CollapseState.IDLE;
switch (pid)
{
case BeagleApi.BG_USB_PID_NAK:
collapse(PacketGroup.PING_NAK, collapseInfo, pktQ);
break;
default:
reRun = true;
break;
}
break;
// Expecting an IN, OUT, or SETUP
case CollapseState.SPLIT:
switch (pid)
{
case BeagleApi.BG_USB_PID_IN:
pktQ.savePacket();
state = CollapseState.SPLIT_IN;
break;
case BeagleApi.BG_USB_PID_OUT:
pktQ.savePacket();
state = CollapseState.SPLIT_OUT;
break;
case BeagleApi.BG_USB_PID_SETUP:
pktQ.savePacket();
state = CollapseState.SPLIT_SETUP;
break;
default:
state = CollapseState.IDLE;
reRun = true;
break;
}
break;
// Collapsing SPLIT+IN+NYET, SPLIT+IN+NAK, SPLIT+IN+ACK
case CollapseState.SPLIT_IN:
state = CollapseState.IDLE;
switch (pid)
{
case BeagleApi.BG_USB_PID_NYET:
collapse(PacketGroup.SPLIT_IN_NYET, collapseInfo,
pktQ);
break;
case BeagleApi.BG_USB_PID_NAK:
collapse(PacketGroup.SPLIT_IN_NAK, collapseInfo,
pktQ);
break;
case BeagleApi.BG_USB_PID_ACK:
collapse(PacketGroup.SPLIT_IN_ACK, collapseInfo,
pktQ);
break;
default:
reRun = true;
break;
}
break;
// Collapsing SPLIT+OUT+NYET
case CollapseState.SPLIT_OUT:
state = CollapseState.IDLE;
switch (pid)
{
case BeagleApi.BG_USB_PID_NYET:
collapse(PacketGroup.SPLIT_OUT_NYET, collapseInfo,
pktQ);
break;
default:
reRun = true;
break;
}
break;
// Collapsing SPLIT+SETUP+NYET
case CollapseState.SPLIT_SETUP:
state = CollapseState.IDLE;
switch (pid)
{
case BeagleApi.BG_USB_PID_NYET:
collapse(PacketGroup.SPLIT_SETUP_NYET, collapseInfo,
pktQ);
break;
default:
reRun = true;
break;
}
break;
}
if (reRun == false)
{
break;
}
// The state machine is about to be re-run. This
// means that a complete packet sequence wasn't collapsed
// and there are packets in the queue that need to be
// output before we can process the current packet.
outputSaved(ref packetnum, ref signalErrors,
collapseInfo, pktQ);
}
}
// Stop the capture
BeagleApi.bg_disable(beagle);
}
public static void spidump(int max_bytes, int num_packets)
{
// Get the size of timing information for each transaction of size
// max_bytes
int timing_size = BeagleApi.bg_bit_timing_size(
BeagleProtocol.BG_PROTOCOL_SPI, max_bytes);
byte[] data_mosi = new byte[max_bytes];
byte[] data_miso = new byte[max_bytes];
uint[] timing = new uint[timing_size];
// Get the current sampling rate
int samplerate_khz = BeagleApi.bg_samplerate(beagle, 0);
int i;
// Start the capture
if (BeagleApi.bg_enable(beagle, BeagleProtocol.BG_PROTOCOL_SPI) !=
(int)BeagleStatus.BG_OK)
{
Console.Write("error: could not enable SPI capture; exiting...\n");
Environment.Exit(1);
}
Console.Write("index,time(ns),SPI,status,mosi0/miso0 ... " +
"mosiN/misoN\n");
Console.Out.Flush();
// Capture and print information for each transaction
for (i = 0; i < num_packets || num_packets == 0; ++i)
{
uint status = 0;
ulong time_sop = 0;
ulong time_sop_ns = 0;
ulong time_duration = 0;
uint time_dataoffset = 0;
int n = 0;
// Read transaction with bit timing data
int count = BeagleApi.bg_spi_read_bit_timing(beagle, ref status,
ref time_sop, ref time_duration,
ref time_dataoffset,
max_bytes, data_mosi,
max_bytes, data_miso,
timing_size, timing);
// Translate timestamp to ns
time_sop_ns = TIMESTAMP_TO_NS(time_sop, samplerate_khz);
Console.Write("{0:d},{1:d},SPI,(", i, time_sop_ns);
if (count < 0)
{
Console.Write("error={0:d},", count);
}
print_general_status(status);
print_spi_status(status);
Console.Write(")");
// Check for errors
if (count <= 0)
{
Console.Write("\n");
Console.Out.Flush();
if (count < 0)
{
break;
}
// If zero data captured, continue
continue;
}
// Display the data
for (n = 0; n < count; ++n)
{
if (n != 0)
{
Console.Write(", ");
}
if ((n & 0xf) == 0)
{
Console.Write("\n ");
}
Console.Write("{0:x2}/{1:x2}", data_mosi[n], data_miso[n]);
}
Console.Write("\n");
Console.Out.Flush();
}
// Stop the capture
BeagleApi.bg_disable(beagle);
}
static void usbDump(int numPackets, int timeoutMS)
{
long start, elapsedTime;
// Set up variables
byte[] packet = new byte[1024];
int packetnum = 0;
samplerateKhz = BeagleApi.bg_samplerate(beagle, 0);
// Configure Beagle 480 for delayed-download capture
BeagleApi.bg_usb480_capture_configure(beagle,
BeagleUsb480CaptureMode.BG_USB480_CAPTURE_DELAYED_DOWNLOAD,
BeagleUsb2TargetSpeed.BG_USB2_AUTO_SPEED_DETECT);
// Enable the hardware filtering. This will filter out packets with
// the same device address as the Beagle analyzer and also filter
// the PID packet groups listed below.
BeagleApi.bg_usb480_hw_filter_config(beagle,
BeagleApi.BG_USB2_HW_FILTER_SELF |
BeagleApi.BG_USB2_HW_FILTER_PID_SOF |
BeagleApi.BG_USB2_HW_FILTER_PID_IN |
BeagleApi.BG_USB2_HW_FILTER_PID_PING |
BeagleApi.BG_USB2_HW_FILTER_PID_PRE |
BeagleApi.BG_USB2_HW_FILTER_PID_SPLIT);
// Start the capture portion of the delayed-download capture
if (BeagleApi.bg_enable(beagle, BeagleProtocol.BG_PROTOCOL_USB) !=
(int)BeagleStatus.BG_OK)
{
Console.Write("error: could not enable USB capture; exiting...\n");
Environment.Exit(1);
}
// Wait until timeout period elapses or the hardware buffer on
// the Beagle USB 480 fills
Console.Write("Hardware buffer usage:\n");
start = timeMicroseconds();
while (true)
{
uint bufferSize = 0;
uint bufferUsage = 0;
byte bufferFull = 0;
// Poll the hardware buffer status
BeagleApi.bg_usb480_hw_buffer_stats(beagle, ref bufferSize,
ref bufferUsage,
ref bufferFull);
// Print out the progress
elapsedTime = (timeMicroseconds() - start) / 1000;
printProgress(bufferUsage / (bufferSize / 100),
((double)elapsedTime) / 1000,
bufferUsage, bufferSize);
// If timed out or buffer is full, exit loop
if (bufferFull != 0 ||
(timeoutMS != 0 && elapsedTime > timeoutMS))
{
break;
}
// Sleep for 150 milliseconds
BeagleApi.bg_sleep_ms(150);
}
// Start the download portion of the delayed-download capture
//
// Output the header...
Console.Write("\nindex,time(ns),USB,status,pid,data0 ... dataN(*)\n");
Console.Out.Flush();
// ...then start decoding packets
while (packetnum < numPackets || (numPackets == 0))
{
uint status = 0;
uint events = 0;
ulong timeSop = 0;
ulong timeSopNS = 0;
ulong timeDuration = 0;
uint timeDataOffset = 0;
// Calling bg_usb480_read will automatically stop the
// capture portion of the delayed-download capture and
// will begin downloading the capture results.
int length = BeagleApi.bg_usb480_read(
beagle, ref status, ref events,
ref timeSop, ref timeDuration,
ref timeDataOffset, 1024, packet);
timeSopNS = TIMESTAMP_TO_NS(timeSop, samplerateKhz);
// Check for invalid packet or Beagle error
if (length < 0)
{
String errorStatus = "";
errorStatus += String.Format("error={0:d}", length);
usbPrintPacket(packetnum, timeSopNS, status, events,
errorStatus, null);
break;
}
// Output the current transaction
if (length > 0 || events != 0 ||
(status != 0 && status != BeagleApi.BG_READ_TIMEOUT))
{
String packetData = usbPrintDataPacket(ref packet,
length);
usbPrintPacket(packetnum, timeSopNS, status,
events, null, packetData);
++packetnum;
}
// Exit if observe end of capture
if ((status & BeagleApi.BG_READ_USB_END_OF_CAPTURE) != 0)
{
break;
}
}
// Stop the capture
BeagleApi.bg_disable(beagle);
}
public void reset_beagle()
{
BeagleApi.bg_disable(handle);
System.Threading.Thread.Sleep(250);
setup_i2c();
}
static void usbDump(int numPackets)
{
// Set up variables
byte[] packet = new byte[1024];
int timingSize =
BeagleApi.bg_bit_timing_size(BeagleProtocol.BG_PROTOCOL_USB, 1024);
uint[] timing = new uint[timingSize];
byte[] savedIn = new byte[64];
uint[] savedInTiming = new uint[8 * 64];
ulong savedInSop = 0;
int savedInLength = 0;
uint savedInStatus = 0;
uint savedInEvents = 0;
ulong countSop = 0;
int sofCount = 0;
int preCount = 0;
int inAckCount = 0;
int inNakCount = 0;
byte pid = 0;
int syncErrors = 0;
int packetnum = 0;
samplerateKhz = BeagleApi.bg_samplerate(beagle, 0);
int idleSamples = IDLE_THRESHOLD * samplerateKhz;
// Open the connection to the Beagle. Default to port 0.
if (BeagleApi.bg_enable(beagle, BeagleProtocol.BG_PROTOCOL_USB) !=
(int)BeagleStatus.BG_OK)
{
Console.Write("error: could not enable USB capture; exiting...\n");
Environment.Exit(1);
}
// Output the header...
Console.Write("index,time(ns),USB,status,pid,data0 ... dataN(*)\n");
Console.Out.Flush();
// ...then start decoding packets
while (packetnum < numPackets || (numPackets == 0))
{
uint status = 0;
uint events = 0;
ulong timeSop = 0;
ulong timeSopNS = 0;
ulong timeDuration = 0;
uint timeDataOffset = 0;
int length = BeagleApi.bg_usb12_read_bit_timing(
beagle, ref status, ref events, ref timeSop,
ref timeDuration, ref timeDataOffset,
1024, packet, timingSize, timing);
timeSopNS = TIMESTAMP_TO_NS(timeSop, samplerateKhz);
// Check for invalid packet or Beagle error
if (length < 0)
{
String errorStatus = "";
errorStatus += String.Format("error={0:d}", length);
usbPrintPacket(packetnum, timeSopNS, status, events,
errorStatus, null);
break;
}
// Check for USB error
if (status == BeagleApi.BG_READ_USB_ERR_BAD_SYNC)
{
++syncErrors;
}
if (length > 0)
{
pid = packet[0];
}
else
{
pid = 0;
}
// Check the PID and collapse appropriately:
// SOF* PRE* (IN (ACK|NAK))*
// If we have saved summary information, and we have
// hit an error, received a non-summary packet, or
// have exceeded the idle time, then dump out the
// summary information before continuing
if (status != BeagleApi.BG_READ_OK || usbTrigger(pid) ||
((int)(timeSop - countSop) >= idleSamples))
{
int offset =
usbPrintSummaryPacket(packetnum, countSop,
sofCount, preCount, inAckCount,
inNakCount, syncErrors);
sofCount = 0;
preCount = 0;
inAckCount = 0;
inNakCount = 0;
syncErrors = 0;
countSop = timeSop;
// Adjust the packet index if any events were printed by
// usbPrintSummaryPacket.
packetnum += offset;
}
// Now handle the current packet based on its packet ID
switch (pid)
{
case BeagleApi.BG_USB_PID_SOF:
// Increment the SOF counter
++sofCount;
break;
case BeagleApi.BG_USB_PID_PRE:
// Increment the PRE counter
++preCount;
break;
case BeagleApi.BG_USB_PID_IN:
// If the transaction is an IN, don't display it yet and
// save the transaction.
// If the following transaction is an ACK or NAK,
// increment the appropriate IN/ACK or IN/NAK counter.
// If the next transaction is not an ACK or NAK,
// display the saved IN transaction .
System.Array.Copy(packet, 0, savedIn, 0, length);
System.Array.Copy(timing, 0, savedInTiming, 0, length * 8);
savedInSop = timeSop;
savedInLength = length;
savedInStatus = status;
savedInEvents = events;
break;
case BeagleApi.BG_USB_PID_NAK:
goto case BeagleApi.BG_USB_PID_ACK;
case BeagleApi.BG_USB_PID_ACK:
// If the last transaction was IN, increment the appropriate
// counter and don't display the transaction.
if (savedInLength > 0)
{
savedInLength = 0;
if (pid == BeagleApi.BG_USB_PID_ACK)
{
++inAckCount;
}
else
{
++inNakCount;
}
break;
}
goto default;
default:
// If the last transaction was IN, output it
if (savedInLength > 0)
{
ulong saved_in_sop_ns =
TIMESTAMP_TO_NS(savedInSop, samplerateKhz);
String packetData = usbPrintDataPacket
(ref savedIn,
savedInLength);
usbPrintPacket(packetnum, saved_in_sop_ns, savedInStatus,
savedInEvents, null, packetData);
++packetnum;
savedInLength = 0;
}
// Output the current transaction
if (length > 0 || events != 0 ||
(status != 0 && status != BeagleApi.BG_READ_TIMEOUT))
{
String packetData = usbPrintDataPacket(ref packet,
length);
usbPrintPacket(packetnum, timeSopNS, status,
events, null, packetData);
++packetnum;
}
countSop = timeSop + timeDuration;
break;
}
}
// Stop the capture
BeagleApi.bg_disable(beagle);
}
public static void mdiodump(int num_packets)
{
// Get the size of the timing information for a transaction of
// max_bytes length
int timing_size =
BeagleApi.bg_bit_timing_size(BeagleProtocol.BG_PROTOCOL_MDIO, 0);
uint[] timing = new uint[timing_size];
// Get the current sampling rate
int samplerate_khz = BeagleApi.bg_samplerate(beagle, 0);
// Start the capture
if (BeagleApi.bg_enable(beagle, BeagleProtocol.BG_PROTOCOL_MDIO) !=
(int)BeagleStatus.BG_OK)
{
Console.Write("error: could not enable MDIO capture; " +
"exiting...\n");
Environment.Exit(1);
}
Console.Write("index,time(ns),MDIO,status,<clause:opcode>," +
"<addr1>,<addr2>,data\n");
Console.Out.Flush();
// Capture and print each transaction
int i;
for (i = 0; i < num_packets || num_packets == 0; ++i)
{
uint packet = 0;
uint status = 0;
ulong time_sop = 0, time_sop_ns = 0;
ulong time_duration = 0;
uint time_dataoffset = 0;
// Read transaction with bit timing data
int count = BeagleApi.bg_mdio_read_bit_timing(
beagle, ref status, ref time_sop,
ref time_duration, ref time_dataoffset,
ref packet, timing_size, timing);
// Translate timestamp to ns
time_sop_ns = TIMESTAMP_TO_NS(time_sop, samplerate_khz);
// Check for errors
if (count < 0)
{
Console.Write("{0,4:d},{1,13:d},MDIO,( error={2:d},",
i, time_sop_ns, count);
print_general_status(status);
print_mdio_status(status);
Console.Write(")\n");
Console.Out.Flush();
continue;
}
// Parse the MDIO frame
byte clause = 0;
byte opcode = 0;
byte addr1 = 0;
byte addr2 = 0;
ushort data = 0;
int ret = BeagleApi.bg_mdio_parse(packet, ref clause,
ref opcode, ref addr1, ref addr2, ref data);
Console.Write("{0:d},{1:d},MDIO,(", i, time_sop_ns);
print_general_status(status);
if ((status & BeagleApi.BG_READ_TIMEOUT) == 0)
{
print_mdio_status((uint)ret);
}
Console.Write(")");
// If zero data captured, continue
if (count == 0)
{
Console.Write("\n");
Console.Out.Flush();
continue;
}
// Print the clause and opcode
Console.Write(",");
if ((status & BeagleApi.BG_READ_ERR_MIDDLE_OF_PACKET) == 0)
{
if (clause == (byte)BeagleMdioClause.BG_MDIO_CLAUSE_22)
{
Console.Write("<22:");
switch (opcode)
{
case BeagleApi.BG_MDIO_OPCODE22_WRITE:
Console.Write("W");
break;
case BeagleApi.BG_MDIO_OPCODE22_READ:
Console.Write("R");
break;
case BeagleApi.BG_MDIO_OPCODE22_ERROR:
Console.Write("?");
break;
}
}
else if (clause == (byte)BeagleMdioClause.BG_MDIO_CLAUSE_45)
{
Console.Write("<45:");
switch (opcode)
{
case BeagleApi.BG_MDIO_OPCODE45_ADDR:
Console.Write("A");
break;
case BeagleApi.BG_MDIO_OPCODE45_WRITE:
Console.Write("W");
break;
case BeagleApi.BG_MDIO_OPCODE45_READ_POSTINC:
Console.Write("RI");
break;
case BeagleApi.BG_MDIO_OPCODE45_READ:
Console.Write("R");
break;
}
}
else
{
Console.Write("<?:?");
}
// Recall that for Clause 22:
// PHY Addr = addr1, Reg Addr = addr2
// and for Clause 45:
// Port Addr = addr1, Dev Addr = addr2
Console.Write(">,<{0:X2}>,<{1:X2}>,{2:X4}\n",
addr1, addr2, data);
}
Console.Out.Flush();
}
// Stop the capture
BeagleApi.bg_disable(beagle);
}
static void usbDump(int numPackets)
{
// Setup variables
byte[] packet = new byte[1036];
byte[] packetKBits = new byte[130];
int packetnum = 0;
int tries = 10;
BeagleUsb5000CaptureStatus captureStatus =
BeagleUsb5000CaptureStatus.BG_USB5000_CAPTURE_STATUS_INACTIVE;
uint pretrigAmt = 0;
uint pretrigTotal = 0;
uint capAmt = 0;
uint capTotal = 0;
// Disable VBUS to device
BeagleApi.bg_usb5000_target_power(
beagle, BeagleUsbTargetPower.BG_USB5000_TARGET_POWER_OFF);
// Start the capture
if (BeagleApi.bg_enable(beagle, BeagleProtocol.BG_PROTOCOL_USB) !=
(int)BeagleStatus.BG_OK)
{
Console.Write("error: could not enable USB capture; exiting...\n");
Environment.Exit(1);
}
// Disable VBUS to device
BeagleApi.bg_usb5000_target_power(
beagle, BeagleUsbTargetPower.BG_USB5000_TARGET_POWER_HOST_SUPPLIED);
// Wait for the analyzer to trigger for up to 10 seconds...
while (tries != 0)
{
if (BeagleApi.bg_usb5000_usb3_capture_status(
beagle, 1000, ref captureStatus,
ref pretrigAmt, ref pretrigTotal,
ref capAmt, ref capTotal) !=
(int)BeagleStatus.BG_OK)
{
Console.Write(
"error: could not query capture status; exiting...\n");
Environment.Exit(1);
}
if (captureStatus <= BeagleUsb5000CaptureStatus.
BG_USB5000_CAPTURE_STATUS_PRE_TRIGGER)
{
Console.Write("waiting for trigger...\n");
}
else
{
break;
}
tries--;
}
if (tries == 0)
{
Console.Write("did not trigger, make sure a host and a device " +
"is connected to the analyzer.\n");
Environment.Exit(1);
}
Console.Write(
"index,time(ns),source,event,status,data0 ... dataN(*)\n");
Console.Out.Flush();
// ...then start decoding packets
while (packetnum < numPackets || (numPackets == 0))
{
uint status = 0;
uint events = 0;
ulong timeSop = 0;
ulong timeDuration = 0;
uint timeDataOffset = 0;
BeagleUsb5000Source source =
BeagleUsb5000Source.BG_USB5000_SOURCE_ASYNC;
int length = BeagleApi.bg_usb5000_read(
beagle,
ref status, ref events, ref timeSop, ref timeDuration,
ref timeDataOffset, ref source,
1036, packet, 130, packetKBits);
// Make sure capture is triggered.
if (length == (int)BeagleStatus.BG_CAPTURE_NOT_TRIGGERED)
{
continue;
}
// Check for invalid packet or Beagle error
if (length < 0)
{
Console.Write("error={0:d}\n", length);
break;
}
// Exit if observed end of capture
if (status == BeagleApi.BG_READ_USB_END_OF_CAPTURE)
{
Console.Write("\n");
Console.Write("End of capture\n");
break;
}
// Grab the next packet on a timeout.
if (length == 0 &&
status == BeagleApi.BG_READ_TIMEOUT &&
events == 0)
{
continue;
}
// Print the packet details
Console.Write("{0},", packetnum);
Console.Write("{0},", timestampToNS(timeSop, samplerateKHz));
printSource(source);
Console.Write(",");
printEvents(source, events);
Console.Write(",");
printStatus(source, status);
Console.Write(",");
printPacket(source, packet, packetKBits, length);
Console.Write("\n");
packetnum++;
}
// Stop the capture
BeagleApi.bg_disable(beagle);
}
/*=====================================================================
| COMPLEX MATCH CONFIGURATION
| ====================================================================*/
static void usbConfigComplexMatch()
{
int features = BeagleApi.bg_usb5000_features(beagle);
if (features < 0)
{
Console.Write("error: could not retrieve features\n");
Environment.Exit(1);
}
bool adv = (features & BeagleApi.BG_USB5000_FEATURE_CMP_TRIG) != 0;
// Setup the first state.
// Do a capture trigger on seeing a SET ADDRESS setup packet.
// Match on a SET ADDRESS request. We also construct a data
// valid mask which masks out the device address from the
// request as that is variable.
byte[] setup_data = new byte[] { 0x00, 0x05, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00 };
byte[] setup_data_valid = new byte[] { 0xff, 0xff, 0x00, 0xff,
0xff, 0xff, 0xff, 0xff };
// Configure the data match properties. Since SET ADDRESS only comes
// on device 0 and ep 0, we can match only on those parameters.
BeagleApi.BeagleUsb5000DataProperties prop =
new BeagleApi.BeagleUsb5000DataProperties();
prop.source_match_type =
BeagleUsb5000MatchType.BG_USB5000_MATCH_TYPE_EQUAL;
prop.source_match_val =
BeagleUsb5000Source.BG_USB5000_SOURCE_TX;
prop.ep_match_type =
BeagleUsb5000MatchType.BG_USB5000_MATCH_TYPE_EQUAL;
prop.ep_match_val = 0;
prop.dev_match_type =
BeagleUsb5000MatchType.BG_USB5000_MATCH_TYPE_EQUAL;
prop.dev_match_val = 0;
prop.stream_id_match_type =
BeagleUsb5000MatchType.BG_USB5000_MATCH_TYPE_DISABLED;
prop.data_len_match_type =
BeagleUsb5000MatchType.BG_USB5000_MATCH_TYPE_EQUAL;
prop.data_len_match_val = 8;
// Setup the struct for the Data Match Unit
BeagleApi.BeagleUsb5000DataMatchUnit match0 =
new BeagleApi.BeagleUsb5000DataMatchUnit();
match0.packet_type =
BeagleUsb5000PacketType.BG_USB5000_MATCH_PACKET_SHP_SDP;
match0.match_other_packets = 0; // Only match a qualified SDP.
match0.data = setup_data;
match0.data_not = 0; // Match this data only.
match0.data_valid = setup_data_valid;
match0.err_match =
BeagleUsb5000ErrorType.BG_USB5000_MATCH_CRC_BOTH_VALID;
match0.data_properties_valid = 1;
match0.data_properties = prop;
match0.repeat_count = 0; // Match just once.
match0.sticky_action = 0; // Match just once.
match0.action_mask =
BeagleApi.BG_USB5000_COMPLEX_MATCH_ACTION_TRIGGER;
if (adv)
{
// Configure state0's data match to goto state1
// on it's match of the SET ADDRESS.
match0.goto_selector = 0; // Use the first goto selector.
match0.action_mask |= BeagleApi.BG_USB5000_COMPLEX_MATCH_ACTION_GOTO;
}
// Configure the State 0 struct.
BeagleApi.BeagleUsb5000ComplexMatchState state0 =
new BeagleApi.BeagleUsb5000ComplexMatchState();
state0.tx_data_0_valid = 1;
state0.tx_data_0 = match0;
state0.tx_data_1_valid = 0;
state0.tx_data_2_valid = 0;
state0.rx_data_0_valid = 0;
state0.rx_data_1_valid = 0;
state0.rx_data_2_valid = 0;
state0.timer_valid = 0;
state0.async_valid = 0;
// For units licensed for advanced complex trigger, go to state 1.
state0.goto_0 = 1;
// Setup state 2 to filter out all link layer packets on both streams.
BeagleApi.BeagleUsb5000DataMatchUnit match_slc =
new BeagleApi.BeagleUsb5000DataMatchUnit();
match_slc.packet_type =
BeagleUsb5000PacketType.BG_USB5000_MATCH_PACKET_SLC;
match_slc.match_other_packets = 0; // Only match a SLC packet.
match_slc.data = null; // Match all SLCs.
match_slc.data_not = 0;
match_slc.data_valid = null;
match_slc.err_match =
BeagleUsb5000ErrorType.BG_USB5000_MATCH_CRC_BOTH_VALID;
match_slc.data_properties_valid = 0;
match_slc.repeat_count = 0;
match_slc.sticky_action = 0;
match_slc.action_mask =
BeagleApi.BG_USB5000_COMPLEX_MATCH_ACTION_FILTER;
BeagleApi.BeagleUsb5000ComplexMatchState state1 =
new BeagleApi.BeagleUsb5000ComplexMatchState();
state1.tx_data_0_valid = 1;
state1.tx_data_0 = match_slc;
state1.tx_data_1_valid = 0;
state1.tx_data_2_valid = 0;
state1.rx_data_0_valid = 1;
state1.rx_data_0 = match_slc;
state1.rx_data_1_valid = 0;
state1.rx_data_2_valid = 0;
state1.timer_valid = 0;
state1.async_valid = 0;
int ret = 0;
if (adv)
{
// Passing null BeagleUsb5000ComplexMatchState objects
// into bg_usb5000_usb3_complex_match_config is not
// allowed so unconfigured match state objects are
// used instead.
BeagleApi.BeagleUsb5000ComplexMatchState empty = new
BeagleApi.BeagleUsb5000ComplexMatchState();
ret = BeagleApi.bg_usb5000_usb3_complex_match_config(
beagle,
0, // Validate and program it into the Beagle 5000.
0, // Not using extout.
state0, state1, empty, empty, empty, empty, empty, empty);
}
else
{
ret = BeagleApi.bg_usb5000_usb3_complex_match_config_single(
beagle,
0, // Validate and program it into the Beagle 5000.
0, // Not using extout.
state0);
}
if (ret != (int)BeagleStatus.BG_OK)
{
Console.Write("error: could not configure complex match\n");
Environment.Exit(1);
}
if (BeagleApi.bg_usb5000_usb3_complex_match_enable(beagle) !=
(int)BeagleStatus.BG_OK)
{
Console.Write("error: could not enable complex match\n");
Environment.Exit(1);
}
}
public List <string> snoop_i2c(int num_packets)
{
// Capture and print each transaction
List <ushort> full_data = new List <ushort>(); //keep adding bytes to this as it goes
List <string> lines = new List <string>();
for (int i = 0; i < num_packets || num_packets == 0; ++i)
{
uint status = 0;
ulong time_sop = 0, time_sop_ns = 0;
ulong time_duration = 0;
uint time_dataoffset = 0;
int count = 0;
// Read transaction with bit timing data
try
{
count = BeagleApi.bg_i2c_read(handle, ref status, ref time_sop, ref time_duration, ref time_dataoffset, max_bytes, data_in);
//count = BeagleApi.bg_i2c_read_bit_timing(handle, ref status, ref time_sop, ref time_duration, ref time_dataoffset, max_bytes, data_in, timing_size, timing);
}
catch
{
Console.WriteLine("Error in I2C bit read, skipping");
continue;
}
string output = "";// output_parse(data_in); //for building console output
string status_string = print_general_status(status);
try
{
buffer.AddRange(data_in); //add to my own buffer
}
catch (System.ArgumentOutOfRangeException)
{
Console.WriteLine("Skipping measurement..");
}
///lines.Add(status_string + " - " + output + " - " + "Iteration: " + i); //added this so see in gui
if (status_string.Contains("TIMEOUT"))
{
continue; //skip if no activity on bus
}
// Translate timestamp to ns
time_sop_ns = TIMESTAMP_TO_NS(time_sop, sample_rate);
///Console.Write("{0:d},{1:d}", i, time_sop_ns);
///Console.Write(",I2C,(");
if (count < 0) //error condition
{
Console.Write("error={0:d},", count);
}
///else
/// Console.Write("Read " + count + " bits. ");
//print_general_status(status); //below reference funct -> moved up
///Console.Write(status_string);
///print_i2c_status(status); //below reference funct
///Console.Write(")");
// Check for errors
if (count <= 0)
{
Console.Write("\n");
Console.Out.Flush(); //what does this do?
if (count < 0)
{
break;
}
// If zero data captured, continue
continue;
}
// Print the address and read/write
///Console.Write(",");
int offset = 0;
/*
* if ((status & BeagleApi.BG_READ_ERR_MIDDLE_OF_PACKET) == 0)
* {
* // Display the start condition
* Console.Write("[S] ");
*
* if (count >= 1)
* {
* // Determine if byte was NACKed
* int nack = (data_in[0] & BeagleApi.BG_I2C_MONITOR_NACK);
*
* // Determine if this is a 10-bit address
* if (count == 1 || (data_in[0] & 0xf9) != 0xf0 ||
* (nack != 0))
* {
* // Display 7-bit address
* Console.Write("<{0:x2}:{1:s}>{2:s} ",
* (data_in[0] & 0xff) >> 1,
* ((data_in[0] & 0x01) != 0) ? 'r' : 'w',
* (nack != 0) ? "*" : "");
* offset = 1;
* }
* else
* {
* // Display 10-bit address
* Console.Write("<{0:x3}:{1:s}>{2:s} ", ((data_in[0] << 7) & 0x300) | (data_in[1] & 0xff), ((data_in[0] & 0x01) != 0) ? 'r' : 'w',
* (nack != 0) ? "*" : "");
* offset = 2;
* }
* }
* }
*///take out prints
// Display rest of transaction - data
count = count - offset;
/*
* for (int n = 0; n < count; ++n)
* {
* // Determine if byte was NACKed
* int nack = (data_in[offset] & BeagleApi.BG_I2C_MONITOR_NACK);
*
* Console.Write("{0:x2}{1:s} ",
* data_in[offset] & 0xff, (nack != 0) ? "*" : "");
++offset;
* }
*/
}
// Stop the capture
//BeagleApi.bg_disable(handle);
return(lines);
}
/*=====================================================================
| MAIN PROGRAM
| ====================================================================*/
public static void Main(String[] args)
{
int port = 0; // open port 0 by default
uint timeout = 100; // in milliseconds
uint latency = 200; // in milliseconds
int num = 0;
if (args.Length < 1)
{
printUsage();
Environment.Exit(1);
}
num = Convert.ToInt32(args[0]);
// Open the device
beagle = BeagleApi.bg_open(port);
if (beagle <= 0)
{
Console.Write("Unable to open Beagle device on port {0:d}\n", port);
Console.Write("Error code = {0:d}\n", beagle);
Environment.Exit(1);
}
Console.Write("Opened Beagle device on port {0:d}\n", port);
// Query the samplerate since Beagle USB has a fixed sampling rate
samplerateKHz = BeagleApi.bg_samplerate(beagle, samplerateKHz);
if (samplerateKHz < 0)
{
Console.Write("error: {0:s}\n",
BeagleApi.bg_status_string(samplerateKHz));
Environment.Exit(1);
}
Console.Write("Sampling rate set to {0:d} KHz.\n", samplerateKHz);
// Set the idle timeout.
// The Beagle read functions will return in the specified time
// if there is no data available on the bus.
BeagleApi.bg_timeout(beagle, timeout);
Console.Write("Idle timeout set to {0:d} ms.\n", timeout);
// Set the latency.
// The latency parameter allows the programmer to balance the
// tradeoff between host side buffering and the latency to
// receive a packet when calling one of the Beagle read
// functions.
BeagleApi.bg_latency(beagle, latency);
Console.Write("Latency set to {0:d} ms.\n", latency);
Console.Write("Host interface is {0:s}.\n",
((BeagleApi.bg_host_ifce_speed(beagle)) != 0) ?
"high speed" : "full speed");
Console.Write("\n");
Console.Out.Flush();
// Configure the capture buffer
usbConfigBuffer();
// Configure the complex match
usbConfigComplexMatch();
usbDump(num);
// Close the device
BeagleApi.bg_close(beagle);
return;
}
public static void i2cdump(int max_bytes, int num_packets)
{
// Get the size of the timing information for a transaction of
// max_bytes length
int timing_size = BeagleApi.bg_bit_timing_size(
BeagleProtocol.BG_PROTOCOL_I2C, max_bytes);
ushort[] data_in = new ushort[max_bytes];
uint[] timing = new uint[timing_size];
// Get the current sampling rate
int samplerate_khz = BeagleApi.bg_samplerate(beagle, 0);
int i;
// Start the capture
if (BeagleApi.bg_enable(beagle, BeagleProtocol.BG_PROTOCOL_I2C) !=
(int)BeagleStatus.BG_OK)
{
Console.Write("error: could not enable I2C capture; exiting...\n");
Environment.Exit(1);
}
Console.Write("index,time(ns),I2C,status,<addr:r/w>" +
"(*),data0 ... dataN(*)\n");
Console.Out.Flush();
// Capture and print each transaction
for (i = 0; i < num_packets || num_packets == 0; ++i)
{
uint status = 0;
ulong time_sop = 0, time_sop_ns = 0;
ulong time_duration = 0;
uint time_dataoffset = 0;
// Read transaction with bit timing data
int count = BeagleApi.bg_i2c_read_bit_timing(
beagle, ref status, ref time_sop,
ref time_duration, ref time_dataoffset,
max_bytes, data_in, timing_size, timing);
// Translate timestamp to ns
time_sop_ns = TIMESTAMP_TO_NS(time_sop, samplerate_khz);
Console.Write("{0:d},{1:d}", i, time_sop_ns);
Console.Write(",I2C,(");
if (count < 0)
{
Console.Write("error={0:d},", count);
}
print_general_status(status);
print_i2c_status(status);
Console.Write(")");
// Check for errors
if (count <= 0)
{
Console.Write("\n");
Console.Out.Flush();
if (count < 0)
{
break;
}
// If zero data captured, continue
continue;
}
// Print the address and read/write
Console.Write(",");
int offset = 0;
if ((status & BeagleApi.BG_READ_ERR_MIDDLE_OF_PACKET) == 0)
{
// Display the start condition
Console.Write("[S] ");
if (count >= 1)
{
// Determine if byte was NACKed
int nack = (data_in[0] & BeagleApi.BG_I2C_MONITOR_NACK);
// Determine if this is a 10-bit address
if (count == 1 || (data_in[0] & 0xf9) != 0xf0 ||
(nack != 0))
{
// Display 7-bit address
Console.Write("<{0:x2}:{1:s}>{2:s} ",
(data_in[0] & 0xff) >> 1,
((data_in[0] & 0x01) != 0) ? 'r' : 'w',
(nack != 0) ? "*" : "");
offset = 1;
}
else
{
// Display 10-bit address
Console.Write("<{0:x3}:{1:s}>{2:s} ",
((data_in[0] << 7) & 0x300) |
(data_in[1] & 0xff),
((data_in[0] & 0x01) != 0) ? 'r' : 'w',
(nack != 0) ? "*" : "");
offset = 2;
}
}
}
// Display rest of transaction
count = count - offset;
for (int n = 0; n < count; ++n)
{
// Determine if byte was NACKed
int nack = (data_in[offset] & BeagleApi.BG_I2C_MONITOR_NACK);
Console.Write("{0:x2}{1:s} ",
data_in[offset] & 0xff, (nack != 0) ? "*" : "");
++offset;
}
// Display the stop condition
if ((status & BeagleApi.BG_READ_I2C_NO_STOP) == 0)
{
Console.Write("[P]");
}
Console.Write("\n");
Console.Out.Flush();
}
// Stop the capture
BeagleApi.bg_disable(beagle);
}
