WaveBPS Protocol Oscilloscope

WaveBPS for FlexRay, CAN bus, and LIN bus

  • WaveBPS
  • FlexRay
  • CAN Bus
  • LIN Bus
  • Others
  • Download
  • Buy Now
  • Company
Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Introducing WaveBPS: Portable Low level analog serial data analysis

Often in the real world things go wrong to the point where protocol tools do not show enough information - you have to understand what is going on at a lower level.

Intrepid Control Systems, Inc. is proud to introduce WaveBPS - an advanced tool for capturing and analyzing digital protocolanalog waveforms like SPI, I2C , CAN Bus, UART (RS232, J1708, K-Line, SCI, GM CGI), J1850, FlexRay or LIN Bus.

Besides general purpose monitoring, WaveBPS can quickly capture infrequent or intermittent protocol violations. For example, you can track down the error frames that may occur intermittently. Another application is verifying there are no timing violations on software based protocol implementations.

The trial version of the software is available for download and is useable for training and learning these protocols. The standard and professional versions of WaveBPS are available for purchase.

Click picture for screen shots

USB Oscilloscope Features

WaveBPS directly captures data directly from a PicoScope USB Oscilloscope. Depending on the model WaveBPS supports up to 4 channels, 1 GS/s sampling and a memory depth of 128 Mega samples. For hardware triggering the scope offers a CAN error trigger, standard scope analog triggering, and CAN/LIN script based triggering with an Intrepid ValueCAN3 or neoVI FIRE. Also, WaveBPS can load waveform files captured from popular oscilloscopes.

WaveBPS Productivity Features

Usability is one of the best features of WaveBPS. WaveBPS understands the waveforms you are looking at so you can quickly navigate and find events and errors. Full mouse and keyboard support allows you to quickly find the information you are looking for. Powerful cursor measurements allow you to quickly determine time, voltage and bus utilization.

Export Support

After determining the parts of the waveform of interest the user can export the waveform subset for other users to view.

Serial Data Decode Support

WaveBPS supports serial decode on FlexRay, CAN Bus, UART (J1708, K-Line, SCI, RS232, GM CGI), J1850, SPI, I2C or LIN Bus. The baud rate, thresholds and other settings for these protocols is completely configurable by the user in case of specialty probes (ie. current or differential) modify the expected voltage ranges of the waveforms. WaveBPS also supports GMLAN 3110 high speed mode switch for single wire CAN.

Test Automation

WaveBPS has a TCP/IP software API allowing remote control and analysis from other applications. This includes the ability to control WaveBPS with Vehicle Spy scripting.

Powerful Analysis

WaveBPS can also perform statistical node analysis where each automatic measurement is grouped by node and exported to a spreadsheet file.

Product PDF Product Sales Sheet

Movie Overview Video Movie
Movie Watch Now

Screenshot FlexRay Waveforms
These are 10Mbit FlexRay static slot frames

Screenshot CAN bus Waveform
This is a 500Kbit DW CAN Bus standard frame

Screenshot LIN bus Waveform
These are 10.41 Kbit LIN Bus frames

Specifications

Buy Now

Policy - WaveBPS is a trademark of Intrepid Control Systems, Inc.


Getting Data into WaveBPS

  • CAN Bus
  • LIN Bus
  • Others
  • Download
  • Buy Now
  • Company
Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Getting Data into WaveBPS

Besides capturing live data from a USB oscilliscope, you can load data into WaveBPS from a saved data file. First you pick a decoder and click "Open Waveform" (figure 1). After doing this the waveform will be plotted and decoded. The zoomed waveform view will then show the first event in the data.

Movie Importing Data Video
Movie
Movie Watch Now

You can also click the refresh button to decode the current waveform again. This maybe useful if you want to update the view with a new decoding or thresholds. Finally when you start again a button will appear allowing you to open the last waveform file you looked at.

Loading CAN bus, LIN bus, or FlexRay data
Figure 1 - you can open waveforms from a file by clicking "Open Waveform"

WaveBPS supports waveforms from Lecroy and Picoscope oscilloscopes. Also you can write a simple import plug-in using Visual C++ using the sample project provided. Please contact us to write an import for your capture device.

WaveBPS automatically stores your current setup when you close the application. This setup resides in a file called "wavebps defaults.xml" stored in the applications directory. You can save or load a previous setup at anytime by clicking the application configuration tab and selecting import or export configuration. You can also load these remotely using the Text API.

WaveBPS Configuration
Figure 2 - you can import and export the current wavebps configuration.


WaveBPS Import Data Video

The Camtasia Studio video content presented here requires JavaScript to be enabled and the latest version of the Adobe Flash Player. If you are you using a browser with JavaScript disabled please enable it now. Otherwise, please update your version of the free Adobe Flash Player by downloading here.


Picoscope

  • Download
  • Buy Now
  • Company
Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Live Capture with WaveBPS

WaveBPS can capture data in real time from a Picoscope USB oscilloscope (Figure 2). WaveBPS includes 3 capture modes including single capture, multiple capture, and a filter based multi capture. The filter based capture can be used to capture events based on the decoded information.

If you have the correct oscilliscope series selected WaveBPS will automatically connect to the PicoScope when it starts. After the PicoScope is configured you can click start on the capture toolbar (figure 1). The capture toolbar also lets you select the capture mode and displays capture and decode progress.

Table 1 - Live Capture Modes

Capture Mode | Description
Single | Captures and decodes a single buffer
Multiple | Repeated captures and decodes buffers
Filter Match | Repeated captures and decodes buffers until at least one decoded event matches the filter
Movie Live Capture Video
 Movie
Movie Watch Now

Capture Toolbar
Figure 1 - You can start the capture and select the capture mode from the capture toolbar.

WaveBPS is a fully capable oscilloscope application allowing you to capture regular analog signals along with serial data. Therefore, WaveBPS has the same settings you are accustomed to on a traditional oscilloscope.

PicoScope 5204 with WaveBPS
Figure 2 - You can purchase WaveBPS with the PicoScope.

You can customize your capture in many ways (figure 3). First, you can select how many channels you wish to acquire (Part B). Next, for each channel you can specify the probe type, voltage range and electrical coupling (Part C). For serial data, recommended settings are 10x probes, +/-20 V or lower range depending on the protocol, and DC coupling.

Next you can set up the capture rate and length (Part D). First you pick how many samples you want to capture. Depending on the PicoScope, you can capture up to 128 mega samples. Next you can pick your sample rate as either samples per second or microseconds per sample. When you change your sample rate or sample length the total capture time display will update with how long your capture will last.

Trigger setup is next (Part E). The Oscilloscope uses the trigger specification to determine when to capture data. Here you can pick the source (Channel A, Channel B, Channel C, Channel D, or External). You can also specify a timeout - this is how long WaveBPS waits for a trigger before auto triggering. For the trigger channel you can specify the signal transition that must occur according to voltage, transition direction and hysteresis.

WaveBPS supports a CAN error frame trigger on selected oscilliscopes (pulse width advanded trigger). The error frame must occur on the trigger channel you selected. For this the trigger must be above the threshold for the proper number of bit times to qualify as an error frame. To enable this choose the CAN error frame special trigger and enter the bit rate of the CAN bus.

The trigger supports pre-trigger data. This means you can capture a percentage of your buffer before the actual trigger condition. This is set in percent of your total capture length.

For the filter match capture mode there are additional options (Part E). First, when a filter match occurs after a decode WaveBPS can play a wave audio file. Next, WaveBPS can also automatically save the file. Finally, WaveBPS can also automatically restart the filter match capture to look for the next event.

Live Capture
Figure 3 - There are many options to customize your analog capture.


Navigation

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Navigation

WaveBPS was designed to support very efficient waveform navigation using the mouse and the optional knob (figure 1). This allows you to quickly focus in on the information you are interested in the waveform. This is especially important when searching megasamples of waveform data.

The WaveBPS application has four main parts, the entire capture, scalar measurements, the zoomed view and the event list. The summary waveform shows the entire file while the zoomed waveform shows the region of interest. The scalar measurements list measurements made on the entire capture (more here). Lastly, the event list, will list all of the events such as Frames or symbols decoded from the entire capture. See the screen shot below.

Knob
Figure 1 - For customers who miss the knobs of a traditional oscilloscope WaveBPS supports the Space Navigator

Movie Navigation Video
 Movie
Movie Watch Now

WaveBPS GUI Sections
Figure 2 - The main sections of the WaveBPS GUI

Navigation using the Summary Waveform
Line

To modify the Zoomed waveform to set what you are interested in, you have a number of options. First, you can change the cursors in the summary waveform. This will cause the zoomed waveform to show the area between the cursors. You can also double click an area in the summary waveform to center the cursors.

Navigation using the Event List
Line

Next you can double click an item in the event list. This will pan and zoom the waveform displays to the event described in the list. You can also double click any column on an item and the waveforms will zoom into that automatic measurement. For example, you can double click on the CRC and the zoomed view will show the CRC part of the event. The Columns in the event list are described here in a seperate topic.

