Agilent Technologies Announces USB 3.0 SuperSpeed Physical Layer Compliance Test Application

Agilent Technologies Inc today announced Super Speed USB 3.0 comprehensive test equipment. This solution will mainly help in testing and making USB devices compliant with USB-IF requirements.

Agilent demonstrated their solution at the First USB 3.0 Developers Conference in San Jose, CA. 

The Super Speed USB or USB 3.0 can deliver upto 10 times speeds as compared with USB 2.0 and makes power usage more efficient. SuperSpeed USB will be necessary for data-storage devices transferring more than 25 Gbps.

-- Infiniium DSO/DSA91304A 13-GHz oscilloscope for transmitter testing;

-- Agilent USB 3.0 transmitter compliance test application;

-- Agilent USB 3.0 test fixtures;

-- J-BERT N4903A, a high-performance serial BERT with complete jitter tolerance test for characterizing USB 3.0 SuperSpeed serial communication links;

-- Agilent ADS simulation software for creating and analyzing USB 3.0 channels;

-- Agilent VNA/PNA network analyzer N5230C-245 for measuring and analyzing USB 3.0 channels.

Additional information about Agilent's USB compliance test solution is available at www.agilent.com/find/N5416A.

For other USB Analyzers that can be used with USB 2.0 click here.

Using MPUSBAPI.CPP directly instead of MPUSBAPI.DLL

Related Links

1. For learning how to Usie MPUSBAPI.DLL with VC++ 6.0 click here

2. For main.c file used in this example click here.

1. Introduction
All the time, we are trying to use the MPUSBAPI.DLL in various development environments. We tried to use the .DLL in Load-time Linking and Run-time Linking methods. Even Microchip provided samples that show how to use the .DLL in both methods.

After trying few things I realized that the _mpusbapi.cpp file can be added to the project directly. The two important pointes to be noted are:
   - When using along with Borland C++ Builder, _mpusbapi.cpp can be used without modifications.
   - When using with other environments few changes are required.

The project is created in Visual C++ 6.0. But almost the same steps/concepts can be adopted while developing your project in other C++ environments also. 

2. Steps to use the _mpusbapi.cpp instead of mpusbapi.dll in Visual C++ 6.0

1. Create a Win32 Console application as an Empty Project.
2. Create main.cpp file and add it to the project.
3. Now, using Windows Explorer copy the files _mpusbapi.cpp, _mpusbapi.h and Ioctls.h files into your project folder. These files are available in C:\MCHPFSUSB\Pc\Mpusbapi\Dll\Borland_C\Source folder.
4. Go back to VC++ environment, and add the files to the newly created project. For this select the FileView tab in Workspace window. This window provides options to add the files in 3 sections. Source Files (.CPP) and Header Files(.H) and Resource Files(.RES). In our example we do not have .RES files. Add _mpusbapi.cpp under Source Files section and _mpusbapi.h & _Ioctls.h in Header Files Section.
   NOTE: If you compile the project at this point, it will throw errors. We havn't added any code in main.cpp. And some libraries are missing in the project settings at this point of time.
   Errors:
         Compiling...
         main.cpp
         _mpusbapi.cpp
         C:\VCExamples\test\_mpusbapi.cpp(53) : warning C4068: unknown pragma
         Linking...
            Creating library Debug/test.lib and object Debug/test.exp
         _mpusbapi.obj : error LNK2001: unresolved external symbol __imp__SetupDiGetDeviceInterfaceDetailA@24
         _mpusbapi.obj : error LNK2001: unresolved external symbol __imp__SetupDiEnumDeviceInterfaces@20
         _mpusbapi.obj : error LNK2001: unresolved external symbol __imp__SetupDiDestroyDeviceInfoList@4
         _mpusbapi.obj : error LNK2001: unresolved external symbol __imp__SetupDiGetClassDevsA@16
         LIBCD.lib(crt0.obj) : error LNK2001: unresolved external symbol _main
         Debug/test.exe : fatal error LNK1120: 5 unresolved externals
         Error executing link.exe.
   
         test.exe - 6 error(s), 1 warning(s)
   
