flightStand 3.0.0__tar.gz

flightstand-3.0.0/FlightStand/__init__.py

@@ -0,0 +1,15 @@
+from importlib import import_module
+import sys
+
+# Make grpc-generated absolute import work:
+# `import flight_stand_api_v1_pb2`  -> resolves to `FlightStand.flight_stand_api_v1_pb2`
+sys.modules.setdefault(
+    "flight_stand_api_v1_pb2",
+    import_module(".flight_stand_api_v1_pb2", package=__name__),
+)
+sys.modules.setdefault(
+    "flight_stand_api_v1_pb2_grpc",
+    import_module(".flight_stand_api_v1_pb2_grpc", package=__name__),
+)
+
+from .flightstand import FlightStand

flightstand-3.0.0/FlightStand/examples/PID_constant_thrust.py

@@ -0,0 +1,128 @@
+"""
+This example demonstrates continuous data reading and throttle adjustment to achieve a constant thrust. The control
+response is calculated using a closed-loop PID controller. To visualize the thrust response, the target thrust is
+alternated between half and full thrust. Make sure the hardware is connected and the output for control is configured
+and activated from the manual control tab before running the script. Additionally, configure safety cutoffs specific to
+your application.
+"""
+
+import time
+from FlightStand import FlightStand
+
+# The PID controller library needs to work with arbitrary timestamps, since the sensors are sampled in the hardware and
+# using the computer's timestamp would yield incorrect results. Also, it needs to accept varying delta timestamps as
+# some sensors don't have a fixed sample rate, for example the rotation speed sensor.
+# Don't forget to install this library before running this example:
+# pip install simple-pid
+from simple_pid import PID
+
+""" USER PARAMETERS """
+
+# Set the signal names of the input and output. To find the input and output names, you can run this script once as
+# it will  print out all the inputs and outputs found. Refer to the API documentation for the signal type constants (
+# search in the .proto file for "enum InputType"). For example a rotation speed sensor is input_type=15.
+input_name = "/boards/simulated_1/inputs/1"  # this is the name of the input to control
+output_name = "/boards/simulated_1/outputs/1"  # this is the name of the control output
+
+"""
+PID terms for the PID controller. These coefficients need to be tuned by the user and are specific to each application.
+Tuning PID coefficients is a crucial step to achieve desired control performance. Here are some considerations:
+
+- Tuning Guidance: Refer to resources like [PID Tuning Guide](https://realpars.com/pid-tuning/) for pointers on PID 
+tuning. However, keep in mind that there is no one-size-fits-all approach, and results can vary based on different 
+factors.
+
+- Factors Affecting PID Coefficients:
+  PID coefficients can be influenced by various factors, including:
+  - Voltage: The power supply voltage can affect the system's response.
+  - Propeller Diameter/Mass: Propeller characteristics can impact the control behavior.
+  - Motor Size: The size and specifications of the motor play a role in determining the optimal coefficients.
+  - ESC Settings: ESC configuration settings can affect the control response.
+  - Type of Input: The type of input being controlled (thrust, RPM, power, temperature) can influence the coefficients.
+  - PID update rate: The sample rate can also affect the stability and performance of the control.
+  - Output Settings: The output configuration (PWM, DShot, range, rate limiter, etc.) can impact the coefficients.
+  - User Application Requirements: Desired control characteristics (fast reaction, no overshoot, etc.) affect the ideal
+    coefficients.
+
+- Examples of PID Terms:
+  Here are some examples of PID terms used in different scenarios:
+  - Simulated Hardware (Constant Thrust): 2000, 1500, 0
+  - Simulated Hardware (Constant Thrust with Output Rate Limit of 200): 2000, 500, 0
+  - Simulated Hardware (Constant Rotation Speed): 2, 5, 0
+  - Real Hardware (Mejzlik 48 x 16,4 Propeller, Xoar 180-35 34kv Motor, Xoar Pulse P200 ESC)
+    - Constant Thrust with Rate Limiter of 200us/s at 80V: 6, 5.5, 0.5
+    - Constant Rotation Speed with Rate Limiter of 200us/s at 80V: 2, 5, 0.3
+"""
+Kp = 2000.0  # Proportional terms
+Ki = 1500.0  # Integral term
+Kd = 0.0  # Derivative term
+
+# This example performs a square wave pattern alternating between 50% of the target_value and 100% of the target_value.
+# You can set the period for this pattern in seconds.
+pattern_period = 10.0
+target_value = 1.0  # The value the input signal should reach
+
+""" SCRIPT """
+
+print(" **** Running example PID script in Python **** ")
+core = FlightStand()
+
+controller_output = core.get_output(output_name)
+controller_input = core.get_input(input_name)
+if not controller_output or not controller_input:
+    print("Input or output not found.")
+    exit()
+
+
+def set_throttle(value):
+    controller_output.output_target.target_value = value
+    core.update_output(controller_output, ['output_target'])
+
+
+# Setup the PID controller
+sample_time = None
+target_changed = time.time()
+limits = (controller_output.min_user_value, controller_output.max_user_value)
+pid = PID(Kp, Ki, Kd, output_limits=limits, sample_time=None)
+
+
+def update():
+    global target_changed, sample_time
+
+    # Calculate the set point to have a square wave pattern with a low point half of the target thrust
+    target = target_value
+    t = time.time()
+    if t - target_changed > pattern_period / 2:
+        target = 0.5 * target
+    if t - target_changed >= pattern_period:
+        target_changed += pattern_period
+    pid.setpoint = target
+
+    # Get the latest available sample.
+    input_sample = core.get_latest_input_sample(controller_input)
+
+    # Listing samples may repeat the same samples as the rpc returns the latest values available, so we only
+    # update the PID controller when the sample time has changed.
+    new_sample_time = input_sample.sample_time.ToDatetime()
+    if sample_time is None or new_sample_time != sample_time:
+        if sample_time is not None:
+            dt = (new_sample_time - sample_time).total_seconds()
+            val = input_sample.filtered_value
+
+            # Update the PID controller with the new sample value, to obtain the updated control output
+            output = pid(val, dt)
+
+            # Apply the output throttle
+            set_throttle(output)
+
+            print({
+                "Delta time (s)": dt,
+                "Target input": pid.setpoint,
+                "Input": val,
+                "Output": output,
+            })
+        sample_time = new_sample_time
+
+
+# We run a continuous loop that reads the latest thrust sensor value and sets the output to achieve a target thrust
+core.run_at_interval(0.001, update)