As you navigate the zoom view the event list will automatically scroll to the events visible. The events visible in the zoom view will have bold text.

Navigation using the Browse Toolbar
Line

The browse toolbar is a very powerful way to browse waveforms. Shown below the browse tool bar allows you to quickly page left and right, or browse to the next event. It also supports filtering. This allows you to quickly skip to the next frame, waveform error, or waveform symbol such as CAN bus acknowledge bits. Alt -Left and Alt-Right keys quickly take you to the next event.

Select the item you wish to filter upon in the drop down, then enter a filter specification in the box to the left (figure 3). Table 1 lists the filter specifications possible. For filters that use math you can use a "$" character to represent hex data. You can enter more than one filter spec for multiple columns but you have to do this by adding the comma, the name of the second column, a space and then the second filter specification. This filter is also used in the filter match capture mode.

Navigation using a filter
Figure 3 - The browse filter can be multi-item to allow searching for events.

Table 1 - Filter types

Filter Type | Description | Example
Text Compare | Basic Text wildcard filter *,? supported | 7e?
= | equality | = 1 // hispeed mode is greater than 1
>, >= | greater than (or equal to) | > 0 // error count greater than 0
<, <= | less than (or equal to) | < 10 // TIFS less then 10 microseconds
{} | inside a range of values | {} $240-$247 // inside a range

Navigation using Auto scroll
Line

Sit back and watch with Auto scroll (figure 4). Auto scroll will scroll at a user specified bit rate or will skip to the next waveform events at intervals. This allows very quick visual review of a lot of waveform data.

Navigation Autoscroll
Figure 4 - auto scroll waveform based on events or at a bit rate.

Navigation using the zoomed waveform
Line

The zoomed waveform is mouse friendly. You can pan and zoom the X axis in the zoomed waveform using the mouse wheel. Double clicking will center the plot too. Finally pressing the spacebar will take you to the next browse event.

Navigation using the Space Navigator
Line

The Space Navigator is a analog six axis USB joystick knob with two buttons. Using this knob you can very quickly zoom in and out, pan and make measurements. When connected WaveBPS will show the knob icon (figure 5). See the figure 6 below for how the knob works with WaveBPS.

Knob Enabled Graphic
Figure 5 -WaveBPS will show the knob icon if the knob is connected.

Space Navigator
The knob gives you powerful navigation of the captured waveform.


CAN Node Analysis

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Advanced Analysis

WaveBPS can do advanced analysis. When a data base is enabled you can do statistics on the entire capture according to node (Figure 1). WaveBPS will calculate the min, max, mean for every automatic measurement organized by node. An example node analysis performed on the "dwcan diff traffic" example waveform is included here . This type of analysis quickly helps you find nodes that are acting badly.
Movie Node Analysis Video
 Movie
Movie Watch Now

Node Analysis
Figure 1- Node analysis will create a statistic report of all automatic measurements organized by node.


Oscilloscope Automtated Test

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Automated Test with WaveBPS

WaveBPS includes a TCP/IP server to allow remote control from other applications. The TCP/IP Server offers a text based command set allowing a remote application capture data, save data and collect results. This server is very easily controlled by Vehicle Spy scripts allowing test systems that involve both message simulation and diagnostics to be combined with analog capture and analysis.

The TCP/IP server configuration is available from the Application Configuration Tab tab. Here you can enable the TCP/IP server with a specific port. You can also enable the TCP/IP server to start when WaveBPS starts. Make sure to allow the WaveBPS and port you choose access though your firewall.
Movie Automated Test Video
 Movie
Movie Watch Now

WaveBPS TCP Server
Figure 1 - The configuration of the TCP/IP server in WaveBPS.

A list of available commands supported is listed in the table 1 below.

Table 1 - Text API commands for WaveBPS Main Object

Command | Description | example
de | accesses the decoder objects collection | de.count? // returns count of decoders de(0).description SPIDecode // sets description of first decoder to SPIDecode
sc | accesses the scope object |
an | accesses the analysis results collection (one per channel) |
start | starts wavebps |
stop | stops wavebps |
refreshgui | loads the settings into the gui (call when you load configuration settings) |
saveentirerawwaveform "filepath" | saves the current waveform to the "filepath" |
hascaptureddata? | returns whether wavebps has finished captured data |
loadconfig "filepath" | loads a configuration indicated by "filepath" |
an(key or index).getscalar? "scalarname" | reads a scalar value such as error count or frame count |
savevspybuffer "filepath" | saves a vehicle spy buffer | savevspybuffer c:\test.csv
saveeventlist "filepath" | saves the event list to a file name | saveeventlist c:\test.csv
autosave | indicates whether autosave should occur on a filter match capture | autosave 1
autorearm | indicates whther a filter match capture should rearm | autorearm 0
autosavepath | sets/returns the autosave path | autosavepath?
decodercha | sets/return the index of the decoder for channel a | decodercha 1
decoderchb | sets/return the index of the decoder for channel b |
decoderchc | sets/return the index of the decoder for channel c |
decoderchd | sets/return the index of the decoder for channel d |
defaultevent | This is the event filter box as an index |
defaulteventfilter | This is the text filter |
wavefileplayonmatch | returns/sets whether a wavefile should be played when a trigger is matched |
wavefilepath | returns/sets the path of the of the wavefile that is played when a trigger occurs |

Table 2 - Decoder Object Properties

Command | Description | example
baudrate | returns/sets the baudrate of the decoder |
basicdatabasepath | returns/sets the path of the data base for this network |
canbittolerance | returns/sets the CAN bit tolerance in percent |
description | returns/sets the description of the decoder |
decodertype | returns/set the decoder type. The following values are valid DWCAN = 0, FlexRay = 1, SWCAN= 2, LSFTCAN= 3, LIN= 4, J1850VPW= 5, KLine= 7, UART= 9, NoDecode= 10, Disabled=12, MathAMinusB= 13, MathAPlusB= 14, I2C= 15, SPI= 16, |
databitordering | indicates either endianess of the data items either msb first or last |
datalengthbits | indicates the number of bits per data item (works for those decoders who support it such as UART and SPI) |
enablemovingaveragefilter | enables a 3 point moving average for the detecting thresholds |
errordecodelimit | returns/set the number errors before the decoder gives up |
enablegmlancanswitch | enables message decoding and detection of the GM3110 high speed programming protocol (Automatically switches decoder baud rate) |
enableautobaudrate | enables an automatic baud rate detection where the estimated baud rate is compared to standard values |
enablemanualthreshold | enables a manual threshold as opposed to the automatic algorithim |
flexraychannel | inidcates if the flexray monitored is (A or B or auto). this is required for CRC calculation testing because flexray uses different CRCs on channel a and b. |
highbaudrate | for swcan indicates the high baud rate that is used when switched |
highvoltagethreshold | for swcan is the voltage threshold used to detect transceivers operating in high voltage mode |
isinverted | indicates if the manual threshold detection is inverted |
idlebitcount | the number of quiet bit times either between messages or before decoding can start |
idlengthbits | for protocols that support it - this indicates the length of the ID in bits. the id is shown in the ID column and is used for database searching |
rearma | this is the voltage threshold for rearm of high voltage |
rearmb | this is the voltage threshold for rearm of low voltage |
spimode | the SPI mode indicates clock polarity and sampling position |
thresholdhigh | this the threshold for trigger when the waveform is rising |
thresholdlow | this is the threshold for trigger when waveform is falling |
uartstopbitcount | this is the count of stop bits for a uart decoder |
uartparity | this is the parity for for a uart decoder |

Table 3 - Scope Object Properties

Command | Description | example
capturetype | What channels should be collected |
couplinga | the type of coupling used on channel a |
couplingb | the type of coupling used on channel b |
couplingc | the type of coupling used on channel c |
couplingd | the type of coupling used on channel d |
capturelengthsamples | the length of the capture in samples |
capturerepeatmode | the type of capture mode : single, multiple, and filter match |
probeafactor | the mulitply factor of the probe used for cha |
probebfactor | the mulitply factor of the probe used for chb |
probecfactor | the mulitply factor of the probe used for chc |
probedfactor | the mulitply factor of the probe used for chd |
sampleratemicrosecondspersample | the requested sample rate in microseconds per sample |
specialtriggerbitrate | the rate used for the can error frame trigger |
sampleratefrequencyspec | indicates how the gui displays the sample rate |
triggersource | indicates the trigger source (0 - none, 1 - cha, 2 - chb, 3 - ext, 4 - chc, 5 - chd) |
triggervoltage | the absolute trigger voltage |
triggerdirection | sets the direction rising or falling |
triggerhystersis | hystersis in voltage |
triggerpercentage | sets the trigger point in precentage (pretrigger) |
triggertimeoutms | the time out if the trigger does not occur |
triggerspecialtype | sets a special trigger mechanism |
voltagerangea | sets the voltage range for channel a |
voltagerangeb | sets the voltage range for channel b |
voltagerangec | sets the voltage range for channel c |
voltageranged | sets the voltage range for channel d |

Table 4 - Analysis Object Properties

