Skip to content

hardware

Bms 

Bms(**kwargs)

Bases: Module, ABC

The BMS module communicates with a simple battery management system over a serial connection.

The BMS module provides measured voltages as an event.

is_above_percent 

is_above_percent(value: float) -> bool

Returns whether the battery is charged above the given percentage.

is_above_voltage 

is_above_voltage(value: float) -> bool

Returns whether the battery voltage is above the given value.

is_below_percent 

is_below_percent(value: float) -> bool

Returns whether the battery is charged below the given percentage.

is_below_voltage 

is_below_voltage(value: float) -> bool

Returns whether the battery voltage is below the given value.

BmsHardware 

BmsHardware(
    robot_brain: RobotBrain,
    *,
    expander: ExpanderHardware | None = None,
    name: str = "bms",
    rx_pin: int = 26,
    tx_pin: int = 27,
    baud: int = 9600,
    num: int = 1,
    charge_detect_threshold: float = -0.4
)

Bases: Bms, ModuleHardware

This module implements the hardware interface for the BMS module.

BmsSimulation 

BmsSimulation(
    is_charging: Callable[[], bool] | None = None,
    fixed_voltage: float | None = None,
)

Bases: Bms, ModuleSimulation

This module simulates a BMS module.

Bumper 

Bumper(estop: EStop | None, **kwargs)

Bases: Module, ABC

A module that detects when a bumper is triggered.

BUMPER_TRIGGERED instance-attribute 

BUMPER_TRIGGERED = Event[str]()

a bumper was triggered (argument: the bumper name)

BumperHardware 

BumperHardware(
    robot_brain: RobotBrain,
    *,
    expander: ExpanderHardware | None = None,
    name: str = "bumper",
    pins: dict[str, int],
    estop: EStop | None = None,
    inverted: bool = False
)

Bases: Bumper, ModuleHardware

Hardware implementation of the bumper module.

The module expects a dictionary of pin names and pin numbers. If an e-stop is provided, the module will not trigger bumpers if the e-stop is active.

BumperSimulation 

BumperSimulation(estop: EStop | None, **kwargs)

Bases: Bumper, ModuleSimulation

Simulation of the bumper module.

Communication 

Communication()

Bases: ABC

This abstract module defines an interface for communicating with a microcontroller.

Besides sending and receiving messages a communication module provides a property whether communication is possible. It can also provide a piece of debug UI.

EStop 

EStop(**kwargs)

Bases: Module, ABC

A module that detects when the e-stop is triggered.

The module has a boolean field active that is true when the e-stop is triggered.

There is also a boolean field is_soft_estop_active that is true when the soft e-stop is active. It can be set to true or false by calling set_soft_estop(active: bool).

ESTOP_RELEASED instance-attribute 

ESTOP_RELEASED = Event[[]]()

the e-stop was released

ESTOP_TRIGGERED instance-attribute 

ESTOP_TRIGGERED = Event[[]]()

the e-stop was triggered

EStopHardware 

EStopHardware(
    robot_brain: RobotBrain,
    *,
    name: str = "estop",
    pins: dict[str, int],
    inverted: bool = True
)

Bases: EStop, ModuleHardware

Hardware implementation of the e-stop module.

The module expects a dictionary of pin names and pin numbers.

EStopSimulation 

EStopSimulation(**kwargs)

Bases: EStop, ModuleSimulation

Simulation of the e-stop module.

ExpanderHardware 

ExpanderHardware(
    robot_brain: RobotBrain,
    *,
    name: str = "p0",
    serial: SerialHardware,
    boot: int = 25,
    enable: int = 14
)

Bases: ModuleHardware

The expander module represents a second ESP microcontroller connected to the core ESP via serial.

Gnss 

Gnss()

Bases: ABC

A GNSS module that provides measurements from a GNSS receiver.

NEW_MEASUREMENT instance-attribute 

NEW_MEASUREMENT = Event[GnssMeasurement]()

a new measurement has been received (argument: GnssMeasurement)

GnssHardware 

GnssHardware(
    *,
    antenna_pose: Pose | None,
    reconnect_interval: float = 3.0
)

Bases: Gnss

This hardware module connects to a Septentrio SimpleRTK3b (Mosaic-H) GNSS receiver.

:param antenna_pose: the pose of the main antenna in the robot's coordinate frame (yaw: direction to the auxiliary antenna) :param reconnect_interval: the interval to wait before reconnecting to the device

GnssSimulation 

GnssSimulation(
    *,
    wheels: PoseProvider,
    lat_std_dev: float = 0.01,
    lon_std_dev: float = 0.01,
    heading_std_dev: float = 0.01,
    gps_quality: GpsQuality = GpsQuality.RTK_FIXED
)

Bases: Gnss

Simulation of a GNSS receiver.

:param wheels: the wheels to use for the simulation :param lat_std_dev: the standard deviation of the latitude in meters :param lon_std_dev: the standard deviation of the longitude in meters :param heading_std_dev: the standard deviation of the heading in degrees :param gps_quality: the quality of the GPS signal

Imu 

Imu(offset_rotation: Rotation | None = None, **kwargs)

Bases: Module

