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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

No version for distro lyrical showing jazzy. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

No version for distro rolling showing jazzy. Known supported distros are highlighted in the buttons above.

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange

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

Package Summary

Version 0.0.0
License Apache 2.0
Build type AMENT_CMAKE
Use RECOMMENDED

Repository Summary

Checkout URI https://github.com/WATonomous/wato_monorepo.git
VCS Type git
VCS Version main
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Package Description

Node to estimate vehicle state (steering angle, velocity, odometry) from CAN bus and wheel speed data

Maintainers

  • WATonomous

Authors

No additional authors.

can_state_estimator

Reads steering angle and wheel speed frames directly from the vehicle OBD CAN bus and publishes steering angle, body velocity, and dead-reckoning odometry.

Overview

Rather than routing vehicle feedback through OSCC, this node reads CAN frames directly via SocketCAN. This eliminates the OSCC dependency for feedback data and reduces latency by one ROS hop. It handles both the 0x2B0 (steering) and 0x4B0 (wheel speeds) CAN frame IDs used by the Kia Soul EV.

Architecture

The node runs a background thread that blocks on read() for incoming CAN frames. Each frame is decoded and the corresponding state (steering angle, wheel speeds) is updated under a mutex. On each wheel speed frame the node recomputes body velocity and integrates odometry.

CAN Bus (SocketCAN)
  0x2B0 steering ──┐
  0x4B0 wheels  ──┤──► CAN read thread ──► decode & integrate ──► publishers
                   │
              TF lookup (rear_axle → front_axle = wheelbase)

Ackermann bicycle model (rear-axle reference):

v_front_avg = (v_nw + v_ne) / 2
v_body      = v_front_avg * cos(steering_angle)
omega       = v_body * tan(steering_angle) / wheelbase

x     += v_body * cos(theta) * dt
y     += v_body * sin(theta) * dt
theta += omega * dt

The wheelbase is resolved from TF at startup by looking up the distance between rear_axle_frame and front_axle_frame (published by robot_state_publisher from the URDF). The node blocks until this transform is available before publishing velocity or odometry.

Odometry is pure dead-reckoning and will drift. Fuse with GPS/IMU for absolute positioning.

Lifecycle

Managed by wato_lifecycle_manager:

Transition Action
configure Read parameters, create publishers, open and bind CAN socket, start TF listener
activate Activate publishers, reset odometry, start CAN read thread
deactivate Stop CAN read thread, deactivate publishers
cleanup Close CAN socket, destroy publishers and TF resources
CHANGELOG
No CHANGELOG found.

Package Dependencies

System Dependencies

No direct system dependencies.

Dependant Packages

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged can_state_estimator at Robotics Stack Exchange