Command | Description | example
getscalar | returns one of the scalar properties by name | an(0).getscalar? framecount


Decoded Database Message Decoding

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

WaveBPS Basic Databases

WaveBPS supports a simple database that matches up a message with a text description and a source node (Figure 1). When enabled, the decoder will search for each event in the database and if it finds a match it will display the text description and the node description in the event list. Next, it will display this description on the zoom plot above the event. The database also enables node analysis.

The database is a text file where each line describes one event in the file. It includes the ID, ID Mask, Data, Data Mask, Name and source node (Figure 2). The ID is up to a 32 bit ID andthe ID mask is a 32 bit mask applied to the ID. Database matching is also supported on the data section up to 32 bits with the data and data mask properties. Finally the name and source node are the text descriptions used to identify the event name and node name.

Vehicle Spy software (rev412 and above) support exporting WaveBPS databases (Figure 3).

An example database is included at this link swcan.wvdb (open as a text file). Notice the extension of this database is "wvdb."

Database Information
Figure 1 - Database information is shown above the message and in the event list.

Database Format
Figure 2 - The simple database is a text file which describes the events and nodes in a network.

Vehicle Spy Export
Figure 3- Vehicle Spy can export WaveBPS databases.


Cursor Measurements

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Cursor Measurements

WaveBPS - has powerful cursors which allow you to do measurements. Cursors allow you to make time, voltage, time in bits, and bus utilization measurements (figure 1). The normal cursor appears in the zoomed view. A high resolution time measurement cursor is also available for measuring time across a large waveform.

Movie Cursor Measurement Video
Movie
Movie Watch Now

Cursors in the Zoom View
Figure 1 - The Cursors allow you to make time, voltage, and bus use measurements

You can change what the cursors measure by double clicking the tool tip or by using the cursor mode drop down (Figure 2).

Cursor Mode selection
Figure 2 - You can change the measurement mode of the cursor using this drop down.

The high resolution cursor allows you to make time measurements across the entire waveform capture. First, position the left cursor on the first time and click the "Set T1" button. Next, position the right hand cursor on the second time and click "Set T2". After this the high resolution time delta will be displayed to the right of the high resolution cursor buttons. Both T1 and T2 times will be displayed in the entire waveform view.

High Resolution Cursor

Figure 3 - The high resolution cursor can make accurate timing measurements.


Event List Columns

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Event List Columns

Each column in the event list represents an automatic measurement. This document describes each column present. Different decoders support different automatic measurements. Clicking on any automatic measurement will change zoom view to the time that measurement was made.

Table 1 - General Columns

Name | Description | Notes
TStart | Start time of the event. The icon signifies the channel and if there are any warnings or errors in this event. |
TWidth | The width of the event in time. |
T-IFS | The time since the last event. | Use for testing diagnostic response messaging which requires specific delays.
ErCnt | Indicates how many errors this event has | Use with filter to quickly find events that have errors
WrnCnt | Indicates how many warnings this event has |
ID |  |
Node | Name of the node sending this event (requires a data base) | When enabled with a data base this enables statistical node analysis on automatic measurements.
Data | shows the data for the event |

Table 2 - FlexRay Columns

Name | Description | Notes
Res | The FlexRay reserved bit |
PPI | Payload preamble indicator bit |
Null | Null frame bit |
Sync | sync frame bit |
Start | startup frame bit |
Ch | the flexray channel a or b |
H-CRC | the header crc |
CycCount | the current cycle count |
CRC | the CRC - will be different for channel a and b |
TSS (bits) | transmission start sequence measurement in bits |
Dyn | indicates whether this is a dynamic frame |
Len | Length of the data section in words |

Table 2 - CAN Columns

Name | Description | Notes
RTR | Remote transmit request bit |
IDE | Identifier extension bit |
RB0 | reserve bit 0 |
RB1 | reserve bit 1 |
HiV (SWCAN ONLY) | For single wire can this indicates the transmitter of the message is using the transceiver's High voltage mode |
HiAck (SWCAN ONLY) | For single wire can this indicates the ack bit is high voltage meaning at least one receiver is using the high voltage mode of the transceiver |
HiSpd (SWCAN only) | for single wire can this indicate the a high speed transition has occurred and is operating at the high bit rate |
SRR | Standard frame remote request bit |
Len | Length of data frame in bytes |
CRCDel | The CRC Delimiter space |
Ack | The acknowledgement bit |
AckDel | the acknowledgement delimiter bit |
CRC | The 15 bit CRC checksum |
Stuffs | how many stuff bits are present in the CAN message |
BitTol | The bit tolerance. The bits controlled only by the transmitter are measured between two recessive to dominant edges. This time is compared with the ideal bit time. |
MinV | Here a minimum voltage is measured across the bits controlled by the transmitter (after the ID and before the Ack bit) |
MaxV | Here a maximum voltage is measured across the bits controlled by the transmitter (after the ID and before the Ack bit) |
AckSkew | The measures the time difference between the ideal starting ack position and the actual one |
AckWidth | This measures the width of the ack bit |
DataPercent | This measures the payload percentage of the message. This is how much data was sent compared to how long the entire frame requires. |

Table 3 - LIN Columns

Name | Description | Notes
Brk(bits) | Length of sync break in bits |
Sync | value of the sync byte |
TSlvRsp | Time between the master header and the slave response |
THeader | Length of the master header in time |
TResponse | Length of the entire slave response |
TMaxUtil | This the length of the frame compared to the ideal length * 40% allowed by the LIN specification |
Len | This is the length of the frames data section. |
ChkSum | This is the checksum of the LIN message. Both standard and enhanced are calculated. |

Table 4 - J1850 VPW Columns

Name | Description | Notes
SOF | The length of the start of frame symbol in time |
Len | the length of the message in bytes |
CRC | The CRC check sum |
IFR | In-frame response data (chrysler implementation only) |

Table 5 - UART Columns

Name | Description | Notes
Brk(bits) | the number of bits of a UART break if present |
Len | the length of the data section |
Data (ASCII) | The data section represented as ascii characters |

Table 6 - I2C Columns

Name | Description | Notes
AddrLen | The length of the I2C address either 7 or 10 bits |
R/W | This indicates if it is an I2C write or read |
Address | This is the address of the message |
Len | This is the length of the data |


Setup Channels

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Setting up Serial Decoding in WaveBPS

WaveBPS can apply a serial decoder to a waveform channel (figure 1). The decoder will analyze the waveform, extract the frame data, and add them to the event list box. Each channel can have one decoder.

Decoder Channel Selection
Figure 1 - You can select any decoder for each channel.

Each decoder has settings which customize it to the waveform you are capturing. WaveBPS allows you to define as many decoders as you want. Each decoder can have different settings and a different custom description. For example, you could have many different dual wire CAN decoders such as CAN High, CAN Low, CAN Differential, and CAN Current Probe. The decoders are saved in the configuration file.
Movie Decoder Setup Video
 Movie
Movie Watch Now

There are two math decoders which require no setup. This includes A-B and A+B. These reduce a two channel capture to one channel capture that is the math result of both channels. A-B is very useful for differential captures such as CAN where ground offsets may drift by several volts. For channels C and D there is support for C-D and C+D.

Every decoder allows you to enter a specific baud rate. Alternately, you can have WaveBPS try to automatically determine the bit rate by selecting "Auto select baud rate from standard list".

Idle bus detection is the number of bit times of idle bus the decoder will wait before beginning decoding. For some protocols such as UART and SPI it uses this time to determine when messages groupings stop.

Decode error limit is the number of errors a decoder will allow before it quits decoding. If the error limit is reached WaveBPS will show a warning.

For noisy signals the decoder can apply a 3 point moving average filter. To enable this feature click "3 Point Thresholding Filter". This filter only applies to decoding and will not apply to any automatic measurements that use voltage as part of the calculation.

The decoder converts the analog waveform into a one or zero by thresholding - comparing the analog signal to a level. WaveBPS uses hysteresis to do this. This is required for slowly changing or noisy waveforms which could trigger multiple times as it crosses a threshold (Figure 2). With hysteresis the analog signal must exit a specific voltage band before the trigger is allowed to occur again.

Noisy CAN signal
Figure 2 - Here is a noisy CAN L waveform decoded perfectly with hysteresis.

WaveBPS can attempt to automatically threshold the waveform based on the min and max voltage. Sometimes, this is not adequate and you can specify the entire waveform. You can also invert the thresholding which is required for looking for the opposite transitions which would be present on the negative lines of differential waveforms.

WaveBPS supports a database which identifies events with a text description and source node. This text description is shown in the event list and the zoomed in view. This database is a simple text file that you can create with Notepad. Vehicle Spy software can also export this type of database after loading a DBC, VS3, UEF, LIN or FIBEX file.

Each decoder may have specific settings unique to that decoder. Table 1 below lists the settings and what there function is.

Decoder Settings
Figure 2 - Each decoder can be customized to your application.

Table 1 - Additional Decoder Settings