5. The next step is fixing these errors.
      - unknown pragma : This warning comes because the file is originally built for Borland C++ and Borland C++ prgrams can not be understood by VC++. So remove the line #pragma argsused from _mpusbapi.cpp file.
   
      - error LNK2001: unresolved external symbol : This error came because we need to add setupapi.lib file to the libararies list in the project settings. The functions missing are from this library. So, goto << Project menu->Settings (Alt+F7)->Link Tab >>. Under Object/Library Modules add setupapi.lib and click on ok.
   
      - error LNK2001: unresolved external symbol _main : This error came as we did not add any code to main.cpp. We will do that at the end.
   
   
6. The next step is setting the byte alignment to 1 byte. For this goto << Project menu->Settings (Alt+F7)->C/C++ Tab >>. Under Category List box select Code Generation. Selecting this displays four more list boxes. Under Struct member alignment select 1 byte.
   
   Then from same tab, this time from Category List box select Precompiled Headers. Then select Not using precompiled headers and click on OK. If you create some other type of project, then make sure if the precompiled headers agree for 1-byte struct alignment. Normally the compiler throws a warning in case of any differences. If not change the setting to "Not using precompiled headers".
   
7. Now open to main.cpp file by selecting it from << Workspace Window->FileView tab>>.
   Copy&Paste the content from C:\MCHPFSUSB\Pc\Mpusbapi\Example Applications\Borland_C\Example 01 - Load-time Linking\console.cpp.
   Dont forget to remove the pragma "#pragma argsused" from this file also.
   
   NOTE:I added some more code to main.c used in this article. The link to the file is available in the resources box(top-right hand side of screen).
8. Connect your demo board in the usual way and build and run this application.

In _MPUSBAPI.CPP file there is a DllEntryPoint entry function. To my knowledge the compiler will consider this function as a normal function rather than an entry point as we are not building a DLL here. For exe files main() is the entry point.

If get into trouble because of this function, then you can remove it. Other functions can be called straight away like how we do in Load-time linking.

To use the functions like MPUSBOpen, MPUSBRead etc.. you can follow the same syntax as Load-time linking. All then you need to do is writing a #include "_mpusbapi.h" on top of your source code. Before that you also need to include windows.h. 

   

         

Interacting with Microchip Full Speed USB Demo board using Visual Basic.NET

Source Files

1. Download the Visual Basic.NET Example with _cdecl.

2. Download the Visual Basic.NET Example with _stdcall.

1. What you need to know.

VB 6.0 allows to invoke functions from DLLs with _stdcall only. But VB.NET allows to invoke functions _cdecl calling convention also.

In this article I provided 2 project files for interacting with the Microchip Full Speed USB Demo Board. These projects interact with the Microchip general purpose USB Driver. MPUSBAPI.DLL with _cdecl can be downloaded from Microchip directly. The other example uses _stdcall calling convention. For this the MPUSBAPI.DLL need to be rebuilt with _stdcall convention. Also refer to the previous article for more information on how to use the _stdcall DLL in VB 6.0. Also previous articles gives an idea from where to download the files.

NOTE: The _cdecl DLL contains underscore(_) prefixed to the funtion names. Where as the _stdcall DLL will not contain the underscore(_) prefixed.

To interact with Microchip USB demo board from a PC MPUSBAPI.DLL need to be used.

2. How Visual Basic.NET and Visual Basic 6.0 access DLLs, differences:

Visual Basic.NET is a complete new development environment that is based on the .NET framework. The VB.NET is a complete Object Oriented Programming language and it supports modernization of code extensively. Most of the basic keywords remained same, but there are many additional keywords. Being a full object oriented language, VB.NET supports features like inheritance, polymorphism, abstraction, and encapsulation. As far as declaring the functions to access functions in .DLL file is same as VB 6.0 syntax. The major difference with respect to VB 6.0 version of the example code is in place of VarPtr the member functions of System.Runtime.InteropServices.Marshal need to be used. Marshaling is a mechanism used for converting/representing data between various platforms or environments in way that the content will never be lost. The System.Runtime.InteropServices.Marshal is a .NET class that is used for this purpose.

The UnsafeAddrOfPinnedArrayElement is used for obtaining the base address of the buffer that is used in MPUSBRead and MPUSBWrite function calls.

The other differences are language and environment specific differences. From the VB 6.0 example, .BAS file and .FRM files are converted to their respective .VB files.

3. VBMPUSBAPI.vb:

This file also provides the same set of functions which provided in the previous example.

