pyCANdo
Download

Restbus Simulation

The PyRbs Python class connects your application logic with timers, CAN messages, signals, state machines, and system variables. React to changes and updates without learning a proprietary programming language.

Explore on GitHubRead the PyRbs docs
./rbs/main.py
Copy code 
from pyrbs import PyRbs, CanMessage, Timerrbs = PyRbs(dashboard=True, log_all=True)timer_100ms: Timer = rbs.timer.add("timer_100ms", 0.1, active_on_start=True)msg_control_01: CanMessage = rbs.can_message.get("CAN1.Control_01")@rbs.timer.on("timer_100ms")def on_timer_100ms(self: Timer):    msg_control_01.send()

Create your event-driven restbus simulation

PyRbs decorators expose the events taking place behind the scenes: CAN message reception and transmission, signal updates, timer events, state-machine changes, and service events from diagnostic protocols such as UDS or CANopen.

Keep the code focused on the behavior of the device under test while pyCANdo handles the timing and CAN communication around it.

./rbs/main.py
Copy code 
temp_avg = rbs.sysvar.add("temp_avg", 0.0)temp_1_mapped = rbs.sysvar.add("temp_1_mapped", 0.0)@rbs.can_message.on("CAN1.Measurement_01")def on_measurement_msg(self):    temp_avg.value = np.average(np.array([        self[f"Temperature_0{x}"] for x in range(1,5)    ]))@rbs.sysvar.on_change("temp_avg")def on_temp_avg(self):    if self.value > 55:        print("over temperature warning!")@rbs.can_signal.on_update("CAN1.Measurement_01.Temperature_01")def on_temp_2_update(self):    temp_1_mapped.value = self.phys

Configure a simulation

Describe CAN communication with familiar DBC or ARXML files. TOML configuration files define the channels and project setup, while requirements.txt keeps the Python dependencies reproducible.

The complete simulation remains a transparent collection of text-based files that can be reviewed and versioned with Git, as well as edited by modern AI.

my_restbus├── config│   ├── config.toml│   ├── can.toml│   ├── can1.dbc│   ├── can2.arxml│   └── requirements.txt├── dashboards│   └── control_panel.json├── rbs│   ├── __init__.py│   └── main.py└── readme.md
Repository structure
./config/can.toml
Copy code 
[CAN1]hw_channel = 1hw_vendor = "pcan"alias = "InputCAN"db = [ "./can1.dbc" ][CAN1.hw.nominal]brp = 2tseg1 = 63tseg2 = 16sjw = 16tsam = 16bitrate = 500_000sample_point = 8_000tq = 25bitrate_real = 0
CAN interface settings
./config/requirements.txt
Copy code 
pyrbs==0.2.38pyrbs_core==0.1.87pandasscipy
Python requirements
./config/can1.dbc
Copy code 
BO_ 512 Measurement_01: 8 Vector__XXXSG_ Temperature_04 : 56|8@1+ (0.5,-40) [-40|87.5] "" Vector__XXXSG_ Temperature_03 : 48|8@1+ (0.5,-40) [-40|87.5] "" Vector__XXXSG_ Temperature_02 : 40|8@1+ (0.5,-40) [-40|87.5] "" Vector__XXXSG_ Temperature_01 : 32|8@1+ (0.5,-40) [-40|87.5] "" Vector__XXXSG_ Voltage_02 : 16|16@1+ (0.01,0) [0|655.35] "" Vector__XXXSG_ Voltage_01 : 0|16@1+ (0.01,0) [0|655.35] "" Vector__XXXBO_ 256 Control_01: 7 Vector__XXXSG_ Activate : 52|1@1+ (1,0) [0|0] "" Vector__XXXSG_ D_Value : 40|12@1+ (0.01,0) [0|40.95] "" Vector__XXXSG_ I_Value : 28|12@1+ (0.01,0) [0|40.95] "" Vector__XXXSG_ P_Value : 16|12@1+ (0.01,0) [0|40.95] "" Vector__XXXSG_ Target_Speed : 4|12@1+ (1,0) [0|4095] "rpm" Vector__XXXSG_ Mode : 0|4@1+ (1,0) [0|15] "" Vector__XXX
CAN description