Setting | Description | Applies to
CAN Bit Tolerance | The bit rate tolerance limit of a CAN message. All decoded CAN frames are measured for there bit tolerance and compared to this limit. If outside the limit an error is added to the CAN message. | All CAN
SWCAN Enable GMLAN Auto switch Baud Rate | This enables the decoder to monitor for a GMLAN 3110 HS programming switch. | SWCAN
SWCAN Auto switch Baud Rate High | This is the new baud rate when the decoder decodes a valid GMLAN 3110 HS programming switch. | SWCAN
SWCAN High Voltage Threshold | This is the voltage threshold used to determine if the message was sent in high voltage mode | SWCAN
FlexRay Channel | This indicates what channel of FlexRay (A or B) was decoded. This is required for CRC calculation. Auto will calculate both and only error if it doesn't match one. | FlexRay
ID (bits) | This indicates how much of the first part of the data section is used for message identification. This part will be used in database look up. | I2C, UART, SPI, J1850 (8 or 24 only)
Bit Organization Order | This indicates the order of bits in the serial stream (most significant or least significant order) | UART, SPI
Bit Organization Byte Length (bits) | This indicates how many bits each unit is that is sent on the bus. | UART, SPI
UART parity | This indicates standard UART parity (more on wikipedia) | UART
UART stop bits | This indicates how many stop bits are used by the communications (more on wikipedia) | UART
SPI Mode | This indicates the relationship between the clock and data signals in SPI and indicates when the clock samples the data (more on wikipedia) | SPI
Additional Channels | The I2C and SPI decoders require you to select the channel for the Clock line | SPI, I2C


Test

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Loading custom data into WaveBPS - download example project Zip wavebpsimport.zip

WaveBPS - allows you to create your own support for importing data. Users can do this by creating a Windows DLL that implements two functions. One function allows WaveBPS to get information about the DLL. The other API does the import. All functions in the dll must use the __stdcall calling convention.

First, when the user clicks the open waveform (Figure 1 - bubble 1) button WaveBPS will search its install directory (where the exe is at) for an "import" subdirectory . For all the DLLs in the subdirectory it will call the function "WaveBPSImportGetInfo" (Figure 2) to find out what types of files the DLL supports and a description. The description is listed in the box of possible import types (Figure 1 - bubble 2).

' Import Process
Figure 1 - Clicking import will show the import data dialog listing the DLLs available for import.

Import API
Figure 2 - The WaveBPSImportGetInfo API allows WaveBPS to determine what types of Files the DLL supports.

If the user selects the import a file open dialog will be shown. If the user then selects a file the second API will be called - WaveBPSImportData. This is shown in figure 3 below. This function receives the FilePath selected by the users and three function pointers. One function pointer indicates the number of channels and buffer type information. Another function pointer is to set the buffer size required by the import data. The other allows the import to update the progress bar in the WaveBPS application.

The first callback sets up the number of channels (currently up to two channels is supported) and the data type. WaveBPS supports two data types. The first is a struct which defines a floating point time and voltage (iDatatype ==0). The second data type (iDatatype ==1) is a short array which has a constant time and voltage scaling (indicated by arguments dVoltsPerCount and dSampleRateInMicroseconds). The short array is more memory efficient for large data sets. dVoltsPerCount and dSampleRateInMicroseconds are ignored for iDataType==0.

Also shown in figure 4, one of the callbacks is to get the memory pointer for the data buffer WaveBPS will use. This API called SetBufferSize takes three arguments and returns the pointer to the buffer. The first argument is the channel number. The next argument is the size of the buffer and the other is a flag to indicate whether the existing buffer data should be preseved with the new buffer. It is recommended to use the preserve as little as possible for performance reasons. If for some reason WaveBPS cannot allocate the memory for the import the SetBufferSize function returns null.

The second call back is for updating the progress bar. There are two arguments - one is the an int indicating whether or not to show the progress bar and the other is the progress value from 0-100.

When datatype ==0, The pointer returned from SetBufferSize is a pointer to stWaveFormPoint structures otherwise its a short array. This includes the waveform values in voltages and times in microseconds. When datatype ==1 it is just a short array.

Import API 2
Figure 3 - The API function in the DLL that allows data to be loaded into WaveBPS.

Import API 3
Figure 4 - The API for loading uses these call back functions and one data strutures for getting data.

DLL DEF file

LIBRARY waveimpex.dll

EXPORTS
WaveBPSImportGetInfo @1 PRIVATE
WaveBPSImportData @2 PRIVATE

DLL Code Listing

#include <string>
#include <windows.h>
#include <fstream>
#include <map>
#include "wavebps.h"
#include "CMatlabBlock.h"

using namespace std;

/*
* WaveBPS plugin example.
* This will load .MAT files generated by PicoScope 6
* (c) 2008 Intrepid Control Systems, Inc.
* www.wavebps.com
*/

string ToString(const wstring & sStr)
{
string::size_type size = sStr.length() + 1;
char * temp = new char[size];

WideCharToMultiByte(CP_UTF8, 0, sStr.c_str(), size, temp, size, NULL, NULL);

string ret(temp);
delete [] temp;

return ret;
}

WAVEBPSEXPORT WaveBPSImportGetInfo(wchar_t* sDescription, wchar_t* sDialogFileSpec, int* piAPIVersion, int* piDLLVersion )
{
wsprintfW(sDescription,L"Matlab 4");
wsprintfW(sDialogFileSpec,L"Matlab 4 Files (.mat)|*.mat|");
*piAPIVersion = 1;
*piDLLVersion = 1;
return 1;
}

WAVEBPSEXPORT WaveBPSImportData(const wchar_t* sFilePath, SETBUFFSIZEPROC SetBufferSize, UPDATEPROGRESSBARPROC UpdateProgressBar,SETCHANNEL_BUFFERINFO SetChannelBufferInfo)
{
ifstream matfile( ToString( wstring(sFilePath) ).c_str(), ios_base::in | ios_base::binary );
if( matfile.fail() )
{
MessageBox(NULL,"Error reading in file","matimport",MB_OK);
return 0;
}

map< string, CMatlabBlock > matlabblocks;
UpdateProgressBar(1,0);
matfile.seekg(ios::end);
int filesize = matfile.tellg()*2; //double scale it so reading the file only goes up to 50%
matfile.seekg(ios::beg);
do
{
try
{
CMatlabBlock mblock( matfile );
matlabblocks.insert( pair<string,CMatlabBlock>( mblock.GetName(), mblock ) );
}
catch( CMatlabBlock::ReadFileError& rfe )
{
MessageBox(NULL,"Error reading in file","matimport",MB_OK);
matfile.close();
return 0;
}
catch( CMatlabBlock::GotEOF& eof )
{
continue;
}
catch(...)
{
MessageBox(NULL,"Error reading in file","matimport",MB_OK);
matfile.close();
return 0;
}
UpdateProgressBar(1, ((float)matfile.tellg()/filesize)*100);

} while( !matfile.eof() );
matfile.close();

//find the "A" channel
map< string, CMatlabBlock >::iterator it = matlabblocks.find(string("A"));
if( it == matlabblocks.end() )
{
MessageBox(NULL,"No data channel","matimport",MB_OK);
return 0;
}
CMatlabBlock& datachannel = it->second;

//what kind of timing is in the file? an array that matches up to the data or an offset and interval?
CMatlabBlock* timechannel = NULL;
double timestart, timeinterval;
it = matlabblocks.find(string("T"));
if( it == matlabblocks.end() )
{
//not an array, it's offset type
it = matlabblocks.find(string("Tstart"));
if( it == matlabblocks.end() )
{
MessageBox(NULL,"No timing data!","matimport",MB_OK);
return 0;
}
switch( it->second.GetHeader().DataFormat )
{
case Double:
timestart = *(double*)it->second.GetData();
break;
case Single:
timestart = *(float*)it->second.GetData();
break;
case Integer:
timestart = *(int*)it->second.GetData();
break;
}

it = matlabblocks.find(string("Tinterval"));
if( it == matlabblocks.end() )
{
MessageBox(NULL,"No timing data!","matimport",MB_OK);
return 0;
}
switch( it->second.GetHeader().DataFormat )
{
case Double:
timeinterval = *(double*)it->second.GetData();
break;
case Single:
timeinterval = *(float*)it->second.GetData();
break;
case Integer:
timeinterval = *(int*)it->second.GetData();
break;
}
}
else
timechannel = &it->second;

SetChannelBufferInfo(1,0, 0.0, 0.0);

stWaveformPoint* pPoints = (stWaveformPoint*) SetBufferSize(0, datachannel.GetHeader().NumberOfValues, false );

for( int i = 0 ; i < datachannel.GetHeader().NumberOfValues ; i++ )
{
double time;
float volt;
switch( datachannel.GetHeader().DataFormat )
{
case Double:
volt = ((double*)datachannel.GetData())[i];
break;
case Single:
volt = ((float*)datachannel.GetData())[i];
break;
case Integer:
volt = ((int*)datachannel.GetData())[i];
break;
}
if( timechannel )
{
switch( timechannel->GetHeader().DataFormat )
{
case Double:
volt = ((double*)timechannel->GetData())[i];
break;
case Single:
volt = ((float*)timechannel->GetData())[i];
break;
case Integer:
volt = ((int*)timechannel->GetData())[i];
break;
}
}
else
{
time = timestart + (timeinterval*i);
}

pPoints[i].dMicroseconds = time * 1000000;
pPoints[i].dVoltage = volt;

UpdateProgressBar(1, (((float)i/datachannel.GetHeader().NumberOfValues*2)*100) + 50 );
}

UpdateProgressBar(0,100);

return 1;
}