flightstand-3.0.0/FlightStand/examples/advanced_grpc_data_streaming.py

@@ -0,0 +1,106 @@
+# This example is for advanced users, and is directly interacting with grpc instead of using flightstand.py wrapper
+# class. For most users, it is better to refer to the example_data_polling.py example to continuously read sensor data.
+# This example shows how to use the WatchSamples rpc call to continuously stream data. It is important to note the core
+# will automatically discard samples if the Python execution is blocked. For this reason, if you want to continuously
+# stream data while performing other tasks, multithreading is recommended.
+import threading
+import time
+import grpc
+from FlightStand import flight_stand_api_v1_pb2 as fs
+from FlightStand import flight_stand_api_v1_pb2_grpc as fs_grpc
+
+print(" **** Running example script in Python **** ")
+
+print("Connecting to core...")
+channel = grpc.insecure_channel('localhost:50051')
+stub = fs_grpc.FlightStandStub(channel)
+
+# Confirming connection to core
+GetServerStatusRequest = fs.GetServerStatusRequest()
+ServerStatus = stub.GetServerStatus(GetServerStatusRequest)
+print("Core connected!")  # If we reach this line without an error thrown, it means the core responded.
+
+# Listing available hardware
+print("Listing available hardware:")
+ListBoardsResponse = stub.ListBoards(fs.ListBoardsRequest())
+for listedBoard in ListBoardsResponse.boards:
+    print(listedBoard.name + ": " + listedBoard.display_name)
+
+# We want to work with a known hardware, in the case of this example we work with simulated_1 circuit, so we check if
+# it is available.
+boardName = "/boards/simulated_1"  # this is the name of the board we want to work with.
+board = False
+for listedBoard in ListBoardsResponse.boards:
+    if listedBoard.name == boardName:
+        board = listedBoard
+
+# If the simulated board does not exist, we add it
+if not board:
+    # Connect a simulated board
+    print("No hardware found. Connecting simulated hardware...")
+    stub.CreateSimulatedBoard(fs.CreateSimulatedBoardRequest())
+    print("Waiting for simulated hardware to connect...")
+    time.sleep(4)
+    print("Done.")
+
+    # Confirm it has connected
+    print("Listing available hardware:")
+    ListBoardsResponse = stub.ListBoards(fs.ListBoardsRequest())
+    for listedBoard in ListBoardsResponse.boards:
+        print(listedBoard.name + ": " + listedBoard.display_name)
+        if listedBoard.name == boardName:
+            board = True
+    if not board:
+        raise RuntimeError("Cannot add simulated board")
+
+# Lets list all available inputs (sensors)
+ListInputsResponse = stub.ListInputs(fs.ListInputsRequest())
+print("Listing available inputs:")
+for listedInput in ListInputsResponse.inputs:
+    # Print some of the properties an input has. See the .proto for details.
+    print(listedInput.name + ": type=" + str(listedInput.input_type) + " signalName=" + listedInput.signal_name)
+
+# We want to focus this example on the thrust sensor
+# First, we need to know the ID of the sensor type "thrust". Based on the .proto, we
+# can find the enumeration of constants:
+#     enum InputType {
+#       [...]
+#       FORCE_FX = 9;
+#       FORCE_FY = 10;
+#       FORCE_FZ = 11;
+#       [...]
+#     }
+# Then we need to find the thrust sensor for this simulated hardware and determine the corresponding signal name.
+# Each sensor is streaming data as a signal. A signal is a stream of values. For efficiency reasons, we kept the list
+# of inputs and the signals as separate elements. Therefore, we need to find the signal name for this specific input.
+thrust_signal_name = ""
+for listedInput in ListInputsResponse.inputs:
+    # According to the .proto each input name is of format: /boards/BOARD-ID/inputs/INPUT-ID
+    # We know we want to use the thrust sensor for a specific hardware, so we check the BOARD-ID is correct:
+    if boardName + "/" in listedInput.name:
+        if listedInput.input_type == fs.FORCE_FZ:
+            thrust_signal_name = listedInput.signal_name
+            print("Thrust sensor signal name: " + thrust_signal_name)
+if not thrust_signal_name:
+    raise RuntimeError("Cannot find the required thrust sensor")
+
+# This method is a generator function that yields only once we received a response from the server
+evt = threading.Event()
+
+
+def watch_samples_request_stream():
+    while True:
+        evt.clear()
+        yield fs.WatchSamplesRequest()
+        evt.wait(timeout=1)
+
+
+# Here we print a loop continuously handles the WatchSamples rpc
+# rpc WatchSamples(stream WatchSamplesRequest) returns (stream WatchSamplesResponse);
+WatchSamplesResponseStream = stub.WatchSamples(watch_samples_request_stream())
+for WatchSamplesResponse in WatchSamplesResponseStream:
+    evt.set()  # As per the API documentation, we need to acknowledge the response (ping pong communication)
+    for sampleGroup in WatchSamplesResponse.sample_groups:
+        for sample in sampleGroup.samples:
+            if sample.signal_name == thrust_signal_name:
+                print("Thrust: " + str(sample.filtered_value) + " N")  # In Newtons

