NAME

       can_viewer - CAN data viewer 3.0.0+github

SYNOPSIS

       python -m can.viewer [-h] [--version] [-b BITRATE] [-c CHANNEL]

DESCRIPTION

       [-d {<id>:<format>,<id>:<format>:<scaling1>:...:<scalingN>,file.txt}]
              [-f                  {<can_id>:<can_mask>,<can_id>~<can_mask>}]                 [-i
              {iscan,ixxat,kvaser,neovi,nican,pcan,serial,slcan,socketcan,socketcan_ctypes,socketcan_native,usb2can,vector,virtual}]

       A simple CAN viewer terminal application written in Python

   Optional arguments:
       -h, --help
              Show this help message and exit

       --version
              Show program's version number and exit

       -b, --bitrate BITRATE
              Bitrate to use for the given CAN interface

       -c, --channel CHANNEL
              Most  backend interfaces require some sort of channel.  For example with the serial
              interface the channel might be a rfcomm device: "/dev/rfcomm0" with  the  socketcan
              interfaces  valid  channel examples include: "can0", "vcan0". (default: use default
              for the specified interface)

       -d, --decode {<id>:<format>,<id>:<format>:<scaling1>:...:<scalingN>,file.txt}
              Specify how to convert the raw bytes into real values.  The  ID  of  the  frame  is
              given  as  the  first  argument  and  the  format as the second.  The Python struct
              package is used to unpack the received data where the format  characters  have  the
              following meaning:

       < = little-endian, > = big-endian
              x  =  pad  byte c = char ? = bool b = int8_t, B = uint8_t h = int16, H = uint16 l =
              int32_t, L = uint32_t q = int64_t, Q = uint64_t f = float  (32-bits),  d  =  double
              (64-bits)

       Fx to convert six bytes with ID 0x100 into uint8_t, uint16 and uint32_t:
              $ python -m can.viewer -d "100:<BHL"

       Note that the IDs are always interpreted as hex values.
              An  optional  conversion  from  integers  to  real units can be given as additional
              arguments. In order to convert from raw integer values the  values  are  multiplied
              with  the  corresponding  scaling  value,  similarly  the values are divided by the
              scaling value in order to convert from real units to raw integer values.   Fx  lets
              say  the  uint8_t  needs no conversion, but the uint16 and the uint32_t needs to be
              divided by 10 and 100 respectively:

              $ python -m can.viewer -d "101:<BHL:1:10.0:100.0"

       Be aware that integer division is performed if the scaling value is an integer.
              Multiple arguments are separated by spaces:

              $ python -m can.viewer -d "100:<BHL" "101:<BHL:1:10.0:100.0"

       Alternatively a file containing the conversion strings separated by new lines
              can be given as input:

              $ cat file.txt

       100:<BHL
              101:<BHL:1:10.0:100.0

              $ python -m can.viewer -d file.txt

       -f, --filter {<can_id>:<can_mask>,<can_id>~<can_mask>}
              Comma separated CAN filters for the given CAN interface:

       <can_id>:<can_mask> (matches when <received_can_id> & mask == can_id & mask)
              <can_id>~<can_mask> (matches when <received_can_id> & mask != can_id & mask)

       Fx to show only frames with ID 0x100 to 0x103:
              python -m can.viewer -f 100:7FC

              Note that the ID and mask are alway interpreted as hex values

       -i,                                                                            --interface
       {iscan,ixxat,kvaser,neovi,nican,pcan,serial,slcan,socketcan,socketcan_ctypes,socketcan_native,usb2can,vector,virtual}
              Specify the backend CAN interface to use.

   Shortcuts:
       +---------+-------------------------+

       |      Key   |       Description       |

       +---------+-------------------------+

       | ESQ/q
              | Exit the viewer         |

       | c    | Clear the stored frames |

       | s    | Sort the stored frames  |

       | SPACE
              | Pause the viewer        |

       | UP/DOWN | Scroll the viewer
              |

       +---------+-------------------------+