• Initialize: Used for initializing the variables.
• OpenMPUSBDevice: Used for opening the data pipes of the Demo application.
• CloseMPUSBDevice: Used for closing the opened data pipes.
• SendReceivePacket: Used for performing the complete Demo application transfer. You can observe that SendData and ReceiveData are passed as Byte arrays. Inside the function the address of the first elements of the Byte arrays are passed to the Read and Write functions in the DLL.

4. VB6PICUSBDemo.vb:

This is the source code file that is generated when VB6PICUSBDemo.frm is ported to VB.NET. This file contains the actual example code on how to use the above functions. This ends the 3 article series on Visual Studio.NET. There is already one article available at www.piccoder.co.uk. So I am not touching the C# aspect.

Interacting with Microchip Full-Speed USB Demo Board using Visual Basic

This is MPUSBAPI Visual Basic 6.0 Example.

Source Code available here.

Modified _stdcall MPUSBAPI.DLL Files available here.

The previous article shows how to connect to the PICDEM FS Demo Board using Visual C++ and Win32 API. The previous article also explains from where to get the required files. So, take a look at it if you are starting from scratch. And this article uses an example application with similar functionality and User Interface as application written in VC++ in the previous article. 

In this article I will explain, how this can be done in Visual Basic 6.0. The Visual Basic.NET takes a different approach which I will explain in the next article. 

The MPUSBAPI.DLL that is provided along with package MCHPFSUSB.ZIP is a dynamic-link library(DLL) that provides a set of public functions for communicating with the Demo Board with the custom driver. And both Visual Basic 6.0 and Visual Basic.NET provides mechanisms to access the Win32 DLL directly even though there is no .LIB file available. For using a DLL in VB one does not need to use the LoadLibrary() API function set. 

But there is a catch. The DLL functions can only be used in VB provided they are implemented using the Standard Calling convention. i.e functions declared with _stdcall. This places a limitation on the usage of a number DLLs in Visual Basic that are developed using Visual C++ or Borland C++ tools if the _cdecl or any other calling convention methods are used while declaring or defining the functions. 

Please refer to http://support.microsoft.com/default.aspx?scid=kb;en-us;Q153586 for more information on how DLL need to build for using in Visual Basic. 

The DLL provided by Microchip is implemented using the _cdecl calling convention. This may be for achieving higher performance. So, we can not use it directly in Visual Basic. The DLL Source project need to be re-compiled by changing the declarations of the exported function to _stdcall. The modified source code of the MPUSBAPI.DLL can be downloaded here. Download this source code and re-build it using Borland C++ Builder tools. 

NOTE
The DLL need to be recompiled by adding _stdcall in place of _cdecl to all exported functions. 

Ok, lets move on now.

First things first, Visual Basic 6.0 does not support pointers. Which means that it is not supporting HANDLEs. HANDLEs are used in Win32 API to access system level objects. The HANDLEs in VC++ are represented as pointers. When it comes to VB, there is no way to declare pointers. But pointer is nothing but a variable that stores in address. An address is a numeric value of 32 bit length in WIN32 Operating Systems. That means variables of type Long datatype can be used for representing HANDLEs in VB. 

Similarly corresponding VB data types which can hold the data need to be identified for each argument and return types of the functions in the DLL. 

For more information on how these functions work, take a look at the previous article. 

Now the task at hand is creating a .BAS file which will hold references to the above listed functions in the syntax that is followed in VB 6.0. 

Ok, it is time to learn some theory.

Next step is creating .BAS file in the Visual Basic with the list of exported (public) functions in the DLL. The MPUSBAPI.DLL has following functions(This DLL is created with the _stdcall and notice that the underscores prefix of the functions are gone.)

DWORD MPUSBGetDLLVersion(void)

DWORD MPUSBGetDeviceCount(PCHAR pVID_PID)

HANDLE MPUSBOpen(/*Input */ DWORD instance, /* Input */ PCHAR pVID_PID, /* Input */ PCHAR pEP, /*Input*/ DWORD dwDir, /*Input*/ DWORD dwReserved);

DWORD MPUSBRead(/*Input*/ HANDLE handle, /*Output*/ PVOID pData, /* Input */DWORD dwLen, /* Output */PDWORD pLength, /*Input*/ DWORD dwMilliseconds);