Exporting Waveform Data

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Exporting Waveforms from WaveBPS

WaveBPS allows you to export data many ways. This includes exporting the event list, the entire raw waveform, subsets of the waveform, picture files of the waveform, and log files compatible with Vehicle Spy software. You can also copy the event list or scalar list to the clipboard for transfer to other applications.

Exporting a Waveform Picture
Figure 1 - WaveBPS can export pictures very simply.
Movie Exporting Data Video
Movie
Movie Watch Now

Clicking on the save button shows a drop down allowing you to export the waveform many different ways (figure 2). First, the Vehicle Spy buffer exports a waveform that is compatible with the Vehicle Spy software. Next you can export the raw waveform as either the zoom view (a subset) or the entire view. Finally, you can also export the event list.

If you export the raw waveform you can save either a wbps file or a wbpx file. The wbps is a binary file which you can later open with WaveBPS . The file format is open and is described in this topic. The wbpx file is special output file that allows you to open the waveform with the trial version of WaveBPS. The wbpx file output is great for sharing waveforms.

Another option for raw waveform export is CSV. The CSV file format is the most portable format but it is very inefficient. So storing a 128 MSample waveform will take a huge amount of space. The CSV is only recommended for smaller waveforms or subset waveforms.

If you select "Filtered event list" you will save the event list. It will not save the entire list though if you have a filter. If you have a filter only the items that match the filter will be saved.

Export Options
Figure 2 - WaveBPS offers different ways to export data.

You can quickly copy the scalar list or the event list by right clicking and selecting copy (figure 3).

Right Click menus for the scalar list and event list
Figure 3 - WaveBPS can copy the scalars to the clipboard.

You can also modify the waveforms before you export them (figure 4). This allows you to create waveforms with disturbances that you may then load into an arbitrary waveform generator.

Export and Modify
Figure 4 - WaveBPS can export waveforms and modify them to create errors.


Scalar Measurements

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Scalar Measurement List

The scalar list is a list of measurements that are made on the entire capture (figure 1). These maybe different for each decoder. You can copy the scalar list to the clipboard using its right click menu. You can also access these scalars remotely with the Text API.

Scalar Measurment List
Figure 1 - The scalar measurement list includes measurements on the entire capture.


Licensing WaveBPS

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Licensing WaveBPS

WaveBPS - is offered in three versions: trial, limited, and professional. The trial is freely distributable and can open waveforms exported from any version. The limited works with 32K and smaller waveforms where the professional can work with waveforms of any size.

Part Number |  | Description | Price | Features
WAVEBPS-PRO-SFT | BUY NOW | WaveBPS Software license | $795 | Contains all protocol decodes and support for unlmited waveform size
WAVEBPS-LTD-SFT | BUY NOW | WaveBPS Embedded Limited Software license | $295 | Contains all protocol decodes and support for 32K limited waveform size


WaveBPS wbps binary format

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

WaveBPS "wbps" binary file format

WaveBPS uses a binary file format to efficiently store its raw waveform files. This document describes the file format enough for third parties to read and write the files. These files have the extension "wbps". These formats are created in Intel big endian byte order.

Internally, the WaveBPS wbps file is actually two main formats. First is the floating point format and the other uses an unsigned short (16 bits). The unsigned short is considerably smaller and is used when possible. When not possible, such as when a waveform was originally loaded from a csv file, the floating point format is used. The parser for the wavebps file can determine which file type it is by reading the file header. The short format is always used when capturing from an oscilloscope.

The file header is always 16 bytes. The header will be one of the two following possibilities (Table 1):

Table 1 - Possible 16 byte headers

Type | Header
Double Precision Floating Point | char szverion5 [] = {'w','a','v','e','b','p','s','5','0','0',0,0,0,0,0,0};
Unsigned Short (16 bits) | char szverion6 [] = {'w','a','v','e','b','p','s','6','0','0',0,0,0,0,0,0};

Following the header is a 4 byte integer describing the number of channels (Table 2). This is the same for both formats.

Table 2 - Number of Channels

Type | Header
Unsigned int (32 bits) | m_iNumberOfChannels

After the number of channels, the file formats diverge and are described in separate topics.

Follow this link for the double precision floating point topic.

Follow this link for the unsigned short topic.


WaveBPS wbps double format

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

WaveBPS "wbps" Double Precision Floating Point Type

After the number of channels described in the parent topic. The floating point format includes a 4 byte integer describing the offset to the data (Table 1). You can use the offset to set the file position to the start of the data. Using the offset, the number of raw data samples in the file can be calculated with this equation. (You probably want to cast each item in the equation to an __int64 considering the files sizes can be very large)

NumberOfDataValues = (SizeOfFile() - m_iOffsetToTheData) / (sizeof(double) * (1+m_iNumberOfChannels))

Table 1 - Offset to the data

Type | Header
Unsigned int (32 bits) | m_iOffsetToTheData

At the offset there is one double precision float (8 byte value) describing the time, and then one double precision float for each channel at that time. This repeats for every data sample. The time is in microsecond units while the channel data is in volts.

For reading the wbps format the above information is the minimum needed to use the format. For writing the format you must have the following information as well.

After the offset integer are two parameters that describe the trigger (Table 2). First is a unsigned integer that indicates whether there is a trigger location present in the file. This will be either 0 meaning no trigger or 1 meaning a trigger is present. Following the trigger is a double precision parameter indicating where in microseconds the trigger exists (this must be present if a trigger is valid or not).

Table 2 - Trigger Information in File

Type | Header
Unsigned int (32 bits) | m_iHasTriggerLocation
Double Precision Floating Point (8 bytes) | m_dTriggerLocationInMicroseconds

Following the trigger is information about the decoders used when the file is saved. The decoder is stored as a convenience in the wbps file so when it is loaded it will be properly displayed (very useful when sharing waveforms).

The file format for the decoders will not be described here. For readers of the file format this data can simply be ignored. For writers of this format, you can write a signed integer equal to -1 for each channel and WaveBPS will simply ignore the decoder section when it reads the file (Table 3).

Table 3 - Decoder Ignore Sequence (repeat for each channel)

Type | Header
Signed int (32 bits) | iDecoderType (set to -1)


WaveBPS wbps short format

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

WaveBPS "wbps" unsigned short

After the number of channels described in the parent topic, the short type includes the multipliers for each channel and the sample rates at which the data was captured. This is repeated for each channel (Table 1).

Table 1 - Multipliers for Time and Voltage (repeated for each channel)

Type | Header
Double Precision Float (8 bytes) | m_dSampleRateInMicroseconds
Double Precision Float (8 bytes) | m_dVoltsPerCount