A module that provides measurements from an IMU.

NEW_MEASUREMENT instance-attribute 

NEW_MEASUREMENT = Event[ImuMeasurement]()

a new measurement has been received (argument: ImuMeasurement)

ImuHardware 

ImuHardware(
    robot_brain: RobotBrain,
    name: str = "imu",
    *,
    min_gyro_calibration: float = 1.0,
    **kwargs
)

Bases: Imu, ModuleHardware

A hardware module that handles the communication with an IMU.

ImuSimulation 

ImuSimulation(
    *,
    wheels: PoseProvider,
    interval: float = 0.1,
    roll_noise: float = 0.0,
    pitch_noise: float = 0.0,
    yaw_noise: float = 0.0,
    **kwargs
)

Bases: Imu, ModuleSimulation

Simulation of an IMU.

Robot 

Robot(modules: list[Module])

Bases: ABC

A robot that consists of a number of modules.

It can be either a hardware robot or a simulation.

RobotBrain 

RobotBrain(
    communication: Communication,
    *,
    enable_esp_on_startup: bool = True
)

This module manages the communication with a Zauberzeug Robot Brain.

It expects a communication object, which is used for the actual read and write operations. Besides providing some basic methods like configuring or restarting the microcontroller, it augments and verifies checksums for each message.

It also keeps track of the clock offset between the microcontroller and the host system, which is used to synchronize the hardware time with the system time. The clock offset is calculated by comparing the hardware time with the system time and averaging the differences over a number of samples. If the offset changes significantly, a notification is sent and the offset history is cleared.

FLASH_P0_COMPLETE instance-attribute 

FLASH_P0_COMPLETE = Event[[]]()

flashing p0 was successful and 'Replica complete' was received

LINE_RECEIVED instance-attribute 

LINE_RECEIVED = Event[str]()

a line has been received from the microcontroller (argument: line as string)

RobotHardware 

RobotHardware(
    modules: list[Module], robot_brain: RobotBrain
)

Bases: Robot

A robot that consists of hardware modules.

It generates Lizard code, forwards output to the hardware modules and sends commands to the robot brain.

RobotSimulation 

RobotSimulation(modules: list[Module])

Bases: Robot

A robot that consists of simulated modules.

It regularly calls the step method of all modules to allow them to update their internal state.

SerialCommunication 

SerialCommunication(
    *,
    device_path: str | None = None,
    baud_rate: int = 115200
)

Bases: Communication

This module implements a communication via a serial device with a given baud rate.

It contains a list of search paths for finding the serial device.

SerialHardware 

SerialHardware(
    robot_brain: RobotBrain,
    *,
    name: str = "serial",
    rx_pin: int = 26,
    tx_pin: int = 27,
    baud: int = 115200,
    num: int = 1
)

Bases: ModuleHardware

The serial module represents a serial connection with another device.

WebCommunication 

WebCommunication()

Bases: Communication

Remote connection to the Robot Brain's ESP.

This makes it possible to keep developing on your fast computer while communicating with the hardware components connected to a physical Robot Brain.

Wheels 

Wheels(**kwargs)

Bases: Module, ABC

This module represents wheels for a two-wheel differential drive.

Wheels can be moved using the drive methods and provide measured velocities as an event.

WheelsHardware 

WheelsHardware(
    robot_brain: RobotBrain,
    *,
    can: CanHardware,
    name: str = "wheels",
    left_can_address: int = 0,
    right_can_address: int = 256,
    m_per_tick: float = 0.01,
    width: float = 0.5,
    is_left_reversed: bool = False,
    is_right_reversed: bool = False
)

Bases: Wheels, ModuleHardware

This module implements wheels hardware.

Drive and stop commands are forwarded to a given Robot Brain. Velocities are read and emitted regularly.

WheelsSimulation 

WheelsSimulation(width: float = 0.5)

Bases: Wheels, ModuleSimulation

This module simulates two wheels.

Drive and stop commands impact internal velocities (linear and angular). A simulated pose is regularly updated with these velocities, while the velocities are emitted as an event.

angular_velocity instance-attribute 

angular_velocity: float = 0

The current angular velocity of the robot.

friction_factor instance-attribute 

friction_factor: float = 0.0

The factor of friction for the wheels (0 = no friction, 1 = full friction).

inertia_factor instance-attribute 

inertia_factor: float = 0.0

The factor of inertia for the wheels (0 = no inertia, 1 = full inertia).

is_blocking instance-attribute 

is_blocking: bool = False

If True, the wheels are blocking and the robot will not move.

linear_velocity instance-attribute 

linear_velocity: float = 0

The current linear velocity of the robot.

pose instance-attribute 

pose: Pose = Pose(time=time())

Provides the actual pose of the robot which can alter due to slippage.

slip_factor_left instance-attribute 

slip_factor_left: float = 0

The factor of slippage for the left wheel (0 = no slippage, 1 = full slippage).

slip_factor_right instance-attribute 

slip_factor_right: float = 0

The factor of slippage for the right wheel (0 = no slippage, 1 = full slippage).

width instance-attribute 

width: float = width

The distance between the wheels -- used to calculate actual drift when slip_factor_* is used.