DWORD MPUSBWrite(/*Input*/ HANDLE handle, /*Input*/ PVOID pData, /*Input*/ DWORD dwLen, /*Output*/ PDWORD pLength, /*Input*/ DWORD dwMilliseconds);

DWORD MPUSBReadInt(/*Input*/ HANDLE handle, /*Output*/ PVOID pData, /* Input */DWORD dwLen, /* Output */PDWORD pLength, /*Input*/ DWORD dwMilliseconds);

DWORD MPUSBClose(/*Input*/ HANDLE handle);

Keywords used in VB 6.0 for declaring API functions: 

1. Public:  This keyword is used to indicate that the function declared is public function which can accessed through out the VB program.
2. Declare:  Used at module level to declare references to external procedures in a dynamic-link library (DLL).
3. Function/Sub:  Function indicates that the procedure returns a value that can be used in an expression. Sub indicates that the procedure does not return a value.
4. Lib:  Indicates that a DLL or code resource contains the procedure being declared. The Lib clause is required for all declarations when using a DLL.
5. Alias:  Indicates that the procedure being called has another name in the DLL. This is useful when the external procedure name is the same as a keyword. You can also use Alias when a DLL procedure has the same name as a public variable, constant, or any other procedure in the same scope. Alias is also useful if any characters in the DLL procedure name are not allowed by the DLL naming convention.

Syntax used in VB 6.0 for declaring API functions:

[ Public | Private] Declare { Sub | Function } name Lib "libname" [ Alias "aliasname" ] [([ arglist])] [ As type ] 

Example: 
Public Declare Function LoadLibrary Lib "kernel32" Alias "LoadLibraryA" ( ByVal lpLibFileName As String ) As Long 

The example shows the LoadLibrary function which we used extensively in previous article when used in VB 6.0. The "kernel32" represents the KERNEL32.DLLfile which is a system Win32 API file and one of the core DLLs of the operating system. Actually the function LoadLibraryA is implemented in this DLL. But we are using the Alias keyword to change the name to LoadLibrary. 

This API function takes 1 argument and returns a value. So it is declared as function in VB. As it takes a string as argument, the datatype of the argument is declared as String. As it returns a HANDLE as return value, the return value data type is selected as Long. Similarly public exported functions available in other Windows System DLLs as well as User DLLs can be accessed. If the function name to be used in Visual Basic is same as the function name in the DLL the use ofAlias is not required. 

The MPUSBAPI.DLL functions looks in the following manner when declared in Visual Basic 6.0. When these declarations are made, make sure that the DLL is in a directory which is listed in the system path. 

• Public Declare Function MPUSBGetDLLVersion Lib "mpusbapi" () As Long
• Public Declare Function MPUSBGetDeviceCount Lib "mpusbapi" (ByVal pVID_PID As String) As Long
• Public Declare Function MPUSBOpen Lib "mpusbapi" (ByVal instance As Long, ByVal pVID_PID As String, ByVal pEP As String, ByVal dwDir As Long, ByVal dwReserved As Long) As Long
• Public Declare Function MPUSBRead Lib "mpusbapi" (ByVal handle As Long, ByVal pData As Long, ByVal dwLen As Long, ByRef pLength As Long, ByVal dwMilliseconds As Long) As Long
• Public Declare Function MPUSBWrite Lib "mpusbapi" (ByVal handle As Long, ByVal pData As Long, ByVal dwLen As Long, ByRef pLength As Long, ByVal dwMilliseconds As Long) As Long
• Public Declare Function MPUSBReadInt Lib "mpusbapi"(ByVal handle As Long, ByVal pData As Long, ByVal dwLen As Long, ByRef pLength As Long, ByVal dwMilliseconds As Long) As Long
• Public Declare Function MPUSBClose Lib "mpusbapi"(ByVal handle As Long)As Long

When we take a look at the above declarations which are used in Visual Basic, one can observe that the data types of the arguments in each function almost match the data types of their C language prototypes. But, few are not matching. Out of these one important argument is pData which is originally an array of bytes. But here in VB it is declared as Long. The reason for this declaration is when the data is passed from VB, we are actually passing the address of first element in the array. As we know, the address is an unsigned numerical value, which can be represented in VB with Long type. Once the address is available to a function, the function can do any with the data available in that address. When see the source code files provided along with this project, you can observe that the address of first byte is passed from a Byte array. 

