Program your first simulation.

Turn the new project into a small working simulation. The exact example, code and verification screenshots will be developed in this chapter.

Introduce the smallest useful simulation example.
Show how to verify that the program is running.

Simulation walkthrough

Use the maintained `pyCANdo/example_rbs_simple` project in code-server. Both CAN channels load the same DBC, and the Python simulation sends the database-backed `Control_01` message every second.

Review the second CAN channel

Open `config/can2.toml`. The example assigns PCAN hardware channel 2 to `CAN2` and loads `rbs_simple.dbc`, which makes messages such as `Control_01` available by name.
Send Control_01 every second

Open `rbs/main.py`. The simulation resolves `CAN2.Control_01` from the DBC, starts a one-second timer automatically and sends the message whenever the timer elapses. The message callback prints the raw `Activate` signal value when the frame is received.
Create a one-second timer

Register a timer named timer_1s. It runs once per second and starts automatically with the simulation.

timer_1s: Timer = rbs.timer.add( "timer_1s", 1.0, active_on_start=True, )

Handle the timer with a decorator

The decorator connects this callback to timer_1s. Every time the timer elapses, the callback sends the Control_01 CAN message.

@rbs.timer.on("timer_1s") def on_timer_1s(_timer: Timer): control_01_msg.send()

Create and receive the CAN2 message

Resolve Control_01 from the DBC on CAN2. The decorated callback runs whenever that message is received on CAN2 and prints the raw Activate signal value.

control_01_msg: CanMessage = rbs.can_message.get("CAN2.Control_01") @rbs.can_message.on("CAN2.Control_01") def on_control_01_msg(message: CanMessage): print(f"Activate status: {message['Activate'].raw}")

Timer API documentation
Change a signal on CAN1 and receive it on CAN2

Open `rbs/examples/signal/main.py`. This extended example leaves the default `rbs/main.py` untouched. With CAN1 and CAN2 connected to the same CAN bus, it accesses the DBC-backed `Target_Speed` signal on CAN1, changes its physical rpm value, sends `Control_01`, and reads the received signal from the same message on CAN2.
Access the CAN1 signal

Resolve the database-backed Control_01 message and its Target_Speed signal explicitly on CAN1. The phys property exposes the value in the DBC unit, rpm.

control_01_tx: CanMessage = rbs.can_message.get("CAN1.Control_01") target_speed_tx: CanSignal = rbs.can_signal.get("CAN1.Control_01.Target_Speed")

Change and send the signal on CAN1

Every second, increase the physical Target_Speed value by 250 rpm, wrap it after 4000 rpm and send the updated Control_01 message on CAN1.

@rbs.timer.on("signal_timer_1s") def send_next_target_speed(_timer: Timer): next_speed = target_speed_tx.phys + 250.0 target_speed_tx.phys = 0.0 if next_speed > 4000.0 else next_speed control_01_tx.send()

Receive and read the signal on CAN2

When Control_01 arrives on CAN2, access Target_Speed through the received message and print its physical rpm value.

@rbs.can_message.on("CAN2.Control_01") def on_control_01_received(message: CanMessage): received_target_speed: CanSignal = message["Target_Speed"] print(f"CAN2 Target_Speed: {received_target_speed.phys:.0f} rpm")

CAN message and signal API documentation
Create a log file

Open `rbs/examples/logging/main.py`. This example creates a timestamped MF4 trace in the project's `default` trace folder. It registers a pyRBS `BusLogger` for all available CAN channels, starts recording when the simulation starts, and stops the logger during shutdown so the log file is exported correctly.
Add the bus logger

Register first_steps_log with the pyRBS bus logger handler. Because no channel filter is supplied, the trace records the available CAN channels, including CAN1 and CAN2.

bus_logger: BusLogger = rbs.buslog.add( "first_steps_log", log_file, )

Start and stop with the simulation

Start recording when the simulation starts. Stop the logger during shutdown so pyRBS closes the session and exports the MF4 log file.

@rbs.on_start() def start_logging(): print(f"Logging CAN traffic to {log_file}") bus_logger.start() @rbs.on_stop() def stop_logging(): bus_logger.stop()

Bus logger API documentation

Program your first simulation.

Simulation walkthrough

Review the second CAN channel

Send Control_01 every second

Change a signal on CAN1 and receive it on CAN2

Create a log file