After the multipliers, a 4 byte integer describing the offset to the data (Table 2). You can use the offset to set the file position to the start of the data. Using the offset, the number of raw data samples in the file can be calculated with this equation. (You probably want to cast each item in the equation to an __int64 considering the file's size can be very large)

Numbered = (SizeOfFile() - m_iOffsetToTheData) / (sizeof(short) * (m_iNumberOfChannels))

Table 2 - Offset to the data

Type | Header
Unsigned int (32 bits) | m_iOffsetToTheData

At the offset there is one short (2 byte value) for each channel. This repeats for every data sample. The time is in microsecond units multiplied by the offset.

Table 3 - Voltage and Time for each sample

Type | Header
Time (in microseconds) | m_dSampleRateInMicroseconds * ((double) iIndexOfSample)
Voltage (in volts) | m_dVoltsPerCount * ((double) iShortData)

For reading the wbps format the above information is the minimum needed to use the format. For writing the format you must have the following information as well.

After the offset integer are two parameters that describe the trigger (Table 4). First is a unsigned integer that indicates whether there is a trigger location present in the file. This will be either 0 meaning no trigger or 1 meaning a trigger is present. Following the trigger is a double precision parameter indicating where in microseconds the trigger exists.

Table 4 - Trigger Information in File

Type | Header
Unsigned int (32 bits) | m_iHasTriggerLocation
Double Precision Floating Point (8 bytes) | m_dTriggerLocationInMicroseconds

Following the trigger is information about the decoders used when the file is saved. The decoder is stored as a convenience in the wbps file so when it is loaded it will be properly displayed. This feature is very useful when sharing waveforms.

The file format for the decoders will not be described here. For readers of the file format this data can simply be ignored. For writers of this format, you can write a signed integer equal to -1 for each channel and WaveBPS will simply ignore the decoder section when it reads the file (Table 5).

Table 5 - Decoder Ignore Sequence (repeat for each channel)

Type | Header
Signed int (32 bits) | iDecoderType (set to -1)


CAN Bus

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

CAN Bus

CAN Bus is the dominant protocol for networking electronics in vehicles. It features a bit rate up to 1 Mbit and offers simple networking of microcontrollers with the help of dedicated CAN bus silicon called a CAN Controller.

The data transfer message of CAN is the data frame. This data frame is allowed to have a longer ID and is then called an extended data frame.

Used in some applications but not in automotive is the remote frame. The remote frame allows a node to request a particular CAN ID.

CAN is very robust. This means it can not only detect many errors but can take action such as automatic transmission or node shut down.

CAN uses the bit stream to resyncronize the receivers to the transmitter. In order for this to work with specific bit sequences CAN must use bit stuffing. Bit stuffing makes decoding a CAN waveform on a traditional oscilloscope difficult.

CAN is a data link layer. To signal CAN electrically there are three common physical layers in use.

In some applications where CAN is used FlexRay or LIN may provide advantages.

The CAN bus Specification from Bosch: PDF can2spec.pdf

CAN Bus Frame
A CAN Bus Data Frame.


CAN Bus Bit Stuffing

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

CAN Bus Bit Stuffing

The CAN waveform is a series of bits. Since there is no clock shared between the CAN bus nodes there must be a way for all nodes to get the clock from the waveform. Therefore receivers use transitions in the CAN waveform to synchronize the receiver clocks to the transmitter.

To ensure there are enough transitions the CAN bus implements bit stuffing. Bit stuffing places a extra opposite bit of the current bit after 5 consecutive identical bits. Since the appearance of stuff bits depends on message content the length of CAN frame will vary depending on the data in it. These extra stuff bits are automatically thown away by the receiver so the application software in the CAN node never sees them.

CAN Stuff Bits
The stuff bits, highlighted in yellow, add overhead to a CAN Message. This message has 13 extra stuff bits.


CAN bus data frame

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

CAN Bus Data Frame

The CAN bus data frame does the work on CAN. The whole point of CAN is to send data between networked controllers - and that is the job of the data frame.

The data frame begins with a single SOF (start of frame) bit and is followed by the CAN Identifier. The CAN Identifier is used to identify the message and the node the message is coming from. The identifier can be either 11 bits long or 29 bits long depending on the state of some reserved bits.

SOF and CAN ID
The CAN Data Frame Starts with a SOF bit and then ID bits.

After the CAN Identifier, there is a data section that first begins with a data length. The CAN data frame can have 0 to 8 bytes so it uses 4 bits to encode length. The data bytes directly follow the data length.

CAN DLC and Data Bytes
The data bytes follow the data length (DLC) in the CAN Frame.

Following the data is the CRC. The CRC is a calculation that is made on the first part of the CAN frame by both the receiver and transmitter. If they match the receiver assumes that it received the data correctly.

CAN CRC and ACK
The CAN CRC checks data integrity while the ack indicates reception by another node.

Following the CRC is the Ack field. This field will be set by all other nodes on the network who properly received the frame.

After the Ack bit there will be a quiet time called end of frame space followed by a minimum inter-frame space.

Picture of a CAN data frame

Policy - WaveBPS is a trademark of Intrepid Control Systems, Inc.


CAN Bus Errors

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

CAN Bus Errors

The CAN protocol automatically handles protocol errors in hardware - this is what makes CAN robust. If a CAN node receives a message with an error it can destroy the message and cause the transmitter to resend. The CAN node destroys the message by sending an error frame (see the picture below).

CAN bus nodes can detect errors in different ways. For example, a CRC checksum error occurs when the receiver calculates a checksum different than what it received. This means the receiver didn't receive what the transmitter sent. When the CRC error happens a receiver generates an error frame and this causes the transmitter to retransmit the message.

The error frame is six to twelve dominate bits (zeros) and directly violates the bit stuffing rules of CAN. After the dominant bits and passive eight bit delimiter is sent followed by and inter frame separation time (IFS).

The CAN node keeps track of how many times it received or transmitted error frames using error counters. When these error counters reach certain limits the CAN node is first partially disabled (error passive mode) and then totally disabled (bus off mode). This avoids the possibility that a broken node disabling the bus by constantly generating error frames. There are specific rules about how these error counters are incremented or decremented - please consult the CAN spec for details.

CAN Error Frame
When an error occurs on the CAN bus an error frame is generated. This is a frame with 6 or more dominant bits followed by a idle bus delimiter. See a bigger picture.


CAN Bus Extended Identifier

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Extended Data Frames

Extended identifier CAN Frames use 29 bits for identification purposes instead of 11 for the standard can frame. Because this extra ID space adds 20 bits of overhead (18 ID and 2 reserved) it is usually not used by networks which want the highest performance.

In the J1939 and GMLAN protocols, the larger ID is segmented into different parts with each part having meaning. For example the least significant 8 ID bits for both J1939 and GMLAN indicate a node's source address.

Extended ID
This Single Wire CAN extended ID is 29 bits long (not counting the stuff bits). Many system designers do not use this ID length because of all the overhead it requres.


CAN Bus Physical Layers

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

CAN Bus Physical Layers

The CAN protocol describes how 1s and 0s are used to communicate. The CAN protocol does not describe an electrical way to signal these 1s and 0s. This is what CAN physical layers are for.

The most prevalent physical layer is called the dual wire physical layer. This physical layer uses two wires CAN H and CAN L. These wires send the same 1 or 0 just in different voltage directions (differential signalling).

Two other physical layers were introduced for specific automotive low speed applications. They are single wire can and low speed fault tolerant CAN. The low speed fault tolerant bus provides fault tolerance if one line breaks. The single wire can bus provides CAN over a single wire and provides a unique wakeup mechanism where a subset of nodes can communicate without waking up sleeping nodes.


CAN Bus Remote Frames

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

CAN Bus Remote Data Frame

CAN bus remote frames are optional frames used to request data. Remote frames contain no data section even though the data length code can be greater than zero. You can determine if a frame is a remote frame from the state of the RTR bit (RTR=1). Remote frames are typically not used in automotive applcations.

CAN Remote Frame
Here a remote frame is shown on a CAN L waveform


CAN Bus Single Wire CAN

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Single Wire CAN

Single wire CAN is a physical layer that was created by General Motors. It allows CAN communication using a single wire at low bit rates such as 33.3 Kbps. It allows a high speed mode for flash programming. Finally, while most can transceivers offer only a 1 or 0, single wire can offers a third state called high voltage mode. This mode enables selectable power management of CAN nodes.

Single Wire CAN Voltages
This shows two different Single Wire CAN frames. One transmitted in high voltage mode and the other the normal voltage.


FlexRay

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

FlexRay

FlexRay is a new protocol designed for time deterministic, high speed, and/or safety critical applications. FlexRay nodes can only transmit at very specific times according to the design of the network. FlexRay has the ability to absolutely guarantee latency using static frames or offer more efficient bandwidth usage via dynamic frames.

FlexRay Timing is Perfect
Here FlexRay Messages captured with Vehicle Spy show a standard deviation of 0 on periodic rate transmission.

Since all transmit in FlexRay is based on time everyone on the bus must have the same clock. Therefore a startup procedure is defined that allows all nodes in the network to become synchronized. After startup, constant resyncronization takes place.

FlexRay also supports power management via a wake up mechanism. Sleeping nodes can wake up up on an external input and perform signaling on the FlexRay bus to wake up all other nodes.

The FlexRay physical layer signals 1's and 0's of the FlexRay protocol. It also offers a third state of idle bus.

FlexRay has advantages over CAN and LIN for fault tolerance, speed, and time determinism. FlexRay has disadvantages including complexity, cost, EMC, and the lack of experienced FlexRay engineers.

Visit the FlexRay Consortium Website

Policy - WaveBPS is a trademark of Intrepid Control Systems, Inc.


FlexRay Dynamic Frame

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

FlexRay Dynamic Frame

While time deterministic messaging is a major goal of FlexRay, FlexRay also offers a less restrictive event based communication. Here dynamic frames serve a role and put the "Flex" into FlexRay. As part of the time division of the network the FlexRay network provides times at which dynamic frames can be sent.

Unlike a static frame which requires a reserved time, dynamic frames can be sent out when necessary and their reserved time is shared with other dynamic frames. Supporting dynamic frames is an optional feature of FlexRay and is up to the system designer.

Picture of a dynamic frame

Policy - WaveBPS is a trademark of Intrepid Control Systems, Inc.


FlexRay Static Frame

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

FlexRay Static Frame

In FlexRay there are two possible ways to transmit data, static frames and dynamic frames. The frames are nearly identical in shape. The difference is when they are allowed to be transmitted. During network design the static frame is engineered to be sent always at specific times. This "static" behavior gives the network time deterministic features. For example, the network designers can ensure a particular variable is always updated exactly every 2 milliseconds.

Picture of some static frames

CRC of A and B Channel
The above picture is the two CRCs overlaid of an identical frame sent on both A and B FlexRay Channels. Notice the CRCs are different.


FlexRay Startup

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

FlexRay Startup

The FlexRay startup process involves getting all the nodes from not communicating to communicating. This involves specific nodes, called cold start nodes, to begin the communication in a specific way to get the network time synchronized. After this procedure the normal FlexRay communication begins.

When a node determines that both FlexRay channels have woken up, the leading cold start node will issue the Collision Avoidance Symbol (CAS) as shown below. Also shown below, the leading cold start node will begin its communication cycle starting with cycle 0. After enough cycles occur the other cold start nodes will time synchronize to the leading cold start node and begin their communication cycles. After the cold start nodes other non cold start nodes join and the normal FlexRay cycle begins.

FlexRay Start CAS symbol
Here a FlexRay startup is shown with a Leading cold start node generating the CAS and first few cycles with the second node joining the network on cycle 4.


FlexRay Wakeup Symbol

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

FlexRay Wakeup Symbol

FlexRay supports power management wakeup using the wakeup symbol. This wakeup symbol is repeated a fixed number of times. The wakeup symbol only pulls the bus in one direction and this avoids a possible contention that could occur if another node sent the pattern at the same time.

FlexRay Single Wakeup
The wakeup pulse is only one direction which allows possible collisions

FlexRay Wakeup
The wakeup symbol is repeated a number of times as part of the FlexRay cluster configuration

Wakeup Cluster Configuration
Here the number of wakeup symbols is part of the FlexRay cluster configuration


FlexRay Physical Layer

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

FlexRay Physical Layer

The FlexRay physical layer uses differential signaling to communicate flexray frames. Unlike CAN and LIN the FlexRay physical layer does not allow multiple nodes to drive the bus simultaneously. Also, in FlexRay, the bus voltages are different for a 0, 1, and idle bus.

FlexRay Physical Layer
The FlexRay Physical Layer uses a differental waveform to signal data.


 FlexRay versus CAN Bus


CAN bus at 70% utilization 120 megasamples

 120 Megasamples of CAN


CAN Bus Waveform Decoding

 CAN Bus Decode


 FlexRay Dynamic Frame


 LIN Bus Decode


Low Speed Fault Tolerant CAN Waveform

 Low Speed Fault Tolerant Waveform


LIN Bus

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

LIN Bus

LIN Bus is a low speed network that focuses on ulta low cost low speed (5-20 Kbits) applications. It is UART based and provides time deterministic messaging via LIN Frames.

LIN Frame
The UART based LIN Frame is consists of a break, break sync, ID, Data bytes and checksum.

The LIN Bus uses a master node to control all communications. Unlike any other protocol, the LIN protocol frame can be composed of data from two separate nodes. The LIN master node supplies the first half of the message consisting of the Break, Sync field and ID. The rest of the frame is filled in by either the master node or slave node depending on the ID.

There are different errors that can occur on a LIN bus including problems with break, sync field, checksum, timing and the unresponsive nodes.

LIN's advantage over CAN and FlexRay is primarily cost. Time determinism is also a major advantage over CAN bus. LIN's relative slowness is the primary disadvantage.

Link Visit the LIN Consortium Website

Policy - WaveBPS is a trademark of Intrepid Control Systems, Inc.


LIN Errors

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

LIN Errors

There are many possible errors in the LIN protocol. Some of them include: 1) the frame taking too long, 2) a checksum error, 3) sync problems, and 4) LIN ID parity. Also, unlike CAN and FlexRay, the LIN protocol is almost always written as a software driver. Therefore, application issues, such as disabling interrupts, can cause intermittent timing errors.

