Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

Package Summary

Version 1.0.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version jazzy-devel
Last Updated 2025-07-01
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

1.0.0 (2025-07-01)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

No version for distro kilted showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

Package Summary

Version 1.0.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version rolling-devel
Last Updated 2025-07-01
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

1.0.0 (2025-07-01)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

No version for distro ardent showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

No version for distro bouncy showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

No version for distro crystal showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

No version for distro eloquent showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

No version for distro dashing showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

No version for distro galactic showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

No version for distro foxy showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

No version for distro iron showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

No version for distro lunar showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

No version for distro jade showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

No version for distro indigo showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

No version for distro hydro showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

No version for distro kinetic showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

No version for distro melodic showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange

No version for distro noetic showing humble. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.9.0
License Apache-2.0, MIT
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/bosch-engineering/off_highway_sensor_drivers.git
VCS Type git
VCS Version humble-devel
Last Updated 2025-06-18
Dev Status MAINTAINED
Released RELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

The off_highway_can package

Maintainers

  • Robin Petereit

Authors

  • Robin Petereit
  • Marcus Huenerbein

off_highway_can

The off_highway_can package provides a C++ library to

  • receive can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode their bytes into custom C++ message structures,
  • encode the bytes of can_msgs/Frame or socketcan_msgs/FdFrame ROS messages from custom C++ message structures and send them.

The list of message structures containing the definition of a CAN message and signals need to be filled by derived classes for CAN node specific functionality. The more generic handling of a cyclic redundancy check and a rolling message counter per message is provided by the library. Have a look directly into the CAN message structure definition for further information.

Classes

Receiver

The off_highway_can::Receiver is an abstract base class and needs to be derived for specific sensor types and behavior. It provides the functionality to process can_msgs/Frame or socketcan_msgs/FdFrame ROS messages and decode configured ones based on provided message definitions. The decoded signal values are forwarded to the derived class for user-defined processing of them.

The off_highway_can::Receiver allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The processing chain is based completely on message callbacks and thus event-based. The needed processing time per message can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Receiver provides a watchdog which checks whether any configured message was received in the period of time defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Subscribed Topics

  • from_can_bus (can_msgs/Frame)
    • CAN frames to decode
    • Disabled by use_fd constructor argument
  • from_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument

Published Topics

Parameters

See receiver_params.yaml.

Sender

The off_highway_can::Sender is an abstract base class and needs to be derived for specific behavior. It provides the functionality to send can_msgs/Frame or socketcan_msgs/FdFrame ROS messages by encoding configured CAN messages as bytes based on provided message definitions. The encoded signal values are published to the to_can_bus or to_can_bus_fd topic.

The off_highway_can::Sender allows to switch between normal and FD CAN frames via the constructor argument use_fd.

The encoding and publishing chain is just a method call and thus event-based. The needed processing time to encode and publish all configured messages can be logged as ROS debug message at runtime with the compile time optionCOMPILE_DEBUG_LOG.

Furthermore, the off_highway_can::Sender provides a watchdog which checks whether a ROS message was published in a defined by the parameter timeout and sends a diagnostic error on the /diagnostics topic when a timeout occurs.

Published Topics

  • to_can_bus (can_msgs/Frame)
    • Encoded CAN frames
    • Disabled by use_fd constructor argument
  • to_can_bus_fd (socketcan_msgs/FdFrame)
    • CAN FD frames to decode
    • Enabled by use_fd constructor argument
  • /diagnostics (diagnostic_msgs/DiagnosticArray)
    • Update Rate: normally 1 Hz, can be forced
    • Diagnostic status in base class only contains timeout status

Parameters

See sender_params.yaml.

Free and Open Source Software (FOSS)

File truncated at 100 lines see the full file

CHANGELOG

Changelog for package off_highway_can

0.9.0 (2025-06-16)

  • Use lround and explicit cast
  • Fix integer inputs for round test
  • Contributors: Robin Petereit

0.8.0 (2025-03-24)

  • Move test to emphasize external FOSS
  • Add tests for encoding by round
  • Replace truncation of physical value with round outside of FOSS Minimizes the floating point error such that half offset of resolution in tests is not needed anymore.
  • Contributors: Calin-Vasile Sopterean, Robin Petereit

0.7.0 (2024-12-04)

  • Update docs for CAN FD
  • Check matching lengths in decoding
  • Allow start bits in CAN FD range
  • Make CRC and message counter optional
  • Enable processing of CAN FD frames
  • Remove unused definitions
  • Do not force warnings as errors to fix rolling (#11)
  • Contributors: Robin Petereit, Tim Clephas

0.6.3 (2024-07-09)

0.6.2 (2024-06-13)

0.6.1 (2024-06-04)

  • Fix missing dependency that was find_packaged (#7)

    • Fix missing dependency that was find_packaged

    * Use ament_lint_common ---------

  • Contributors: Tim Clephas

0.6.0 (2024-05-14)

0.5.1 (2024-03-27)

  • Align Clang FP contraction to GCC for passing tests
  • Add virtual destructor for base class
  • Contributors: Robin Petereit

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged off_highway_can at Robotics Stack Exchange