The VB 6.0 Example code can be downloaded from here. 

The (VBMPUSBAPI.BAS) contains all the code related to MPUSBAPI.DLL and also additional functions and data definitions required to communicate with the demo firmware that comes with the demo board. 

It implements following functions:

• Initialize: Used for initializing the variables.
• OpenMPUSBDevice: Used for opening the data pipes of the Demo application.
• CloseMPUSBDevice: Used for closing the opened data pipes.
• SendReceivePacket: Used for performing the complete Demo application transfer. You can observe that SendData and ReceiveData are passed as Byte arrays. Inside the function the address of the first elements of the Byte arrays are passed to the Read and Write functions in the DLL.

The (VB6PICUSBDemo.frm) is VB Form file, which contains the event handles for two check boxes and one command button. These function in-turn calls the functions declared in the .BAS file as per the requirement. The section 7.2 in the previous article shows how the sequence is to be followed. The event handles in this file also follows similar sequence.

    Private Sub Check1_Click()
      [Step A - Declarations]
      Dim send_buf(0 To 64) As Byte
      Dim receive_buf(0 To 64) As Byte
      Dim RecvLength As Long

      [Step B- Open the USB End-points]
      OpenMPUSBDevice

      [Step C- Check the Handles of the End-points to see if the are opened properly]
      If myOutPipe <> INVALID_HANDLE_VALUE And myInPipe <> INVALID_HANDLE_VALUE Then 

          [Step D- Initialize the command to be transmitted to demo firmware]
          RecvLength = 1
          send_buf(0) = 50 '0x32 - SET_LED 
          send_buf(1) = 3 ' LED Number
          'Set LED value based on the check box state
          If Check1.Value = 1 Then
            send_buf(2) = 1
          ElseIf Check1.Value = 0 Then
            send_buf(2) = 0
          End If

          [Step E- Call SendReceivePacket to send the command and to receive the response ]
          If (SendReceivePacket(send_buf, 3, receive_buf, RecvLength, 1000, 1000) = 1) Then

            [Step F- The received data confirms that the command is executed properly ]
            If (RecvLength <> 1 Or receive_buf(0) <> 50) Then
              MsgBox "Failed to update LED"
            End If

          End If

      End If

      [Step G- Once the operation is completed, close all the open handles ]
      CloseMPUSBDevice

    End Sub

In the next article I will explain how to use the Visual Basic .NET.

List of USB Protocol Analyzers available in market

What does USB Protocol Analyzers do?

USB Protocol Analyzer is like any other protocol analyzer. It basically hooks onto the bus and probes the signal patterns, and from the signal patterns re-creates the user understandable data or packet formats as per the USB 2.0 specifications.
There are two types of Protocol Analyzers for USB. 1) Hardware+Software Toolset 2) Only Software. This document explains only the Hardware Type Protocol Analyzers.
The Hardware type protocol analyzers are costly to procure, and the price is directly proportional to the trace buffer available in the hardware. But these analyzers come with great powers, the collected data can be viewed and formatted in many formats and helps users to pin point the problems quickly and help in debugging the application.
Some of the typical capabilities are:

• Triggers - Specify when to start the data collection from the bus
• Prefetch - How many packets need to be recorded before the trigger
• Postfetch - How many packets need to be recorded after the trigger
• Trigger Types - Manual, Automatic, Content Based (Based on what is there inside a packet), Transaction Based
• Buffer Size Control - For managing the available trace buffers
• Reporting & Filtering Options - Flexibility to view specific trasactions and specific packets
• Save & Reload operations
• Simulation & Transmission of User Defined Packets on the bus - In this case user can transfer a packet to see how the device driver or the device responds to specific packets. Activity is intiated by user, but the analyzer pretends as if the host or the device has generated the packet

The above is a partial list of most common features. For more information one should check the documents of each of the Analyzers.

---

List of USB Protocol & Bus Analyzers (that come in form of Hardware+Software)

