# Message

class `can.``Message`(timestamp=0.0, is_remote_frame=False, extended_id=True, is_error_frame=False, arbitration_id=0, dlc=None, data=None, channel=None)

  The `Message` object is used to represent CAN messages for both sending and receiving.

  Messages can use extended identifiers, be remote or error frames, and contain data.

  One can instantiate a `Message` defining data, and optional arguments for all attributes such as arbitration ID, flags, and timestamp.

      >>> from can import Message
      >>> test = Message(data=[1, 2, 3, 4, 5])
      >>> test.data
      bytearray(b'\x01\x02\x03\x04\x05')
      >>> test.dlc
      5
      >>> print(test)
      Timestamp:        0.000000    ID: 00000000    010    DLC: 5    01 02 03 04 05

  The `arbitration_id` field in a CAN message may be either 11 bits (standard addressing, CAN 2.0A) or 29 bits (extended addressing, CAN 2.0B) in length, and `python-can` exposes this difference with the `is_extended_id` attribute.

  `arbitration_id`

    Type: | int

    The frame identifier used for arbitration on the bus.

    The arbitration ID can take an int between 0 and the maximum value allowed depending on the is_extended_id flag (either 211 - 1 for 11-bit IDs, or 229 - 1 for 29-bit identifiers).

        >>> print(Message(extended_id=False, arbitration_id=100))
        Timestamp:        0.000000        ID: 0064    S        DLC: 0

  `data`

    Type: | bytearray

    The data parameter of a CAN message is exposed as a bytearray with length between 0 and 8.

        >>> example_data = bytearray([1, 2, 3])
        >>> print(Message(data=example_data))
        Timestamp:        0.000000    ID: 00000000    X        DLC: 3    01 02 03

    A `Message` can also be created with bytes, or lists of ints:

        >>> m1 = Message(data=[0x64, 0x65, 0x61, 0x64, 0x62, 0x65, 0x65, 0x66])
        >>> print(m1.data)
        bytearray(b'deadbeef')
        >>> m2 = Message(data=b'deadbeef')
        >>> m2.data
        bytearray(b'deadbeef')

  `dlc`

    Type: | int

    The DLC parameter of a CAN message is an integer between 0 and 8 representing the frame payload length.

        >>> m = Message(data=[1, 2, 3])
        >>> m.dlc
        3

    Note

    The DLC value does not necessarily define the number of bytes of data in a message.

    Its purpose varies depending on the frame type - for data frames it represents the amount of data contained in the message, in remote frames it represents the amount of data being requested.

  `is_extended_id`

    Type: | bool

    This flag controls the size of the `arbitration_id` field.

        >>> print(Message(extended_id=False))
        Timestamp:        0.000000        ID: 0000    S        DLC: 0
        >>> print(Message(extended_id=True))
        Timestamp:        0.000000    ID: 00000000    X        DLC: 0

    Previously this was exposed as id_type.

  `is_error_frame`

    Type: | bool

    This boolean parameter indicates if the message is an error frame or not.

        >>> print(Message(is_error_frame=True))
        Timestamp:        0.000000    ID: 00000000    X E      DLC: 0

  `is_remote_frame`

    Type: | boolean

    This boolean attribute indicates if the message is a remote frame or a data frame, and modifies the bit in the CAN message’s flags field indicating this.

        >>> print(Message(is_remote_frame=True))
        Timestamp:        0.000000    ID: 00000000    X   R    DLC: 0

  `timestamp`

    Type: | float

    The timestamp field in a CAN message is a floating point number representing when the message was received since the epoch in seconds. Where possible this will be timestamped in hardware.

  `__str__`()

    A string representation of a CAN message:

        >>> from can import Message
        >>> test = Message()
        >>> print(test)
        Timestamp:        0.000000    ID: 00000000    X        DLC: 0
        >>> test2 = Message(data=[1, 2, 3, 4, 5])
        >>> print(test2)
        Timestamp:        0.000000    ID: 00000000    X        DLC: 5    01 02 03 04 05

    The fields in the printed message are (in order):

    - timestamp,
    - arbitration ID,
    - flags,
    - dlc,
    - and data.

    The flags field is represented as one, two or three letters:

    - X if the `is_extended_id` attribute is set, otherwise S,
    - E if the `is_error_frame` attribute is set,
    - R if the `is_remote_frame` attribute is set.

    The arbitration ID field is represented as either a four or eight digit hexadecimal number depending on the length of the arbitration ID (11-bit or 29-bit).

    Each of the bytes in the data field (when present) are represented as two-digit hexadecimal numbers.