flightstand-3.0.0/FlightStand/examples/balancing/real_hardware.py

@@ -0,0 +1,145 @@
+# This example interacts with the user to achieve the balancing of a propeller by asking the user a series of
+# questions and asking the user to perform various actions on the hardware. Use this script in parallel to running
+# the user interface to control the motor using the manual control slider.
+# Note: the user interface has a balancing tab which takes care of all this sequence. This script is for illustrative
+# purposes only. Also, this works with a simulated hardware too, but is less automated.
+import math
+import time
+
+from examples.balancing.utils import show_balancing_report, input_float, format_weights
+from FlightStand import FlightStand
+
+print("**** Running example propeller balancing script with real hardware ****")
+
+core = FlightStand()
+
+# Fetch the required parameters for the balancing session from the user
+title = input("Enter the session title (optional, max 100 chars): ")
+operator_display_name = input("Enter the operator's name (optional, max 50 chars): ")
+motor_display_name = input("Enter the motor's name (optional, max 50 chars): ")
+propeller_display_name = input("Enter the propeller's name (optional, max 50 chars): ")
+rotor_mass_kg = input_float("Enter the rotor mass (in kg): ")
+operating_speed_rpm = input_float("Enter the operating speed (rpm): ")
+quality_grade_g = input_float("Enter the quality grade (optional, recommended 6.3): ")
+radius_m = input_float("Enter the correction radius (m): ")
+blades_count = int(
+    input("Enter the number of blades for the propeller (enter zero to balance a disk without blades): "))
+rotation_sensor_name = input("Enter the rotation sensor name (format '/boards/id/inputs/id'): ")
+vibration_sensor_name = input("Enter the vibration sensor name (format '/boards/id/inputs/id'): ")
+control_output_name = input("Enter the control output name (optional, format '/boards/id/outputs/id'): ")
+control_throttle_value = input_float(f"Enter the throttle value that will spin the motor to {operating_speed_rpm} rpm. Enter 0 to control manually using the GUI: ")
+
+
+def rpm_to_rad_s(rpm):
+    return rpm * (2.0 * math.pi) / 60.0
+
+
+# Create the balancing session with the user's parameters
+core.create_balancing_session(params=core.Proto.BalancingSession(
+    title=title,
+    operator_display_name=operator_display_name,
+    motor_display_name=motor_display_name,
+    propeller_display_name=propeller_display_name,
+    rotor_mass=rotor_mass_kg,
+    operating_speed_rad_s=rpm_to_rad_s(operating_speed_rpm),
+    quality_grade_g=quality_grade_g,
+    correction_radius_m=radius_m,
+    rotation_sensor_name=rotation_sensor_name,
+    vibration_sensor_name=vibration_sensor_name,
+    control_output_name=control_output_name,
+    blades_count=blades_count
+))
+
+
+def grams_to_unbalance(grams):
+    return grams * radius_m / 1000.0
+
+
+def degrees_to_rad(degrees):
+    return degrees * math.pi / 180.0
+
+
+def run_motor():
+    # Ask the user to bring the motor to their specified operating speed
+    if control_output_name == "" or control_throttle_value == 0:
+        input(f"\nPlease bring the motor to {operating_speed_rpm} rpm and press Enter")
+        return
+    print("Starting motor automatically")
+    esc_output = core.get_output(control_output_name)
+    esc_output.output_target.target_value = control_throttle_value
+    core.update_output(esc_output, ['output_target'])
+    time.sleep(1.0)
+
+
+def stop_motor():
+    if control_output_name == "":
+        input("Please stop the motor and press Enter")
+        return
+    print("Stopping motor automatically")
+    esc_output = core.get_output(control_output_name)
+    esc_output.output_target.target_value = esc_output.cutoff_target.target_value
+    core.update_output(esc_output, ['output_target'])
+
+
+# Execute the balance run
+run_motor()
+core.execute_balance_run(False, None)
+stop_motor()
+
+# Retrieve the data to know the trial weight to put
+session = core.get_balancing_session()
+initial_run = session.runs[0]
+trial_weights = initial_run.next_corrections
+
+# Ask the user to install the calculated trial weight
+print(f"\nWe recommend a trial weight of {format_weights(trial_weights, correction_radius=radius_m)}.")
+actual_trial_mass_g = input_float("Enter the installed trial weight's mass (in grams): ")
+actual_trial_angle = input_float("Enter the installed trial weight's angle (in degrees): ")
+trial_weight = core.Proto.BalanceWeight(unbalance=grams_to_unbalance(actual_trial_mass_g),
+                                        phase=degrees_to_rad(actual_trial_angle))
+
+# Execute the trial run
+print("Executing trial run")
+run_motor()
+core.execute_balance_run(False, [trial_weight])
+stop_motor()
+
+# Do multiple correction runs until the user decides to stop
+while True:
+    # Retrieve the data to know the correction weight to put
+    session = core.get_balancing_session()
+    last_run = session.runs[-1]
+    correction_weights = last_run.next_corrections
+
+    print(f"\nInstall correction weight(s) of {format_weights(correction_weights, correction_radius=radius_m)}")
+    actual_correction_mass_g = input_float("Enter the first installed correction weight's mass (in grams): ")
+    actual_correction_angle = input_float("Enter the first installed correction weight's angle (in degrees): ")
+    correction_weight = core.Proto.BalanceWeight(unbalance=grams_to_unbalance(actual_correction_mass_g),
+                                                 phase=degrees_to_rad(actual_correction_angle))
+    actual_correction_weights = [correction_weight]
+
+    actual_correction_mass_g = input_float(
+        "Enter the second installed correction weight's mass (in grams). Write 0 if none: ")
+    if actual_correction_mass_g != 0.0:
+        actual_correction_angle = input_float("Enter the second installed correction weight's angle (in degrees): ")
+        correction_weight = core.Proto.BalanceWeight(unbalance=grams_to_unbalance(actual_correction_mass_g),
+                                                     phase=degrees_to_rad(actual_correction_angle))
+        actual_correction_weights.append(correction_weight)
+
+    # Execute the correction run
+    print("Executing correction run")
+    run_motor()
+    core.execute_balance_run(True, actual_correction_weights)
+    stop_motor()
+
+    # Ask the user if they want to continue with more runs
+    answer = input(f"Current balancing grade: {last_run.quality_grade_g}. Target grade: {session.quality_grade_g}. "
+                   f"Do you want to continue with more corrections (Y/N)?:")
+    if answer == "Y" or answer == "y":
+        continue
+    break
+
+# Retrieve the data to print the report
+show_balancing_report(core)
+
+print("\nDone.")