Analyzer	Description	Image(If Available)
MQP Electronics Packet-Master USB480+	Description: On-the-Go(OTG) analysis Analyse High-Speed, Low-Speed, Full-Speed USB Device in any combination of speeds 32 Mbyte FIFO Advanced hardware event triggering as standard Up to 4Mbyte Pre-Trigger Data Buffer Highest Specification for the Lowest Cost Integral Capture Start and Stop buttons and Capture Indicator USB through-connectors for device under test High Speed USB uplink for unlimited capture BNC Connector for Trigger Input or Output Feature connector provides signals for oscilloscope or logic analyser Comprehensive event filtering, highlighting, searching and bookmarking ncludes Free Class Analysis package ~$1500 USD (special educational pricing available)
MQP Electronics Packet-Master USB480	Description: On-the-Go(OTG) analysis Analyse High-Speed, Low-Speed, Full-Speed 32 Mbyte FIFO Hardware triggering BNC trigger input Highly cost-effective development solution Integral Capture Start and Stop buttons and Capture Indicator USB through-connectors for device under test Automatically detects speed of link under test High Speed USB (480 Mbit/s) connection to host PC Feature connector provides signals for oscilloscope or logic analyser Comprehensive event filtering, highlighting, searching and bookmarking ~$1400 USD (special educational pricing available)
MQP Electronics Packet-Master USB12	Description: Analyses Low Speed, Full Speed or a mixture of both(No High Speed) Power Indicator & Activity indicator shows presence of data exchanges Integral Capture Start and Stop buttons and Capture Indicator Economically priced Bus-powered for convenience of use, Optional external power input supply High Speed USB uplink for unlimited capture time Comprehensive event filtering, highlighting, searching and bookmarking ~$750 USD (special educational pricing available)
Ellisys USB Explorer 200	Description: Supports Low Speed (1.5Mbits/s), Full Speed (12Mbits/s) and High Speed (480Mbps) Measurement of USB bus states and low level protocols Device Bus Powered. No need for external adaptor. Speedy USB2.0 Uplink with Internal 32MB FIFO Memory. Intutive, Easy to use Interface. High level decoding of requests and descriptors, making diagnosing problems a breeze. Filtering and Highlighting of Events. Dimensions: 150 x 120 x 65 mm, Weight 850g. ~$2600 USD and includes a 2 years of limited warranty.
Ellisys USB Tracker 110 Recommended	Description: Supports Low Speed (1.5Mbits/s) and Full Speed (12Mbits/s) Unlimited capture time. USB2.0 Uplink (Backwards compatible with 1.1). Device Bus Powered. No need for external adaptor. Power and Activity LEDs. Activity flashes green on receipt of DATA0/1 packet but not captured and red if captured. Realtime statistics during capture. Filtering and Highlighing of Events. Dimensions: 85 x 80 x 45 mm, Weight 75g. ~$850 USD and includes a 2 years of limited warranty.
Wireless USB Explorer 300 Wireless USB Protocol Analyzer	Description: Displays UWB and Wireless USB protocols in an easy-to-use hierarchical view Supports speeds up to 480 Mbps Non-intrusively captures traffic from any MB-OFDM UWB link. Automatically determines the speed of each frame and decodes it accordingly. Highlights protocol errors and interoperability issues Supports the latest WiMedia and Wireless USB specifications. Free viewer software to exchange recorded traffic with others, Free lifetime software maintenance. Powered by USB, no need for a bulky external power supply. Dimensions: 150 x 120 x 65 mm (5.91 x 4.72 x 2.56'') , Weight 850 g (1.9 lbs). 2 years of limited warranty.
USB Ver.2.0 Bus Protocol Analyzer SB-2020	Description: Automatic detection of USB 2.0 at high, full, and low speed Trigger function Powerful filtering function. Built-in 512 MB capture memory. Capturing of log data up to 20 GB. Display descriptor tree. Bus state display. Display communication speed. Dimensions: 150 x 120 x 65 mm (5.91 x 4.72 x 2.56'') , Weight 850 g (1.9 lbs). 2 years of limited warranty.
CATC USBTracer/Trainer™ Protocol Verification System	Description: CATC Trace Analysis Software System OTG (On-The-Go) Support Traffic Generation/Device Emulation. 512 MByte Recording Capacity Non-intrusive High Impedance Probe Advanced Triggering Extensive Decodes to display Device Class Specific information. Real-Time Statistics & Hardware Filtering Hi-Speed USB Port 3 years of limited warranty.
CATC Advisor™ Protocol Analyzer	Description: CATC Trace Analysis Software System Records USB 2.0 traffic - Supports all three USB speeds (High (480Mbps), Full (12Mbps) and Low (1.5Mbps)) 128 MByte Recording Capacity. BusEngine Protocol Processor technology Dual Recording Channels Advanced Triggering Intelligent Reporting Real-Time Statistics & Hardware Filtering Hi-Speed USB Port 3 years of limited warranty.
CATC USBMobile™ Protocol Analyzer	Description: PC Card form factor - Personal analyzer. Low-power, portable operation with any notebook PC CATC Trace Analysis Software System Records USB 2.0 traffic - Supports all three USB speeds (High (480Mbps), Full (12Mbps) and Low (1.5Mbps)) OTG (On-The-Go) Support 64 MByte Recording Capacity. 2 Mini AB USB ports and cables. Extensive Decodes to display Device Class Specific information. BusEngine Protocol Processor technology Advanced Triggering Intelligent Reporting Real-Time Statistics & Hardware Filtering Hi-Speed USB Port 3 years of limited warranty.
Beagle™ USB 12 Protocol Analyzer	Description: The Beagle USB 12 Protocol Analyzer is a bus-powered, high-speed USB 2.0 device. Being small, lightweight, and portable in size (89 x 41 x 25 mm) it is the ideal tool for engineers in the field. Non-intrusive Full-/Low-Speed USB monitoring of a USB bus in real time. The capture is nearly limitless as data is constantly streamed to the analysis computer. Share your captured data with your colleagues with ease. The Beagle Data Center is our free GUI monitoring software which can be downloaded from the Total Phase website. The Beagle USB 12 Protocol Analyzer is only $400 in single-unit quantities. Additional volume discounts are available. At this price, every engineer can have their own analyzer. The Beagle USB 12 Protocol Analyzer is available for purchase through the Total Phase website. Small orders of 25 units or less normally ship within 24-48 hours. If you are located outside the United States, please consult the list of international distributors on our website.
Beagle USB 480 Protocol Analyzer	Description: Non-intrusive High-speed USB 2.0 monitoring (up to 480 Mbps) Two capture modes: real-time and delayed-download High-speed USB chirp detection Hardware-based packet suppression Digital inputs and outputs for synchronizing with external logic Real-time capture and delayed-download capture Free software and API available. Compatible to Linux & Windows. The Beagle USB 480 Protocol Analyzer comes complete with software for an introductory price of $1200.
CATALYST Conquest™ Series USB Protocol Analyzers	Description: Three Variants: Conquest Classic; Conquest Standard; Conquest Advanced Low Speed (1.5 Mb/s); Full Speed (12 Mb/s); [ High Speed (480 Mb/s) Available in Standard, Advanced] 128 MB Trace Memory. Search on Errors and Data Payload Snapshot Capture Upper-level USB Device Class Decodes in Standard, Advanced Trigger on Protocol Errors & Transactions in Standard, Advanced Multi-level Event Triggering (Advanced mode) Classic starts at $995.
CATALYST SBAE Series, Universal Serial Bus (USB)	Description: Too many features, see company website :-) Analyzer, Exerciser, Device Emulator, OTG, DC Compliance DC Compliance Test Suite Protocol Error Detection Performance Analysis & Performance Characterization SBAE30B USB 2.0 Protocol Analyzer System (SBAE30B-2X-ADC) SBAE30B USB 2.0 Protocol Analyser / Exerciser System (SBAE30B-2X-EDH)
USB2 SnooperTM (USB 2.0 Bus Analyzer)	Description: Compatible to USB2.0 & USB1.1 specs Supports HS, FS and LS speeds Provides USB-ON-THE-GO ( OTG ) support Non-intrusive snooping Self powered. Does not consume power from USB cable Provides Packet View, Transaction View, Control transfer view, Summary view, Raw bit view for effective packet analysis. Comes as a PCI add-on card for fast transfer to PC memory. Optimizes the usage of PC's available memory. Works faster. External Trigger input & external trigger outputs are for enhanced capture & trigger Oscilloscopes to observe electrical condition on the Bus Time stamping for each captured packet with 16.67ns resolution. Provides very high capture buffer depending on the PC memory. On Windows 2000 one can easily go up to 540MB of capture buffer depending on Memory support