viam.components.board

Submodules

Attributes

`Tick`
`TickStream`

Classes

Board

Board represents a physical general purpose compute board that contains various

Package Contents

class viam.components.board.Board(name: str, *, logger: logging.Logger | None = None)[source]

Bases: viam.components.component_base.ComponentBase

Board represents a physical general purpose compute board that contains various components such as analog readers/writers, and digital interrupts.

This acts as an abstract base class for any drivers representing specific board implementations. This cannot be used on its own. If the __init__() function is overridden, it must call the super().__init__() function.

from viam.components.board import Board

For more information, see Board component.

API: Final: The API of the Resource

class Analog(name: str)[source]

Analog represents an analog pin reader or writer that resides on a Board.

name: str: The name of the analog pin

Value: TypeAlias = ReadAnalogReaderResponse

Value contains the result of reading an analog reader. It contains the raw data read, the reader’s minimum and maximum possible values, and its step size (the minimum possible change between values it can read).

For more information, see analogs.

abstract read(*, extra: Dict[str, Any] | None = None, timeout: float | None = None, **kwargs) → Value[source]

Async:

Read the current value from the reader.

my_board = Board.from_robot(robot=machine, name="my_board")

# Get the Analog "my_example_analog_reader".
reader = await my_board.analog_by_name(
    name="my_example_analog_reader")

# Get the value of the digital signal "my_example_analog_reader" has most
# recently measured.
reading = await reader.read()

Returns:: The current value, including the min, max, and step_size of the reader.
Return type:: Value

For more information, see Board component Analog API.

abstract write(value: int, *, extra: Dict[str, Any] | None = None, timeout: float | None = None, **kwargs)[source]

Async:

Write a value to the Analog writer.

my_board = Board.from_robot(robot=machine, name="my_board")

# Get the Analog "my_example_analog_writer".
writer = await my_board.analog_by_name(
    name="my_example_analog_writer")

await writer.write(42)

Parameters:: value (int) – Value to write to the analog writer.

For more information, see Board component Analog API.

class DigitalInterrupt(name: str)[source]

DigitalInterrupt represents a configured interrupt on the Board that when interrupted, calls the added callbacks. Post processors can be added to modify what Value it ultimately returns.

For more information, see digital_interrupts.

name: str: The name of the digital interrupt.

abstract value(*, extra: Dict[str, Any] | None = None, timeout: float | None = None, **kwargs) → int[source]

Async:

Get the current value of the interrupt, which is based on the type of interrupt.

my_board = Board.from_robot(robot=machine, name="my_board")

# Get the DigitalInterrupt "my_example_digital_interrupt".
interrupt = await my_board.digital_interrupt_by_name(
    name="my_example_digital_interrupt")

# Get the amount of times this DigitalInterrupt has been interrupted with a
# tick.
count = await interrupt.value()

Returns:: The current value.
Return type:: int

For more information, see Board component DigitalInterrupt API.

class GPIOPin(name: str)[source]

Abstract representation of an individual GPIO pin on a board.

name: str: The name of the GPIO pin.

abstract set(high: bool, *, extra: Dict[str, Any] | None = None, timeout: float | None = None, **kwargs)[source]

Async:

Set the pin to either low or high.

my_board = Board.from_robot(robot=machine, name="my_board")

# Get the GPIOPin with pin number 15.
pin = await my_board.gpio_pin_by_name(name="15")

# Set the pin to high.
await pin.set(high=True)

Parameters:: high (bool) – When true, sets the pin to high. When false, sets the pin to low.