flightstand-3.0.0/FlightStand/examples/balancing/simulated.py

@@ -0,0 +1,114 @@
+# This example shows how to connect a simulated hardware and use the propeller balancing feature. In this example
+# the simulated hardware starts with a virtual imbalance, and we run the balancing steps to get it balanced.
+# In your scenario, you should replace the simulated circuit with your own hardware.
+import time
+
+from examples.balancing.utils import show_balancing_report, format_weights
+from FlightStand import FlightStand
+
+print(" **** Running example propeller balancing script with simulated hardware **** ")
+core = FlightStand()
+
+# Connect a simulated board if none already connected
+print("\nConnecting simulated hardware...")
+board = core.create_simulated_board()
+core.print_hardware_list()
+
+# Activate the output at 1000. This is done by first modifying the output fields to set a new target value, and then
+# the update_output command must be called to send the updated values.
+print("\nActivating ESC at 1000")
+output_name = board.name + "/outputs/1"
+esc_output = core.get_output(output_name)
+esc_output.output_target.target_value = 1000
+esc_output.output_target.active = True
+core.update_output(esc_output, ['output_target'])
+time.sleep(0.2)
+
+# Increase the throttle to 1500
+print("\nSetting ESC to 1500")
+esc_output.output_target.target_value = 1500
+core.update_output(esc_output, ['output_target'])
+time.sleep(0.5)
+
+# Do an initial run in the balancing session to get the initial unbalance (simulated hardware has a random unbalance
+# when created)
+rotor_mass_kg = 0.02  # Important to correctly calculate the correction weights
+radius_m = 0.04  # So we can calculate the weight
+core.create_balancing_session(params=core.Proto.BalancingSession(
+    title="Demo balance session on 3-bladed simulated hardware",  # Optional
+    operator_display_name="My name",  # Optional
+    motor_display_name="Motor 1",  # Optional
+    propeller_display_name="Propeller 1",  # Optional
+    rotor_mass=rotor_mass_kg,
+    operating_speed_rad_s=1091,  # In our demo, we go to ESC value 1500 which gives a repeatable rotation speed.
+    quality_grade_g=6.3,  # Optional. 6.3 is common in the industry for propellers (ISO 1940 standard)
+    correction_radius_m=radius_m,
+    rotation_sensor_name=board.name + "/inputs/5",
+    vibration_sensor_name=board.name + "/inputs/8",
+    control_output_name=output_name,
+    blades_count=3
+))
+core.execute_balance_run(False, None)
+
+
+# Retrieve the data to know the trial weight to put
+session = core.get_balancing_session()
+# print_session(session)
+initial_run = session.runs[0]
+
+trial_weights = initial_run.next_corrections
+print("Trial weights: " + format_weights(trial_weights, radius_m))
+
+# Normally done by user, but here we simulate adding a trial weight
+print(f"Putting a simulated trial weight on the simulated hardware")
+sim_settings = core.Proto.UpdateSimulatedBoardSettingsRequest(board_name=board.name)
+sim_settings.settings.correction_weights.extend(trial_weights)
+core.stub.UpdateSimulatedBoardSettings(sim_settings)
+time.sleep(0.5)  # Gives time for the data samples to update
+
+# Confirm the simulated hardware has correction weights applied
+sim_settings = core.stub.GetSimulatedBoardSettings(core.Proto.GetSimulatedBoardSettingsRequest(board_name=board.name))
+print("Confirmed correction weights applied:", sim_settings)
+print("")
+
+# Do the trial run
+print("Executing trial run")
+core.execute_balance_run(False, trial_weights)
+
+# Retrieve the data to know the correction weight to put
+session = core.get_balancing_session()
+# print_session(session)
+trial_run = session.runs[1]
+correction_weights = trial_run.next_corrections
+print("Correction weights: " + format_weights(correction_weights, radius_m))
+
+# Normally done by user, apply the correction weight to achieve a balanced rotor
+sim_settings = core.Proto.UpdateSimulatedBoardSettingsRequest(board_name=board.name)
+sim_settings.settings.correction_weights.extend(correction_weights)
+core.stub.UpdateSimulatedBoardSettings(sim_settings)
+time.sleep(0.5)  # Gives time for the data samples to update
+
+# Do the correction run (will confirm balance is good)
+print("Executing correction run")
+core.execute_balance_run(True, correction_weights)
+
+# Retrieve the data to print the report
+show_balancing_report(core)
+
+# Restore the throttle to 1000
+print("\nSetting ESC to 1000")
+esc_output.output_target.target_value = 1000
+core.update_output(esc_output, ['output_target'])
+time.sleep(1.0)  # Give time for the output change to be applied
+
+# Turn off the ESC output signal
+print("\nTurning off ESC")
+esc_output.output_target.active = False
+core.update_output(esc_output, ['output_target'])
+time.sleep(1.0)  # Give time for the output change to be applied
+
+# Delete the balance run
+core.delete_balance_run(session.name)
+
+print("\nDone.")
+exit()

