Best practices for system design and package dependencies

My questions is based on lack of experience in the overall robot system design process. I have practiced all the pieces very often, like nodes ( publishers and subscribers) as well as actions and services. I also used many off the shelf packages like ros2 control and nav2 to move both physical robots and in Gazebo.

However I lack experience in designing an entire robot and its packages from scratch. So I am using the duckietown chassis and peripherals but writing everything in ros2 c++ rather than neotic python as is being used by the course

So far I have two packages: a sensors package and a control package.

Sensor Package: the purpose here is to group together any kind of hardware interfaces, like wheel encoders, motor drivers, camera nodes, etc. This package understands things like PWM and I2C and can communicate with the GPIO.
Control Package: this package will use classes and nodes from the sensor package to drive the wheels. I plan to add PID feedback later on, but for now the purpose to just drive the wheels with teleop or teleop_joy for instance.

I started to think about this in terms of having two teams: one team is writing the controls package, while another team is writing the sensors (essentially drivers). The control engineers don't want to know or understand anything about PWM or I2C for instance.

Therefore it does not make sense for the sensors package to offer any utilities, but just interfaces through messages.

Thus the sensors package needs to offer services and actions for initializing things like I2C or GPIO.

But I want to pause and think about this design so that it is long-term-thinking.

For instance this robot will end up with a perception package and a planning package as well. Therefore there must be some kind of orchestration package (probably just a set of launch files) that would initialize all this.

I suppose my real question is: how is this done in professional large scale projects? What is the best practice for package dependencies and overall system design, as well as system bring-up?

Asked by sameh4 on 2022-12-30 10:45:53 UTC

Comments

Answers

This is not the answer, but I can give you some examples of projects I know of that you can base your work on:

Neobotix repositories: https://github.com/neobotix/neo_simulation2 and others
Linorobot2: https://github.com/linorobot/linorobot2
Mecanum wheel robot: https://github.com/deborggraever/ros2-mecanum-bot
Panther (Husarion): https://github.com/husarion/panther_ros
TIAGi (Pal Robotics): https://github.com/pal-robotics/tiago_simulation
TurtleBot3 (ROBOTIS): https://github.com/ROBOTIS-GIT/turtlebot3 and Turtlebot2 on ROS2: https://github.com/igrak34/TurtleBot2-on-ROS2

Of course, your final decision depends on many factors, so I'd love to see other suggestions.

Asked by ljaniec on 2022-12-30 11:20:43 UTC

Comments

@ljaniec thanks for the links! The turtlebot3 is an interesting use case. They have a kind of "main" node that creates objects that manage sensors and actuators, and passes a handle of itself to them. It also uses an "sdk" for controlling the actual peripherals by doing the lower level code, i2c, etc.

Asked by sameh4 on 2022-12-30 13:27:20 UTC