Multiply your simulation

When a test bench contains several devices under test, profiles define only the differences from a shared base configuration. A project can therefore scale to a multi-DUT setup on one pyCANdo device without duplicating the entire simulation in case each device needs its own independent RT Runtime.

my_restbus├── config│   ├── profile│   │   ├── DUT1.toml│   │   └── DUT2.toml│   ├── config.toml│   ├── can.toml│   ├── can1.dbc│   └── requirements.txt├── dashboards│   └── control_panel.json├── rbs│   ├── __init__.py│   └── main.py└── readme.md
Repository structure
./config/profile/DUT1.toml
Copy code 
[CAN.CAN1]hw_channel = 1[SYSVAR]logfile_name = "DUT1"
Profile of DUT1
./config/profile/DUT2.toml
Copy code 
[CAN.CAN1]hw_channel = 2[SYSVAR]logfile_name = "DUT2"
Profile of DUT2

State machines

Use the Python statemachine package to describe the application logic. Event decorators such as @rbs.state.on_enter can change timers, message transmission, or signal values as the machine moves between states.

The same definition can be converted into a Mermaid diagram, keeping the implemented behavior and its visual documentation closely aligned.

Explore the state-machine example →
./rbs/control_states.py
Copy code 
from statemachine import StateMachine, State, exceptionsclass ControllerTargetStates(StateMachine):    sleep = State("sleep", initial=True)    standby = State("standby")    speed = State("speed")    torque = State("torque")    to_standby = sleep.to(standby) | speed.to(standby) | torque.to(standby)    to_speed = standby.to(speed)    to_torque = standby.to(torque)    to_sleep = standby.to(sleep)    to_save_state = sleep.to(standby) | speed.to(standby) | torque.to(standby)    def change_state(self, sel_state: int) -> None:        if self.current_state == self.state_from_value(sel_state):            return        try:            match sel_state:                case 0:                    self.to_sleep()                case 1:                    self.to_standby()                case 2:                    self.to_speed()                case 3:                    self.to_torque()        except exceptions.TransitionNotAllowed:            self.to_save_state()
State definition
State diagram generated from the engine-control logic
Generated diagram
./rbs/main.py
Copy code 
from pyrbs import PyRbs, CanMessage, CanSignal, SysVar, Timerfrom control_states import ControllerTargetStatesrbs = PyRbs(dashboard=True, log_all=True)ctrl_state = rbs.state.add_statemachine(    "ctrl_state", ControllerTargetStates)@rbs.state.on_enter("ctrl_state", "sleep")def on_enter_sleep(self: ControllerTargetStates):    select_mode.value = 0    timer_100ms.stop()@rbs.state.on_exit("ctrl_state", "sleep")def on_exit_sleep(self: ControllerTargetStates):    timer_100ms.start()@rbs.state.on_enter("ctrl_state", "standby")def on_enter_standby(self: ControllerTargetStates):    select_mode.value = 1    msg_control_01["Mode"].raw = 0@rbs.state.on_enter("ctrl_state", "speed")def on_enter_speed(self: ControllerTargetStates):    msg_control_01["Mode"].raw = 1@rbs.state.on_enter("ctrl_state", "torque")def on_enter_torque(self: ControllerTargetStates):    msg_control_01["Mode"].raw = 2
Application behavior

Common questions about pyCANdo

Isn't Python is a slow programming language?

PyRbs keeps the performance-critical work outside of your business logic. The heavy lifting is implemented in Rust in the background.

Is real-time behavior possible with pyCANdo?

Linux preemption, core isolation, and other system-level measures are used to make response times accurate and predictable.

Can I use any Python package?

Most packages fit naturally, including NumPy, Polars, pandas, and SciPy. Blocking requests or custom asynchronous threads should not run directly inside an @rbs event handler.

How many simulations can run in parallel?

The available CPU cores determine the number of parallel running simulations. Three cores are typically reserved for utilities and real-time services; each remaining core can run an additional simulation.

Can i use my CAN Interfaces on multiple Simulations at the same time

Yes, Interfaces can be shared as well as locked exclusivly for one Simulation.