LIN Checksum Error
Here a LIN Checksum error indicates that something is not correct in the data section.


LIN Frame

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

LIN Frame

The LIN Frame consists of the LIN Header and the LIN slave respnose. The header is always transmitted by the master node while the slave response is filled in by either a Slave Node or the Master node.

Picture of a LIN frame

Policy - WaveBPS is a trademark of Intrepid Control Systems, Inc.


LIN Header

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

LIN Header

The LIN Header is the first part of the LIN Message. It begins with a sync break, followed by a sync waveform and then the LIN identifier. After this portion of the message, the ID indicates which node should respond with the slave part of the message.

The Sync break is a UART break that is low for 13 or more bits. All LIN devices see this symbol as the start of a message as it is a special symbol that forces a UART frame error.

LIN Break
Sent by the master node, the LIN Break indicates the start of a LIN Frame

After the Sync break is the sync waveform. The sync waveform is always the UART byte 0x55. This byte, as you can see from the the picture below, is an alternating sequence of 1's and 0's. This waveform allows the slave devices to calibrate their UART clock to that of the master. This allows cost savings in slave devices using a time and temperature dependant, but cheap R-C Oscillator.

LIN Sync Byte
The sync byte is always hex 0x55 and can be used by slave devices to calibrate their clocks

After the Sync byte is the LIN ID. The LIN ID consists of 6 ID bits and 2 parity bits. The parity bits are calculated according to the LIN Specification. Normally, parity bits are pre-calculated for receivers and transmitters. When an ID is referenced including the parity bits it is called the "protected ID" - the normal LIN ID is without the parity bits. For example, the LIN ID shown below is the LIN ID 0x01 with a protected ID of 0xC1.

LIN ID
The ID indicates what data needs to sent in the data section and includes parity bits.


LIN Slave

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

LIN Slave Section

The LIN Slave section includes the data of the LIN frame followed by the checksum. The slave section follows the LIN Header part of the LIN Frame.

LIN Data Section
The LIN Data section includes up to 8 data bytes

After the data section is the checksum. The checksum will vary based on the LIN specification. LIN supports both a classic and enhanced checksum. The classic checksum uses all the databytes while the enhanced also includes the ID.

LIN Checksum
The LIN Checksum is the last part of the LIN frame.


Other buses

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Other Buses

Besides CAN, LIN, and FlexRay other buses are used in embedded applications. For vehicle applications, J1850 has been a popular protocol for many older vehicles in North America. I2C and SPI bus are used internally in ECUs. UART based protocols are very popular with implementations such as J1708, Keyword 2000, ISO9141, GM CGI, K-Line, and RS232.


UART

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

UART: K-Line, J1708, ISO9141, GM CGI, RS232

The UART is a very common serial protocol. This type of serial communications is used for the popular RS232 protocol. Also, because of its wide availablity and low cost it is used in many automotive protocols such as J1708, ISO9141, K-Line, GM CGI, and RS232. More at Wikipedia.

K Line Data
The UART byte begins with a stop bit, data follows and ends with one or more stop bits (click for a larger picture)


SPI

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

SPI bus

SPI bus is a peripheral interface used for communications between devices in embedded electronics.. More at Wikipedia.

SPI Bus Waveform
The SPI Bus is used for embedded device communications (click for larger image).


I2C

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

I2C or SMBus

I2C or SMBus bus is a peripheral interface used for communications between devices in embedded electronics. More at Wikipedia.

I2C Data Capture
The I2C Bus uses two lines to communicate bi-directional data. (click for a larger picture).


J1850

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

J1850

J1850 is an older protocol used by North American manufactures for Vehicle networking. More information on J1850 can be found in the SAE J1850 specification from SAE.org.

J1850 Data Waveform
This J1850 waveform from a Chrysler vehicle supports a 1 byte IFR section. (click for larger picture)


FlexRay CAN LIN Comparision

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Compare FlexRay, CAN bus and LIN Bus

FlexRay, CAN Bus, and LIN bus are very different protocols and fit very different applications. Therefore, it is very unlikely that any of these protocols will replace the other. For example, the FlexRay protocol was designed for specific time deterministic applications with fault tolerance and may replace CAN in applications such as safety, chassis, and powertrain but not in body or diagnostics.

CAN and FlexRay Frames
FlexRay is faster than the CAN bus. Here we can see a 32 byte FlexRay 10 MBit frame taking just a fraction of a 500Kbits CAN frame. View a large image.


Movies

Importing data in to WaveBPS

Using Cursors in WaveBPS

Live Capture with WaveBPS

Navigation with WaveBPS

Exporting Data From WaveBPS

Text API Demo

Node analysis

Decoder Setup


Specificatons

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Specifications

WaveBPS Application

  • TCP/IP Server Text API allows remote control of application via Windows Clients and Vehicle Spy Function Blocks
  • Open DLL import support allowing importation of any waveform data from any source
  • Export support for raw analog waveforms including efficient binary formats (fully open and documented) and CSV for both entire waveform or subset of waveform
  • Export to Vehicle Spy buffer format
  • Modification of waveform within software to create improper waveforms for error testing with Arbitrary Waveform Generators
  • Import and Export WaveBPS XML configuration files
  • Node Analysis can prepare statistical analysis of all network nodes for all decoders and automatic measurements
  • Acquisition Modes include Single, Multiple, and Filter Match Capture. Filter Match capture is a multiple capture that stops when there is a filter match.
  • Automatic buffer capture mode saves buffer every time a filter condition is matched
  • Automatic Wave file playing on a filter condition
  • Cursor Modes allow measurement of : Delta Time in Second, Delta Time in Bits, Frequency, Delta Volts, Absolute Volts, and Bus Utilization
  • High Resolution Cursor allows very fine cursor control for measure across large captures
  • Auto scroll waveform based on Bit rate or Event with programmable rate
  • Search, Browse and Filter based on any automatic measurement
  • Powerful Mouse wheel based waveform navigation with optional knob