flightstand-3.0.0/FlightStand/examples/balancing/utils.py

@@ -0,0 +1,159 @@
+import math
+from datetime import timedelta
+
+import numpy as np
+from matplotlib import pyplot as plt
+
+from FlightStand import FlightStand
+
+
+def input_float(prompt):
+    val = input(prompt)
+    if val == "":
+        return 0.0
+    return float(val)
+
+
+# Calculates datapoints for superposing a sine wave function on top of the data, to show correct curvefitting
+def simulate_sine_result(run: FlightStand.Proto.BalanceRun, rotation_speed: list[FlightStand.Proto.DataPoint]):
+    # Sort rotation speed data timestamps
+    rotation_speed_times = [dp.sample_time.ToDatetime() for dp in rotation_speed]
+
+    # Get duration (converting it to seconds) by subtracting smallest timestamp from largest
+    duration = (rotation_speed_times[-1] - rotation_speed_times[0]).total_seconds()
+
+    # Sampling frequency
+    fs = 10000  # 10000 Hz
+
+    # Time vector
+    t = np.arange(0, duration, 1 / fs)
+
+    # Analysis data from the run
+    amp = run.vibration_signal_amplitude
+    phase_offset = run.vibration_signal_phase
+    omega = run.average_rotation_speed
+
+    # Create sine wave
+    sine_values = amp * np.sin(omega * t + phase_offset)
+
+    # Convert the float seconds back to timestamps
+    sine_times = [rotation_speed_times[0] + timedelta(seconds=s) for s in t]
+
+    return sine_times, sine_values
+
+
+def format_number(number) -> str:
+    if number == 0:
+        return "0"
+    digits = math.floor(math.log10(abs(number))) + 1
+    precision = max(0, 3 - digits)
+    format_str = "{:." + str(precision) + "f}"
+    formatted_num = format_str.format(number)
+    return formatted_num[:-1] if formatted_num[-2:] == '.0' else formatted_num
+
+
+def format_weight(weight: FlightStand.Proto.BalanceWeight, correction_radius: float) -> str:
+    if weight.unbalance != 0 and correction_radius != 0:
+        unbalance = format_number(weight.unbalance * 1000.0 / correction_radius)  # Convert from kg⋅m to g⋅m
+        phase_degrees = format_number(math.degrees(weight.phase))
+        result = f"{unbalance} grams {phase_degrees}°"
+        print(weight, " -> ", result)
+        return result
+    return '0 grams 0°'  # return a default string
+
+def format_weights(weights: list[FlightStand.Proto.BalanceWeight], correction_radius: float) -> str:
+    return " & ".join([format_weight(weight, correction_radius) for weight in weights])
+
+def show_balancing_report(core: FlightStand):
+    session = core.get_balancing_session()
+
+    # Create matplotlib figure and axes
+    fig, axs = plt.subplots(len(session.runs))
+
+    #title_text = f'Session ID: {session.name}\n'
+    title_text = f'Title: {session.title}\n'
+    title_text += f'Motor: {session.motor_display_name}\n'
+    title_text += f'Propeller: {session.propeller_display_name}\n'
+    title_text += f'Operator: {session.operator_display_name}\n'
+    title_text += f'Rotor mass (grams): {round(session.rotor_mass * 1000.0, 3)}\n'
+    title_text += f'Operating speed (rpm): {round(session.operating_speed_rad_s * 9.5493, 3)}\n'
+    title_text += f'Target quality grade (g): {round(session.quality_grade_g, 3)}\n'
+    title_text += f'Permissible unbalance (g⋅m): {round(session.permissible_unbalance*1000.0, 6)}\n'
+    title_text += f'Correction radius (cm): {round(session.correction_radius_m * 100.0, 3)}\n'
+    title_text += f'Blades count: {session.blades_count}\n'
+    #title_text += f'Control Output: {session.control_output_name}\n'
+    #title_text += f'Rotation Sensor: {session.rotation_sensor_name}\n'
+    #title_text += f'Vibration Sensor: {session.vibration_sensor_name}'
+
+    # compute the overall maximum from all runs
+    ymax = 0
+
+    fig.suptitle(title_text, fontsize=8, y=0.9)
+    if len(session.runs) == 1:
+        axs = [axs]
+    for i, (run, ax) in enumerate(zip(session.runs, axs), 1):
+        run_data = core.list_balance_run_data(session.name, i-1)
+        vibration_data = run_data.vibration
+        rotation_speed = run_data.rotation_speed
+        run_vib_max = max(dp.value for dp in vibration_data)
+        if run_vib_max > ymax:
+            ymax = run_vib_max
+        title = "Initial run"
+        if i == 2:
+            title = "Trial run"
+        if i > 2:
+            title = f"Correction run {i - 2}/{len(session.runs) - 2}"
+        tol = "in tolerance ✔"
+        if session.quality_grade_g < run.quality_grade_g:
+            tol = "out of tolerance ✘"
+        run_details = (
+            f"\n{title}\n\n"
+            f"Correction weights: {format_weights(run.corrections, session.correction_radius_m)}\n"
+            f"Previous corrections removed: {run.previous_weight_removed}\n"
+            #f"Rotation speed (rpm): {round(run.average_rotation_speed * 9.5493, 3)}\n"
+            #f"Rotation samples: {len(run.rotation_speed_data)}\n"
+            f"Vibration amplitude: {round(run.vibration_signal_amplitude, 3)}\n"
+            #f"Vibration phase: {round(run.vibration_signal_phase, 3)}\n"
+            #f"Vibration SNR: {round(run.vibration_signal_to_noise_ratio, 3)}\n"
+            #f"Vibration samples: {len(run.vibration_data)}\n"
+            f"Quality grade G: {round(run.quality_grade_g, 3)} → {tol}\n"
+            f"Result unbalance: {format_weight(run.unbalance, session.correction_radius_m)}\n"
+            f"Next corrections: {format_weights(run.next_corrections, session.correction_radius_m)}\n"
+        )
+        ax.text(1.05, 0.5, run_details, transform=ax.transAxes, verticalalignment='center', fontsize=6,
+                bbox=dict(facecolor='white', edgecolor='black', boxstyle='round,pad=1'))
+
+        vibration_times = [dp.sample_time.ToDatetime() for dp in vibration_data]
+        vibration_values = [dp.value for dp in vibration_data]
+        rotation_speed_times = [dp.sample_time.ToDatetime() for dp in rotation_speed]
+        sine_times, sine_values = simulate_sine_result(run, rotation_speed)
+
+        start_time = rotation_speed_times[0]
+        vibration_time_diff = [(t - start_time).total_seconds() for t in vibration_times]
+        sine_time_diff = [(t - start_time).total_seconds() for t in sine_times]
+
+        # Calculate new vibration time differences
+        revolution_start_times = [(t - start_time).total_seconds() for t in rotation_speed_times]
+        new_vibration_time_diff = []
+        for vt in vibration_time_diff:
+            revolution_start_time = max((rt for rt in revolution_start_times if rt <= vt), default=0)
+            new_vibration_time_diff.append(vt - revolution_start_time)
+
+        # Plot vibration data with updated time differences
+        ax.plot(new_vibration_time_diff, vibration_values, 'o', markersize=2.0)
+
+        # Plot the sinewave
+        ax.plot(sine_time_diff, sine_values)
+
+        # Add labels
+        ax.set_xlabel('Time (s)')
+        ax.set_ylabel('Vibration')
+
+        # set the same y-axis limits for all sub-plots
+        ax.set_ylim(-ymax, ymax)
+        one_revolution_duration = (rotation_speed_times[1] - rotation_speed_times[0]).total_seconds()
+        ax.set_xlim(0, one_revolution_duration)
+
+    # Show plot
+    plt.tight_layout()
+    plt.show()