Hardware Support

  • Support of PicoScope 5000, PicoScope 4000, Picoscope 3000, and PicoScope 2000 series oscilloscopes: Programmable Capture and Depth, 4 Channel Support, Oscilloscope probes, Triggering, CAN Error Frame Trigger, External Trigger Modes, and Pre trigger depending on the scope model.
  • Support of neoVI FIRE and ValueCAN3 devices for advanced protocol triggering
  • Support of Space navigator 3D six axis knob

All Decoders

  • All Automatic Measurements include the time at which they were taken and clicking on the measurement will focus the zoom view on the times
  • Automatic Measurements for every event: Time Start, Time Width, Inter frame Separation, Error Count, Warning Count, ID including message description, and Node Name
  • Database support with import from Vehicle Spy software (UEF, DBC, VS3, LDF, FIBEX, etc...)
  • User specified Baud Rate and thresholds including inversion
  • Decoder Templates allow multiple customizations of each decoder with a custom description
  • Supports Math Operations on multiple channels (A-B, A+B, C-D, C+D)

CAN Decoder

  • Automatic Measurement for every message: CAN Remote Transmit Request, CAN Identifier Extension Bit, CAN Reserved Bit Zero, CAN Reserved Bit One, Single Wire CAN High Voltage Message, Single Wire CAN High Voltage Ack Bit,Single Wire CAN High Speed Mode Bit Rate, CAN Substitute Remote Request, Length (DLC), CAN CRC Delimiter, CAN Ack Slot, CAN Ack Delimter, CRC Checksum, CAN Stuff Bit Count,CAN Data Section, CAN Bitrate Tolerance , Minimum Frame Voltage, Maximum Frame Voltage, CAN Acknowledgement Bit Skew, CAN Acknowledgement Bit Width, Error Frame Bit Count, Percentage of Time Used For Data
  • Error & Warning Detection for every message: SRR = 0 Error, RB0 = 1 Error, DLC > 8 Error, Invalid CRC Error, CRC Del = 0 Form Error, Ack Error, ACK Del = 0 Form Error, EOF = 0 Form Error,IFS = 0 Form Error,RB1 = 1 Error,RB0 = 1 Error, Bit Tolerance Limit Error, High Voltage Ack Bit warning, Partial Frame Decode Warning, Error Frame
  • Automatic Measurements for entire waveform : Frame Count, Error Count, Idle Bus Mean Voltage, Max Frame Voltage, Min Frame Voltage, Bus Utilization, Error Frame Count
  • GMW3110 Single Wire CAN HighSpeed mode transition decoding
  • Single Wire CAN High Voltage Threshold setting
  • User settable Bit tolerance
  • Satisifies bit tolerance measurments as indicated in GMW14241 - GMLAN Device Test Specification

LIN Decoder

  • Automatic Measurement for every message: LIN Sync Break In Bits, LIN Sync Waveform, LIN Slave Response Time, LIN Header Time, LIN Slave Message Time, LIN TMax Utilization, LIN Frame Length, LIN Check Sum, Data
  • Error & Warning Detection for every message: TResponse Max Error, Message Length Error, TMax violation Error, Checksum Error, Slave Not Responding Error, Sync Error, THeader Max Error, ID Parity Error, Break Too Short, Break Too Long, Partial Frame Decode Warning
  • Automatic Measurements for entire waveform : Frame Count, Error Count

FlexRay Decoder

  • Automatic Measurement for every message: FlexRay Reserved Bit, FlexRay Payload Preamble Indicator, FlexRay Null Frame Indicator, FlexRay Sync Frame Indicator, FlexRay Startup Frame Indicator, FlexRay Channel, FlexRay Header CRC, FlexRay Cycle Count, CRC, FlexRay Transmission Start Sequence Length, FlexRay Is Dynamic Frame, Data Length in words, Data Section, Min Frame Voltage, Max Frame Voltage, Min Idle Voltage, Max Idle Voltage
  • Error & Warning Detection for every message: Header CRC Error, CRC Error, Partial Frame Decode Warning
  • Automatic Measurements for entire waveform : Frame Count, Error Count
  • Automatic A-B channel detection or fixed channel setting for decoder

UART Decoder

  • Automatic Measurement for every message: UART Break In Bits, UART Frame Length, Data Section, Data Section in ASCII
  • Error & Warning Detection for every message: Partial Frame Decode Warning, Parity Error
  • Automatic Measurements for entire waveform : Frame Count, Error Count
  • Break UART Streams into messages based on IDLE bit times
  • Supports programmable Bit Length, Parity, Stop Bits, Bit ordering, and ID length

J1850 VPW Decoder

  • Automatic Measurement for every message: J1850 Start of Frame (SOF) Time in Microseconds, Frame Length, CRC, In-Frame Response Data, Data Section
  • Error & Warning Detection for every message: CRC Error, Partial Frame Decode Warning
  • Automatic Measurements for entire waveform : Frame Count, Error Count
  • Programmable ID length (1 or 3 byte) setting for the decoder

SPI Decoder

  • Automatic Measurement for every message: Length of Data, Data Section
  • Error & Warning Detection for every message: Partial Frame Decode Warning
  • Automatic Measurements for entire waveform : Frame Count, Error Count
  • Programmeable SPI Mode, word length, ID length and endianess

I2C Decoder

  • Automatic Measurement for every message: I2C Address Length, I2C Read Write Bit, I2C Address, Length of Data, Data Section
  • Error & Warning Detection for every message: Ack Error, Partial Frame Decode Warning
  • Automatic Measurements for entire waveform : Frame Count, Error Count


blank.html - Needed for Internet Explorer's hidden IFrame


CAN bus Error Frames

 CAN Bus Errors


Download Decoding Software

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Download Form

Download

Please enter the following information in order to download the WaveBPS trial edition.


Download Form

Download

Please enter the following information in order to download the WaveBPS trial edition.


Test

Navigation Live Capture Cursors Importing Exporting Decoder Setup Analysis Automated Test Specifications
Static Frame Dynamic Frame Wakeup Startup Physical Layer Compare To CAN and LIN
Data Frame Extended Frame Remote Frame CAN Bus Errors Bit Stuffing Physical Layers Single Wire CAN Compare To FlexRay and LIN
LIN Frame LIN Header LIN Slave Part LIN Errors Compare to CAN and FlexRay
UART: K-Line, J1708, RS232 J1850 SPI I2C

Policy - WaveBPS is a trademark of Intrepid Control Systems, Inc.


WaveBPS Cursors Demo

The Camtasia Studio video content presented here requires JavaScript to be enabled and the latest version of the Adobe Flash Player. If you are you using a browser with JavaScript disabled please enable it now. Otherwise, please update your version of the free Adobe Flash Player by downloading here.


WaveBPS Decoder Setup

The Camtasia Studio video content presented here requires JavaScript to be enabled and the latest version of the Adobe Flash Player. If you are you using a browser with JavaScript disabled please enable it now. Otherwise, please update your version of the free Adobe Flash Player by downloading here.


WaveBPS Node Analysis

The Camtasia Studio video content presented here requires JavaScript to be enabled and the latest version of the Adobe Flash Player. If you are you using a browser with JavaScript disabled please enable it now. Otherwise, please update your version of the free Adobe Flash Player by downloading here.


WaveBPS Text API Demo

The Camtasia Studio video content presented here requires JavaScript to be enabled and the latest version of the Adobe Flash Player. If you are you using a browser with JavaScript disabled please enable it now. Otherwise, please update your version of the free Adobe Flash Player by downloading here.


WaveBPS Export Demo

The Camtasia Studio video content presented here requires JavaScript to be enabled and the latest version of the Adobe Flash Player. If you are you using a browser with JavaScript disabled please enable it now. Otherwise, please update your version of the free Adobe Flash Player by downloading here.


WaveBPS Navigation Features

The Camtasia Studio video content presented here requires JavaScript to be enabled and the latest version of the Adobe Flash Player. If you are you using a browser with JavaScript disabled please enable it now. Otherwise, please update your version of the free Adobe Flash Player by downloading here.


WaveBPS Software For Decoding CAN bus, LIN Bus, FlexRay and others

The Camtasia Studio video content presented here requires JavaScript to be enabled and the latest version of the Macromedia Flash Player. If you are you using a browser with JavaScript disabled please enable it now. Otherwise, please update your version of the free Flash Player by downloading here.


Live Capture Demo WaveBPS

The Camtasia Studio video content presented here requires JavaScript to be enabled and the latest version of the Adobe Flash Player. If you are you using a browser with JavaScript disabled please enable it now. Otherwise, please update your version of the free Adobe Flash Player by downloading here.