Block library

The block diagrams comprise blocks which belong to one of a number of different categories. These come from the package bdsim.blocks, roboticstoolbox.blocks, machinevisiontoolbox.blocks.

Icons, if shown to the left of the black header bar, are as used with bdedit.

Inheritance diagram of bdsim.components.SourceBlock, bdsim.components.SinkBlock, bdsim.graphics.GraphicsBlock, bdsim.components.FunctionBlock, bdsim.components.TransferBlock, bdsim.components.SubsystemBlock

Source blocks

Source blocks:

  • have outputs but no inputs

  • have no state variables

  • are a subclass of SourceBlockBlock

class bdsim.blocks.sources.Constant(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SourceBlock

CONSTANT

inputs

outputs

states

0

1

0

float, A(N,)

__init__(value=None, **blockargs)[source]

Constant value.

Parameters
Returns

a CONSTANT block

Return type

Constant instance

This block has only one output port, but the value can be any Python type, for example float, list or Numpy ndarray.

class bdsim.blocks.sources.Piecewise(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SourceBlock

PIECEWISE

inputs

outputs

states

0

1

0

float

__init__(*seq, **blockargs)[source]

Piecewise constant signal.

Parameters
  • seq (list of 2-tuples) – sequence of time, value pairs

  • blockargs (dict) – common Block options

Returns

a PIECEWISE block

Return type

Piecewise instance

Outputs a piecewise constant function of time. This is described as a series of 2-tuples (time, value). The output value is taken from the active tuple, that is, the latest one in the list whose time is no greater than simulation time.

Note

  • The tuples must be order by monotonically increasing time.

  • There is no default initial value, the list should contain a tuple with time zero otherwise the output will be undefined.

Note

The block declares an event for the start of each segment.

Seealso

declare_events()

class bdsim.blocks.sources.Ramp(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SourceBlock

RAMP

inputs

outputs

states

0

1

0

float

__init__(T=1, off=0, slope=1, **blockargs)[source]

Ramp signal.

Parameters
  • T (float, optional) – time of ramp start, defaults to 1

  • off (float, optional) – initial value, defaults to 0

  • slope (float, optional) – gradient of slope, defaults to 1

  • blockargs (dict) – common Block options

Returns

a RAMP block

Return type

Ramp

Output a ramp signal that starts increasing from the value off when time equals T linearly with time, with a gradient of slope.

Note

The block declares an event for the ramp start time.

Seealso

:method:`declare_event`

class bdsim.blocks.sources.Step(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SourceBlock

STEP

inputs

outputs

states

0

1

0

float

__init__(T=1, off=0, on=1, **blockargs)[source]

Step signal.

Parameters
  • T (float, optional) – time of step, defaults to 1

  • off (float, optional) – initial value, defaults to 0

  • on (float, optional) – final value, defaults to 1

  • blockargs (dict) – common Block options

Returns

a STEP block

Return type

Step

Output a step signal that transitions from the value off to on when time equals T.

Note

The block declares an event for the step time.

Seealso

declare_events()

class bdsim.blocks.sources.Time(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SourceBlock

TIME

inputs

outputs

states

0

1

0

float

__init__(value=None, **blockargs)[source]

Simulation time.

Parameters

blockargs (dict) – common Block options

Returns

a TIME block

Return type

Time instance

The block has only one output port which is the current simulation time.

class bdsim.blocks.sources.WaveForm(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SourceBlock

WAVEFORM

inputs

outputs

states

0

1

0

float

__init__(wave='square', freq=1, unit='Hz', phase=0, amplitude=1, offset=0, min=None, max=None, duty=0.5, **blockargs)[source]

Waveform as function of time.

Parameters
  • wave (str, optional) – type of waveform to generate, one of: ‘sine’, ‘square’, ‘triangle’, defaults to ‘square’

  • freq (float, optional) – frequency, defaults to 1

  • unit (str, optional) – frequency unit, one of: ‘rad/s’, ‘Hz’, defaults to ‘Hz’

  • amplitude (float, optional) – amplitude, defaults to 1

  • offset (float, optional) – signal offset, defaults to 0

  • phase (float, optional) – Initial phase of signal in the range [0,1], defaults to 0

  • min (float, optional) – minimum value, defaults to 0

  • max (float, optional) – maximum value, defaults to 1

  • duty (float, optional) – duty cycle for square wave in range [0,1], defaults to 0.5

  • blockargs (dict) – common Block options

Returns

a WAVEFORM block

Return type

WaveForm instance

Create a waveform generator block.

Examples:

WAVEFORM(wave='sine', freq=2)   # 2Hz sine wave varying from -1 to 1
WAVEFORM(wave='square', freq=2, unit='rad/s') # 2rad/s square wave varying from -1 to 1

The minimum and maximum values of the waveform are given by default in terms of amplitude and offset. The signals are symmetric about the offset value. For example:

WAVEFORM(wave='sine') varies between -1 and +1
WAVEFORM(wave='sine', amplitude=2) varies between -2 and +2
WAVEFORM(wave='sine', offset=1) varies between 0 and +2
WAVEFORM(wave='sine', amplitude=2, offset=1) varies between -1 and +3

Alternatively we can specify the minimum and maximum values which override amplitude and offset:

WAVEFORM(wave='triangle', min=0, max=5) varies between 0 and +5

At time 0 the sine and triangle wave are zero and increasing, and the square wave has its first rise. We can specify a phase shift with a number in the range [0,1] where 1 corresponds to one cycle.

Note

For discontinuous signals (square, triangle) the block declares events for every discontinuity.

:seealso declare_events()

Sink blocks

Sink blocks:

  • have inputs but no outputs

  • have no state variables

  • are a subclass of SinkBlockBlock

  • that perform graphics are a subclass of GraphicsBlockSinkBlockBlock

class bdsim.blocks.sinks.Null(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SinkBlock

NULL

inputs

outputs

states

N

0

0

any

__init__(nin=1, **blockargs)[source]

Discard signal.

Parameters
  • nin (int, optional) – number of input ports, defaults to 1

  • blockargs (dict) – common Block options

Returns

A NULL block

Return type

Null instance

Create a sink block with arbitrary number of input ports that discards all data. Useful for testing.

class bdsim.blocks.sinks.Print(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SinkBlock

PRINT

inputs

outputs

states

1

0

0

any

__init__(fmt=None, file=None, **blockargs)[source]

Print signal.

Parameters
  • fmt (str, optional) – Format string, defaults to None

  • file (file object, optional) – file to write data to, defaults to None

  • blockargs (dict) – common Block options

Returns

A PRINT block

Return type

Print instance

Creates a console print block which displays the value of a signal at each simulation time step. The display format is like:

PRINT(print.0 @ t=0.100) [-1.0 0.2]

and includes the block name, time, and the formatted value.

The numerical formatting of the signal is controlled by fmt:

  • if not provided, str() is used to format the signal

  • if provided:
    • a scalar is formatted by the fmt.format()

    • a NumPy array is formatted by fmt.format() applied to every element

Examples:

pr = bd.PRINT()     # create PRINT block
bd.connect(x, inputs=pr)   # its input comes from x

bd.PRINT(x)         # create PRINT block with input from x

bd.PRINT(x, name='X')  # block name appears in the printed text

bd.PRINT(x, fmt="{:.1f}") # print with explicit format

Note

  • By default writes to stdout

  • The output is cleaner if progress bar printing is disabled.

class bdsim.blocks.sinks.Stop(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SinkBlock

STOP

inputs

outputs

states

1

0

0

any

__init__(func=None, **blockargs)[source]

Conditional simulation stop.

Parameters
  • func (callable, optional) – evaluate stop condition, defaults to None

  • blockargs (dict) – common Block options

Returns

A STOP block

Return type

Stop instance

Conditionally stop the simulation if the input is:

  • bool type and True

  • numeric type and > 0

If func is provided, then it is applied to the block input and if it returns True the simulation is stopped.

class bdsim.blocks.sinks.Watch(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SinkBlock

WATCH

inputs

outputs

states

N

0

0

1

__init__(**blockargs)[source]

Watch a signal.

Parameters

blockargs (dict) – common Block options

Returns

A NULL block

Return type

Null instance

Causes the input signal to be logged during the simulation run. Equivalent to adding it as the watch= argument to bdsim.run.

Seealso

:method:`BDSim.run`

Function blocks

Function blocks:

  • have inputs and outputs

  • have no state variables

  • are a subclass of FunctionBlockBlock

class bdsim.blocks.functions.Clip(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

CLIP

inputs

outputs

states

1

1

0

float, A(N,)

float, A(N,)

__init__(min=- inf, max=inf, **blockargs)[source]

Signal clipping.

Parameters
  • min (float or array_like, optional) – Minimum value, defaults to -math.inf

  • max (float or array_like, optional) – Maximum value, defaults to math.inf

  • blockargs (dict) – common Block options

Returns

A CLIP block

Return type

Clip instance

The input signal is clipped to the range from minimum to maximum inclusive.

The signal can be a 1D-array in which case each element is clipped. The minimum and maximum values can be:

  • a scalar, in which case the same value applies to every element of the input vector , or

  • a 1D-array, of the same shape as the input vector that applies elementwise to the input vector.

For example:

clip = bd.CLIP()
class bdsim.blocks.functions.Function(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

FUNCTION

inputs

outputs

states

nin

nout

0

any

any

__init__(func=None, nin=1, nout=1, persistent=False, args=None, kwargs=None, **blockargs)[source]

Python function.

Parameters
  • func (callable or sequence of callables, optional) – A function or lambda, or list thereof, defaults to None

  • nin (int, optional) – number of inputs, defaults to 1

  • nout (int, optional) – number of outputs, defaults to 1

  • persistent (bool, optional) – pass in a reference to a dictionary instance to hold persistent state, defaults to False

  • args (list, optional) – extra positional arguments passed to the function, defaults to []

  • kwargs (dict, optional) – extra keyword arguments passed to the function, defaults to {}

  • blockargs (dict, optional) – common Block options

Returns

A FUNCTION block

Return type

A Function instance

Inputs to the block are passed as separate arguments to the function. Programmatic ositional or keyword arguments can also be passed to the function.

A block with one output port that sums its two input ports is:

FUNCTION(lambda u1, u2: u1+u2, nin=2)

A block with a function that takes two inputs and has two additional arguments:

def myfun(u1, u2, param1, param2):
    pass

FUNCTION(myfun, nin=2, args=(p1,p2))

If we need access to persistent (static) data, to keep some state:

def myfun(u1, u2, param1, param2, state):
    pass

FUNCTION(myfun, nin=2, args=(p1,p2), persistent=True)

where a dictionary is passed in as the last argument and which is kept from call to call.

A block with a function that takes two inputs and additional keyword arguments:

def myfun(u1, u2, param1=1, param2=2, param3=3, param4=4):
    pass

FUNCTION(myfun, nin=2, kwargs=dict(param2=7, param3=8))

A block with two inputs and two outputs, the outputs are defined by two lambda functions with the same inputs:

FUNCTION( [ lambda x, y: x_t, lambda x, y: x* y])

A block with two inputs and two outputs, the outputs are defined by a single function which returns a list:

def myfun(u1, u2):
    return [ u1+u2, u1*u2 ]

FUNCTION( myfun, nin=2, nout=2)

For example:

func = bd.FUNCTION(myfun, args)

If inputs are specified then connections are automatically made and are assigned to sequential input ports:

func = bd.FUNCTION(myfun, block1, block2, args)

is equivalent to:

func = bd.FUNCTION(myfun, args)
bd.connect(block1, func[0])
bd.connect(block2, func[1])
class bdsim.blocks.functions.Gain(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

GAIN

inputs

outputs

states

1

1

0

float, A(N,), A(N,M)

float, A(N,), A(N,M)

__init__(K=1, premul=False, **blockargs)[source]

Gain block.

Parameters
  • K (array_like) – The gain value, defaults to 1

  • premul (bool, optional) – premultiply by constant, default is postmultiply, defaults to False

  • blockargs (dict) – common Block options

Returns

A GAIN block

Return type

Gain instance

Scale the input signal. If the input is \(u\) the output is \(u K\).

Either or both the input and gain can be Numpy arrays and Numpy will compute the appropriate product \(u K\).

If \(u\) and K are both NumPy arrays the @ operator is used and \(u\) is postmultiplied by the gain. To premultiply by the gain, to compute \(K u\) use the premul option.

For example:

gain = bd.GAIN(constant)
class bdsim.blocks.functions.Interpolate(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

INTERPOLATE

inputs

outputs

states

0 or 1

1

0

float

any

__init__(x=None, y=None, xy=None, time=False, kind='linear', **blockargs)[source]

Interpolate signal.

Parameters
  • x (array_like, shape (N,) optional) – x-values of function, defaults to None

  • y (array_like, optional) – y-values of function, defaults to None

  • xy (array_like, optional) – combined x- and y-values of function, defaults to None

  • time (bool, optional) – x new is simulation time, defaults to False

  • kind (str, optional) – interpolation method, defaults to ‘linear’

  • blockargs (dict) – common Block options

Returns

An INTERPOLATE block

Return type

An Interpolate instance

Interpolate the input signal using to a piecewise function.

A simple triangle function with domain [0,10] and range [0,1] can be defined by:

INTERPOLATE(x=(0,5,10), y=(0,1,0))

We might also express this as a list of 2D-coordinats:

INTERPOLATE(xy=[(0,0), (5,1), (10,0)])

The data can also be expressed as Numpy arrays. If that is the case, the interpolation function can be vector valued. x has a shape of (N,1) and y has a shape of (N,M). Alternatively xy has a shape of (N,M+1) and the first column is the x-data.

The input to the interpolator comes from:

  • Input port 0

  • Simulation time, if time=True. In this case the block has no input ports and is a Source not a Function.

class bdsim.blocks.functions.Prod(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

PROD

inputs

outputs

states

len(ops)

1

0

float, A(N,), A(N,M)

float, A(N,), A(N,M)

__init__(ops='**', matrix=False, **blockargs)[source]

Product junction.

Parameters
  • ops (str, optional) – operations associated with input ports, accepted characters: * or /, defaults to ‘**’

  • inputs (Block or Plug) – Optional incoming connections

  • matrix (bool, optional) – Arguments are matrices, defaults to False

  • blockargs (dict) – common Block options

Returns

A PROD block

Return type

Prod instance

Multiply or divide input signals according to the ops string. The number of input ports is the length of this string.

For example:

prod = PROD('*/*')

is a 3-input product junction which computes port0 / port 1 * port2.

Implicit PROD blocks are created by:

sum = block1  block2

which will create a summation block named “_prod.N”.

Note

  • The inputs can be scalars or NumPy arrays.

  • By default the * and / operators are used.

  • The option matrix will instead use @ and @ np.linalg.inv(). - the shapes of matrices must conform. - only square matrices are supported.

class bdsim.blocks.functions.Sum(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

SUM

inputs

outputs

states

len(signs)

1

0

float, A(N,), A(N,M)

float, A(N,), A(N,M)

__init__(signs='++', angles=False, **blockargs)[source]

Summing junction.

Parameters
Returns

A SUM block

Return type

Sum instance

Add or subtract input signals according to the signs string. The number of input ports is the length of this string.

For example:

sum = bd.SUM('+-+')

is a 3-input summing junction which computes port0 - port1 + port2.

Implicit SUM blocks are created by:

sum = block1 + block2

which will create a summation block named “_sum.N”.

Note

The signals must be compatible, all scalars, or all arrays of the same shape.

Transfer blocks

Transfer blocks:

  • have inputs and outputs

  • have state variables

  • are a subclass of TransferBlockBlock

class bdsim.blocks.transfers.Integrator(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.TransferBlock

INTEGRATOR

inputs

outputs

states

1

1

N

float, A(N,)

float, A(N,)

__init__(x0=0, min=None, max=None, **blockargs)[source]

Integrator.

Parameters
  • x0 (array_like, optional) – Initial state, defaults to 0

  • min (float or array_like, optional) – Minimum value of state, defaults to None

  • max (float or array_like, optional) – Maximum value of state, defaults to None

  • blockargs (dict) – common Block options

Returns

an INTEGRATOR block

Return type

Integrator instance

Output is the time integral of the input. The state can be a scalar or a vector. The initial state, and type, is given by x0. The shape of the input signal must match x0.

The minimum and maximum values can be:

  • a scalar, in which case the same value applies to every element of the state vector, or

  • a vector, of the same shape as x0 that applies elementwise to the state.

class bdsim.blocks.transfers.LTI_SISO(*args, bd=None, **kwargs)[source]

Bases: bdsim.blocks.transfers.LTI_SS

LTI_SISO

inputs

outputs

states

1

1

n

float

float

__init__(N=1, D=[1, 1], x0=None, **blockargs)[source]

SISO LTI dynamics.

Parameters
  • N (array_like, optional) – numerator coefficients, defaults to 1

  • D (array_like, optional) – denominator coefficients, defaults to [1,1]

  • x0 (array_like, optional) – initial states, defaults to None

  • blockargs (dict) – common Block options

Returns

A SCOPE block

Return type

LTI_SISO instance

Implements the dynamics of a single-input single-output (SISO) linear time invariant (LTI) system described by numerator and denominator polynomial coefficients.

Coefficients are given in the order from highest order to zeroth order, ie. \(2s^2 - 4s +3\) is [2, -4, 3].

Only proper transfer functions, where order of numerator is less than denominator are allowed.

The order of the states in x0 is consistent with controller canonical form.

Examples:

LTI_SISO(N=[1, 2], D=[2, 3, -4])

is the transfer function \(\frac{s+2}{2s^2+3s-4}\).

class bdsim.blocks.transfers.LTI_SS(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.TransferBlock

LTI_SS

inputs

outputs

states

1

1

nc

float, A(nb,)

float, A(nc,)

__init__(A=None, B=None, C=None, x0=None, **blockargs)[source]

State-space LTI dynamics.

Parameters
  • N (array_like, optional) – numerator coefficients, defaults to 1

  • D (array_like, optional) – denominator coefficients, defaults to [1,1]

  • x0 (array_like, optional) – initial states, defaults to None

  • blockargs (dict) – common Block options

Returns

A SCOPE block

Return type

LTI_SISO instance

Implements the dynamics of a single-input single-output (SISO) linear time invariant (LTI) system described by numerator and denominator polynomial coefficients.

Coefficients are given in the order from highest order to zeroth order, ie. \(2s^2 - 4s +3\) is [2, -4, 3].

Only proper transfer functions, where order of numerator is less than denominator are allowed.

The order of the states in x0 is consistent with controller canonical form.

Examples:

LTI_SISO(N=[1,2], D=[2, 3, -4])

is the transfer function \(\frac{s+2}{2s^2+3s-4}\).

class bdsim.blocks.transfers.PoseIntegrator(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.TransferBlock

POSEINTEGRATOR

inputs

outputs

states

1

1

N

A(N,)

A(N,)

__init__(x0=None, **blockargs)[source]

Pose integrator

Parameters
Returns

an INTEGRATOR block

Return type

Integrator instance

This block integrates spatial velocity over time. The block input is a spatial velocity as a 6-vector \((v_x, v_y, v_z, \omega_x, \omega_y, \omega_z)\) and the output is pose as an SE3 instance.

Note

State is a velocity twist.

Warning

NOT WORKING YET

Discrete-time blocks

Transfer blocks:

  • have inputs and outputs

  • have state variables

  • are a subclass of TransferBlockBlock

class bdsim.blocks.discrete.DIntegrator(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.ClockedBlock

DINTEGRATOR

inputs

outputs

states

1

1

N

float, A(N,)

float, A(N,)

__init__(clock, x0=0, gain=1.0, min=None, max=None, **blockargs)[source]

Discrete-time integrator.

Parameters
  • clock (Clock) – clock source

  • x0 (array_like, optional) – Initial state, defaults to 0

  • min (float or array_like, optional) – Minimum value of state, defaults to None

  • max (float or array_like, optional) – Maximum value of state, defaults to None

  • blockargs (dict) – common Block options

Returns

an INTEGRATOR block

Return type

Integrator instance

Create a discrete-time integrator block.

Output is the time integral of the input. The state can be a scalar or a vector, this is given by the type of x0.

The minimum and maximum values can be:

  • a scalar, in which case the same value applies to every element of the state vector, or

  • a vector, of the same shape as x0 that applies elementwise to the state.

next()[source]
class bdsim.blocks.discrete.DPoseIntegrator(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.ClockedBlock

DPOSEINTEGRATOR

inputs

outputs

states

1

1

N

A(6,)

SE3

__init__(clock, x0=None, **blockargs)[source]

Discrete-time spatial velocity integrator.

Parameters
  • clock (Clock) – clock source

  • x0 (SE3, optional) – Initial pose, defaults to null

  • blockargs (dict) – common Block options

Returns

an DPOSEINTEGRATOR block

Return type

Integrator instance

This block integrates spatial velocity over time. The block input is a spatial velocity as a 6-vector \((v_x, v_y, v_z, \omega_x, \omega_y, \omega_z)\) and the output is pose as an SE3 instance.

Note

State is a velocity twist.

next()[source]
class bdsim.blocks.discrete.ZOH(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.ClockedBlock

ZOH

inputs

outputs

states

1

1

N

float, A(N,)

float, A(N,)

__init__(clock, x0=0, **blockargs)[source]

Zero-order hold.

Parameters
  • clock (Clock) – clock source

  • x0 (array_like, optional) – Initial value of the hold, defaults to 0

  • blockargs (dict) – common Block options

Returns

a ZOH block

Return type

Integrator instance

Output is the input at the previous clock time. The state can be a scalar or a vector, this is given by the type of x0.

Note

If input is not a scalar, x0 must have the shape of the input signal.

next()[source]

Linear algebra blocks

Linear algebra blocks:

  • have inputs and outputs

  • have no state variables

  • are a subclass of FunctionBlockBlock

class bdsim.blocks.linalg.Cond(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

COND

inputs

outputs

states

1

1

0

A(N,M)

float

__init__(**blockargs)[source]

Compute the matrix condition number.

Parameters

blockargs (dict) – common Block options

Returns

A COND block

Return type

Cond instance

Seealso

numpy.linalg.cond()

class bdsim.blocks.linalg.Det(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

DET

inputs

outputs

states

1

1

0

A(N,N)

float

__init__(**blockargs)[source]

Matrix determinant

Parameters

blockargs (dict) – common Block options

Returns

A DET block

Return type

Det instance

Compute the matrix determinant.

Seealso

numpy.linalg.inv()

class bdsim.blocks.linalg.Flatten(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

FLATTEN

inputs

outputs

states

1

1

0

A(N,M )

A(NM,)

__init__(order='C', **blockargs)[source]

Flatten a multi-dimensional array.

Parameters
  • order (str) – flattening order, either “C” or “F”, defaults to “C”

  • blockargs (dict) – common Block options

Returns

A FLATTEN block

Return type

Flatten instance

Flattens the incoming array in either row major (‘C’) or column major (‘F’) order.

Seealso

numpy.flatten()

class bdsim.blocks.linalg.Inverse(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

INVERSE

inputs

outputs

states

1

2

0

A(M,N)

A(N,M) float

__init__(pinv=False, **blockargs)[source]

Matrix inverse.

Parameters
  • pinv (bool, optional) – force pseudo inverse, defaults to False

  • blockargs (dict) – common Block options

Returns

An INVERSE block

Return type

Inverse instance

Compute inverse of the 2D-array input signal. If the matrix is square the inverse is computed unless the pinv flag is True. For a non-square matrix the pseudo-inverse is used. The condition number is output on the second port.

Seealso

numpy.linalg.inv() numpy.linalg.pinv() numpy.linalg.cond()

onames = ('inv', 'cond')
class bdsim.blocks.linalg.Norm(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

NORM

inputs

outputs

states

1

1

0

A(N,) A(N,M)

float

__init__(ord=None, axis=None, **blockargs)[source]

Array norm.

Parameters
  • axis (int, optional) – specifies the axis along which to compute the vector norms, defaults to None.

  • ord (int or str) – Order of the norm, default to None.

  • blockargs (dict) – common Block options

Returns

A NORM block

Return type

Norm instance

Computes the specified norm for a 1D- or 2D-array.

Seealso

numpy.linalg.norm()

class bdsim.blocks.linalg.Slice1(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

SLICE1

inputs

outputs

states

1

1

0

A(N)

A(M)

__init__(index, **blockargs)[source]

Slice out subarray of 1D-array.

Parameters
Returns

A SLICE1 block

Return type

Slice1 instance

Compute a 1D slice of input 1D array.

If index is None it means all elements.

If index is a list, perform NumPy fancy indexing, returning the specified elements

Example:

SLICE1(index=[2,3]) # return elements 2 and 3 as a 1D array
SLICE1(index=[2])   # return element 2 as a 1D array
SLICE1(index=2)     # return element 2 as a NumPy scalar

If index is a tuple, it must have three elements. It describes a Python slice (start, stop, step) where any element can be None

  • start=None means start at first element

  • stop=None means finish at last element

  • step=None means step by one

rows=None is equivalent to rows=(None, None, None).

Example:

SLICE1(index=(None,None,2))  # return every second element
SLICE1(index=(None,None,-1)) # reverse the elements
Seealso

Slice1

class bdsim.blocks.linalg.Slice2(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

SLICE2

inputs

outputs

states

1

1

0

A(N,M)

A(K,L)

__init__(rows=None, cols=None, **blockargs)[source]

Slice out subarray of 2D-array.

Parameters
  • rows (tuple(3) or list) – row selection, defaults to None

  • cols (tuple(3) or list) – column selection, defaults to None

  • blockargs (dict) – common Block options

Returns

A SLICE2 block

Return type

Slice2 instance

Compute a 2D slice of input 2D array.

If rows or cols is None it means all rows or columns respectively.

If rows or cols is a list, perform NumPy fancy indexing, returning the specified rows or columns

Example:

SLICE2(rows=[2,3])  # return rows 2 and 3, all columns
SLICE2(cols=[4,1])  # return columns 4 and 1, all rows
SLICE2(rows=[2,3], cols=[4,1]) # return elements [2,4] and [3,1] as a 1D array

If a single row or column is selected, the result will be a 1D array

If rows or cols is a tuple, it must have three elements. It describes a Python slice (start, stop, step) where any element can be None

  • start=None means start at first element

  • stop=None means finish at last element

  • step=None means step by one

rows=None is equivalent to rows=(None, None, None).

Example:

SLICE2(rows=(None,None,2))  # return every second row
SLICE2(cols=(None,None,-1)) # reverse the columns

The list and tuple notation can be mixed, for example, one for rows and one for columns.

Seealso

Slice1 Index

class bdsim.blocks.linalg.Transpose(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

TRANSPOSE

inputs

outputs

states

1

1

0

A(M,N)

A(N,M)

__init__(**blockargs)[source]

Matrix transpose.

Parameters

blockargs (dict) – common Block options

Returns

A TRANSPOSE block

Return type

Transpose instance

Compute transpose of the 2D-array input signal.

Note

  • An input 1D-array of shape (N,) is turned into a 2D-array column vector with shape (N,1).

  • An input 2D-array column vector of shape (N,1) becomes a 2D-array

row vector with shape (1,N).

Seealso

numpy.transpose()

Connection blocks

Connection blocks are in two categories:

  1. Signal manipulation:
    • have inputs and outputs

    • have no state variables

    • are a subclass of FunctionBlockBlock

  2. Subsystem support
    • have inputs or outputs

    • have no state variables

    • are a subclass of SubsysytemBlockBlock

class bdsim.blocks.connections.DeMux(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

DEMUX

inputs

outputs

states

1

nout

0

float, A(nout,)

float

__init__(nout=1, **kwargs)[source]

Demultiplex signals.

Parameters
Returns

A DEMUX block

Return type

DeMux instance

This block has a single input port and nout output ports. A 1D-array input signal (with nout elements) is routed element-wise to individual scalar output ports.

class bdsim.blocks.connections.Dict(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

DICT

inputs

outputs

states

N

1

0

any

dict

__init__(item, **kwargs)[source]

Create a dictionary signal.

Parameters
Returns

A DICT block

Return type

Dict instance

Inputs are assigned to a dictionary signal, using the corresponding names from keys. For example:

DICT(['x', 'xd', 'xdd'])

expects three inputs and assigns them to dictionary items x, xd, xdd of the output dictionary respectively.

A dictionary signal can serve a similar purpose to a “bus” in Simulink(R).

This is somewhat like a multiplexer Mux but allows for named heterogeneous data.

Seealso

Item Mux

class bdsim.blocks.connections.InPort(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SubsystemBlock

INPORT

inputs

outputs

states

0

nout

0

any

__init__(nout=1, **kwargs)[source]

Input ports for a subsystem.

Parameters
  • nout (int, optional) – Number of output ports, defaults to 1

  • kwargs (dict) – common Block options

Returns

An INPORT block

Return type

InPort instance

This block connects a subsystem to a parent block diagram. Inputs to the parent-level SubSystem block appear as the outputs of this block.

Note

Only one INPORT block can appear in a block diagram but it can have multiple ports. This is different to Simulink(R) which would require multiple single-port input blocks.

class bdsim.blocks.connections.Index(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

INDEX

inputs

outputs

states

1

1

0

ndarray

ndarray

__init__(index=[], **kwargs)[source]

Index an iterable signal.

Parameters
  • index (list, slice or str, optional) – elements of input array, defaults to []

  • kwargs (dict) – common Block options

Returns

An INDEX block

Return type

Index instance

The specified element(s) of the input iterable (list, string, etc.) are output. The index can be an integer, sequence of integers, a Python slice object, or a string with Python slice notation, eg. "::-1".

Seealso

Slice1 Slice2

class bdsim.blocks.connections.Item(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

ITEM

inputs

outputs

states

1

1

0

dict

any

__init__(item, **kwargs)[source]

Selector item from a dictionary signal.

Parameters
Returns

An ITEM block

Return type

Item instance

For a dictionary type input signal, select one item as the output signal. For example:

ITEM('xd')

selects the xd item from the dictionary signal input to the block.

A dictionary signal can serve a similar purpose to a “bus” in Simulink(R).

This is somewhat like a demultiplexer DeMux but allows for named heterogeneous data.

Seealso

Dict

class bdsim.blocks.connections.Mux(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

MUX

inputs

outputs

states

nin

1

0

float, A(N,)

A(M,) A(M,)

__init__(nin=1, **kwargs)[source]

Multiplex signals.

Parameters
  • nin (int, optional) – Number of input ports, defaults to 1

  • kwargs (dict) – common Block options

Returns

A MUX block

Return type

Mux instance

This block takes a number of scalar or 1D-array signals and concatenates them into a single 1-D array signal. For example:

MUX(2, inputs=(func1[2], sum3))

multiplexes the outputs of blocks func1 (port 2) and sum3 into a single output vector as a 1D-array.

Seealso

Dict

class bdsim.blocks.connections.OutPort(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SubsystemBlock

OUTPORT

inputs

outputs

states

nin

0

0

any

__init__(nin=1, **kwargs)[source]

Output ports for a subsystem.

Parameters
  • nin (int, optional) – Number of input ports, defaults to 1

  • kwargs (dict) – common Block options

Returns

A OUTPORT block

Return type

OutPort instance

This block connects a subsystem to a parent block diagram. The the inputs of this block become the outputs of the parent-level SubSystem block.

Note

Only one OUTPORT block can appear in a block diagram but it can have multiple ports. This is different to Simulink(R) which would require multiple single-port output blocks.

class bdsim.blocks.connections.SubSystem(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SubsystemBlock

SUBSYSTEM

inputs

outputs

states

ss.in.nout

ss.out.nin

0

any

any

__init__(subsys, nin=1, nout=1, **kwargs)[source]

Instantiate a subsystem.

Parameters
  • subsys (str or BlockDiagram) – Subsystem as either a filename or a BlockDiagram instance

  • nin (int, optional) – Number of input ports, defaults to 1

  • nout (int, optional) – Number of output ports, defaults to 1

  • kwargs (dict) – common Block options

Raises
  • ImportError – DESCRIPTION

  • ValueError – DESCRIPTION

Returns

A SUBSYSTEM block

Return type

SubSystem instance

This block represents a subsystem in a block diagram. The definition of the subsystem can be:

  • the name of a module which is imported and must contain only only BlockDiagram instance, or

  • a BlockDiagram instance

The referenced block diagram must contain one or both of:

  • one InPort block, which has outputs but no inputs. These outputs are connected to the inputs to the enclosing SubSystem block.

  • one OutPort block, which has inputs but no outputs. These inputs are connected to the outputs to the enclosing SubSystem block.

  • The referenced block diagram is treated like a macro and copied into the parent block diagram at compile time. The SubSystem, InPort and OutPort blocks are eliminated, that is, all hierarchical structure is lost.

  • The same subsystem can be used multiple times, its blocks and wires

    will be cloned. Subsystems can also include subsystems.

  • The number of input and output ports is not specified, they are computed from the number of ports on the InPort and OutPort blocks within the subsystem.

External Toolbox blocksets

These blocks are defined within external Toolboxes or packages.

Robot blocks

These blocks are defined within the Robotics Toolbox for Python.

Arm robots

class roboticstoolbox.blocks.arm.ArmPlot(*args, bd=None, **kwargs)[source]

Bases: bdsim.graphics.GraphicsBlock

ARMPLOT

inputs

outputs

states

1

0

0

ndarray

__init__(robot=None, *inputs, q0=None, backend=None, **blockargs)[source]
Parameters
  • *inputs (Block or Plug) – Optional incoming connections

  • robot (Robot subclass) – Robot model

  • backend (str, optional) – RTB backend name, defaults to ‘pyplot’

  • blockargs (dict) – common Block options

Returns

An ARMPLOT block

Return type

ArmPlot instance

Create a robot animation.

Notes:

  • Uses RTB plot method

Example of vehicle display (animated). The label at the top is the block name.

class roboticstoolbox.blocks.arm.CTraj(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SourceBlock

CTRAJ

inputs

outputs

states

0

1

0

float

__init__(T1, T2, T, lspb=True, **blockargs)[source]

[summary]

Parameters
  • T1 (SE3) – initial pose

  • T2 (SE3) – final pose

  • T (float) – motion time

  • lspb (bool) – Use LSPB motion profile along the path

  • blockargs (dict) – common Block options

Returns

CTRAJ block

Return type

CTraj instance

Create a Cartesian motion block.

The block outputs a pose that varies smoothly from T1 to T2 over the course of T seconds.

If T is not given it defaults to the simulation time.

If lspb is True then an LSPB motion profile is used along the path to provide initial acceleration and final deceleration. Otherwise, motion is at constant velocity.

Seealso

:method:`SE3.interp`

class roboticstoolbox.blocks.arm.CirclePath(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SourceBlock

CIRCLEPATH

inputs

outputs

states

0 or 1

1

0

float

float

__init__(radius=1, centre=0, 0, 0, pose=None, frequency=1, unit='rps', phase=0, **blockargs)[source]
Parameters
  • radius (float) – radius of circle, defaults to 1

  • centre (array_like(3)) – center of circle, defaults to [0,0,0]

  • pose (SE3) – SE3 pose of output, defaults to None

  • frequency (float) – rotational frequency, defaults to 1

  • unit (str) – unit for frequency, one of: ‘rps’ [default], ‘rad’

  • phase (float) – phase

  • blockargs (dict) – common Block options

Returns

TRAJ block

Return type

Traj instance

Create a circular motion block.

The block outputs the coordinates of a point moving in a circle of radius r centred at centre and parallel to the xy-plane.

By default the output is a 3-vector \((x, y, z)\) but if pose is an SE3 instance the output is a copy of that pose with its translation set to the coordinate of the moving point. This is the motion of a frame with fixed orientation following a circular path.

class roboticstoolbox.blocks.arm.Delta2Tr(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

DELTA2TR

inputs

outputs

states

1

1

0

ndarray(6)

SE3

__init__(**blockargs)[source]
Parameters

blockargs (dict) – common Block options

Returns

a DELTA2TR block

Return type

Delta2Tr instance

Delta to SE(3)

The block has one input port:

  1. delta as an ndarray(6,n)

and one output port:

  1. T as an SE3

Seealso

spatialmath.base.delta2tr()

class roboticstoolbox.blocks.arm.FDyn(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.TransferBlock

FDYN

inputs

outputs

states

1

3

0

ndarray

ndarray, ndarray, ndarray

__init__(robot, q0=None, **blockargs)[source]
Parameters
  • robot (Robot subclass) – Robot model

  • q0 (array_like(n)) – Initial joint configuration

  • blockargs (dict) – common Block options

Returns

a FORWARD_DYNAMICS block

Return type

Foward_Dynamics instance

Robot arm forward dynamics model.

The block has one input port:

  1. Joint force/torque as an ndarray.

and three output ports:

  1. joint configuration

  2. joint velocity

  3. joint acceleration

class roboticstoolbox.blocks.arm.FDyn_X(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.TransferBlock

FDYN_X

inputs

outputs

states

1

3

0

ndarray

ndarray, ndarray, ndarray

__init__(robot, q0=None, gravcomp=False, velcomp=False, representation='rpy/xyz', **blockargs)[source]
Parameters
  • robot (Robot subclass) – Robot model

  • end (Link or str) – Link to compute pose of, defaults to end-effector

  • blockargs (dict) – common Block options

Returns

a FDYN_X block

Return type

FDyn_X instance

Robot arm forward dynamics model.

The block has one input port:

  1. Applied end-effector wrench as an ndarray.

and three output ports:

  1. task space pose

  2. task space velocity

  3. task space acceleration

class roboticstoolbox.blocks.arm.FKine(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

FKINE

inputs

outputs

states

1

1

0

ndarray

SE3

__init__(robot=None, args={}, **blockargs)[source]
Parameters
  • *inputs (Block or Plug) – Optional incoming connections

  • robot (Robot subclass, optional) – Robot model, defaults to None

  • args (dict, optional) – Options for fkine, defaults to {}

  • blockargs (dict) – common Block options

Returns

a FORWARD_KINEMATICS block

Return type

Foward_Kinematics instance

Robot arm forward kinematic model.

Block ports

input q

Joint configuration vector as an ndarray.

output T

End-effector pose as an SE(3) object

class roboticstoolbox.blocks.arm.Gravload(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

GRAVLOAD

inputs

outputs

states

1

1

0

ndarray

ndarray

__init__(robot, gravity=None, **blockargs)[source]
Parameters
  • robot (Robot subclass) – Robot model

  • gravity (float) – gravitational acceleration

  • blockargs (dict) – common Block options

Returns

a GRAVLOAD block

Return type

Gravload instance

Robot arm gravity torque.

The block has one input port:

  1. Joint configuration vector as an ndarray.

and one output port:

  1. joint torque/force due to gravity

class roboticstoolbox.blocks.arm.Gravload_X(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

GRAVLOAD_X

inputs

outputs

states

1

1

0

ndarray

ndarray

__init__(robot, gravity=None, **blockargs)[source]
Parameters
  • robot (Robot subclass) – Robot model

  • gravity (float) – gravitational acceleration

  • blockargs (dict) – common Block options

Returns

a GRAVLOAD block

Return type

Gravload instance

Robot arm gravity torque.

The block has one input port:

  1. Joint configuration vector as an ndarray.

and one output port:

  1. joint torque/force due to gravity

class roboticstoolbox.blocks.arm.IDyn(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

IDYN

inputs

outputs

states

3

1

0

ndarray, ndarray, ndarray

ndarray

__init__(robot, gravity=None, **blockargs)[source]
Parameters
  • robot (Robot subclass) – Robot model

  • gravity (float) – gravitational acceleration

  • blockargs (dict) – common Block options

Returns

an INVERSE_DYNAMICS block

Return type

Inverse_Dynamics instance

Robot arm forward dynamics model.

The block has three input port:

  1. Joint configuration vector as an ndarray.

  2. Joint velocity vector as an ndarray.

  3. Joint acceleration vector as an ndarray.

and one output port:

  1. joint torque/force

class roboticstoolbox.blocks.arm.IKine(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

IKINE

inputs

outputs

states

1

1

0

SE3

ndarray

__init__(robot=None, q0=None, useprevious=True, ik=None, **blockargs)[source]
Parameters
  • robot (Robot subclass, optional) – Robot model, defaults to None

  • q0 (array_like(n), optional) – Initial joint angles, defaults to None

  • useprevious (bool, optional) – Use previous IK solution as q0, defaults to True

  • ik (callable f(T)) – Specify an IK function, defaults to ‘ikine_LM’

  • blockargs (dict) – common Block options

Returns

an INVERSE_KINEMATICS block

Return type

Inverse_Kinematics instance

Robot arm inverse kinematic model.

The block has one input port:

  1. End-effector pose as an SE(3) object

and one output port:

  1. Joint configuration vector as an ndarray.

class roboticstoolbox.blocks.arm.Inertia(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

INERTIA

inputs

outputs

states

1

1

0

ndarray

ndarray

__init__(robot, gravity=None, **blockargs)[source]
Parameters
Returns

an INERTIA block

Return type

Inertia instance

Robot arm inertia matrix.

The block has one input port:

  1. Joint configuration vector as an ndarray.

and one output port:

  1. Joint-space inertia matrix \(\mat{M}(q)\)

class roboticstoolbox.blocks.arm.Inertia_X(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

INERTIA_X

inputs

outputs

states

1

1

0

ndarray

ndarray

__init__(robot, representation=None, pinv=False, **blockargs)[source]
Parameters
Returns

an INERTIA_X block

Return type

Inertia_X instance

Robot arm task-space inertia matrix.

The block has one input port:

  1. Joint configuration vector as an ndarray.

and one output port:

  1. Task-space inertia matrix \(\mat{M}_x(q)\)

class roboticstoolbox.blocks.arm.JTraj(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SourceBlock

JTRAJ

inputs

outputs

states

0

3

0

ndarray(n)

__init__(q0, qf, qd0=None, qdf=None, T=None, **blockargs)[source]

Compute a joint-space trajectory

Parameters
  • q0 (array_like(n)) – initial joint coordinate

  • qf (array_like(n)) – final joint coordinate

  • T (array_like or int, optional) – time vector or number of steps, defaults to None

  • qd0 (array_like(n), optional) – initial velocity, defaults to None

  • qdf (array_like(n), optional) – final velocity, defaults to None

  • blockargs (dict) – common Block options

Returns

TRAJ block

Return type

Traj instance

  • tg = jtraj(q0, qf, N) is a joint space trajectory where the joint

coordinates vary from q0 (M) to qf (M). A quintic (5th order) polynomial is used with default zero boundary conditions for velocity and acceleration. Time is assumed to vary from 0 to 1 in N steps.

  • tg = jtraj(q0, qf, t) as above but t is a uniformly-spaced time

vector

The return value is an object that contains position, velocity and acceleration data.

Notes:

  • The time vector, if given, scales the velocity and acceleration outputs

assuming that the time vector starts at zero and increases linearly.

Seealso

ctraj(), qplot(), jtraj()

class roboticstoolbox.blocks.arm.Jacobian(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

JACOBIAN

inputs

outputs

states

1

1

0

ndarray

ndarray

__init__(robot, frame='0', inverse=False, pinv=False, transpose=False, **blockargs)[source]
Parameters
  • robot (Robot subclass) – Robot model

  • frame (str, optional) – Frame to compute Jacobian for, one of: ‘0’ [default], ‘e’

  • inverse (bool, optional) – output inverse of Jacobian, defaults to False

  • pinv (bool, optional) – output pseudo-inverse of Jacobian, defaults to False

  • transpose (bool, optional) – output transpose of Jacobian, defaults to False

  • blockargs (dict) – common Block options

Returns

a JACOBIAN block

Return type

Jacobian instance

Robot arm Jacobian.

The block has one input port:

  1. Joint configuration vector as an ndarray.

and one output port:

  1. Jacobian matrix as an ndarray(6,n)

class roboticstoolbox.blocks.arm.LSPB(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.SourceBlock

LSPB

inputs

outputs

states

0

3

0

float

__init__(q0, qf, V=None, T=None, **blockargs)[source]

Compute a joint-space trajectory

Parameters
  • q0 (array_like(n)) – initial joint coordinate

  • qf (array_like(n)) – final joint coordinate

  • T (array_like or int, optional) – time vector or number of steps, defaults to None

  • blockargs (dict) – common Block options

Returns

LSPB block

Return type

LSPB instance

  • tg = jtraj(q0, qf, N) is a joint space trajectory where the joint

coordinates vary from q0 (M) to qf (M). A quintic (5th order) polynomial is used with default zero boundary conditions for velocity and acceleration. Time is assumed to vary from 0 to 1 in N steps.

  • tg = jtraj(q0, qf, t) as above but t is a uniformly-spaced time

vector

The return value is an object that contains position, velocity and acceleration data.

Notes:

  • The time vector, if given, scales the velocity and acceleration outputs

assuming that the time vector starts at zero and increases linearly.

Seealso

ctraj(), qplot(), jtraj()

class roboticstoolbox.blocks.arm.Point2Tr(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

POINT2TR

inputs

outputs

states

1

1

0

ndarray(3)

SE3

__init__(T, **blockargs)[source]
Parameters
Returns

a POINT2TR block

Return type

Point2Tr instance

The block has one input port:

  1. a 3D point as an ndarray(3)

and one output port:

  1. T as an SE3 with its position part replaced by the input

Seealso

spatialmath.base.delta2tr()

class roboticstoolbox.blocks.arm.TR2T(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

TR2T

inputs

outputs

states

1

3

0

SE3

float

__init__(**blockargs)[source]
Parameters
Returns

a POINT2TR block

Return type

Point2Tr instance

The block has one input port:

  1. a 3D point as an ndarray(3)

and one output port:

  1. T as an SE3 with its position part replaced by the input

Seealso

spatialmath.base.delta2tr()

class roboticstoolbox.blocks.arm.Tr2Delta(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

TR2DELTA

inputs

outputs

states

2

1

0

SE3, SE3

ndarray(6)

__init__(**blockargs)[source]
Parameters

blockargs (dict) – common Block options

Returns

a TR2DELTA block

Return type

Tr2Delta instance

Difference between T1 and T2 as a 6-vector

The block has two input port:

  1. T1 as an SE3.

  2. T2 as an SE3.

and one output port:

  1. delta as an ndarray(6,n)

Seealso

spatialmath.base.tr2delta()

class roboticstoolbox.blocks.arm.Traj(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

TRAJ

inputs

outputs

states

0 or 1

1

0

float

float

__init__(y0=0, yf=1, T=None, time=False, traj='lspb', **blockargs)[source]
Parameters
  • y0 (array_like(m), optional) – initial value, defaults to 0

  • yf (array_like(m), optional) – final value, defaults to 1

  • T (array_like or int, optional) – time vector or number of steps, defaults to None

  • time (bool, optional) – x is simulation time, defaults to False

  • traj (str, optional) – trajectory type, one of: ‘lspb’ [default], ‘tpoly’

  • blockargs (dict) – common Block options

Returns

TRAJ block

Return type

Traj instance

Create a trajectory block.

A block that generates a trajectory using a trapezoidal or quintic polynomial profile.

Mobile robots

class roboticstoolbox.blocks.mobile.Bicycle(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.TransferBlock

BICYCLE

inputs

outputs

states

2

1

3

float

ndarray(3)

__init__(L=1, speed_max=inf, accel_max=inf, steer_max=1.413716694115407, x0=None, **blockargs)[source]

Create a vehicle model with Bicycle kinematics.

Parameters
  • L (float, optional) – Wheelbase, defaults to 1

  • speed_max (float, optional) – Velocity limit, defaults to 1

  • accel_max (float, optional) – maximum acceleration, defaults to math.inf

  • steer_max (float, optional) – maximum steering angle, defaults to math.pi*0.45

  • x0 (array_like, optional) – Inital state, defaults to None

  • blockargs (dict) – common Block options

Returns

a BICYCLE block

Return type

Bicycle instance

Bicycle kinematic model with state \([x, y, \theta]\).

Block ports

input v

Vehicle speed (metres/sec). The velocity limit vlim is applied to the magnitude of this input.

input γ

Steering wheel angle (radians). The steering limit slim is applied to the magnitude of this input.

output q

configuration (x, y, θ)

Seealso

mobile.Bicycle DiffSteer

class roboticstoolbox.blocks.mobile.DiffSteer(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.TransferBlock

DIFFSTEER

inputs

outputs

states

2

3

3

float

float

__init__(w=1, R=1, speed_max=inf, accel_max=inf, steer_max=None, a=0, x0=None, **blockargs)[source]

Create a differential steer vehicle model

Parameters
  • w (float, optional) – vehicle width, defaults to 1

  • R (float, optional) – Wheel radius, defaults to 1

  • speed_max (float, optional) – Velocity limit, defaults to 1

  • accel_max (float, optional) – maximum acceleration, defaults to math.inf

  • steer_max (float, optional) – maximum steering rate, defaults to 1

  • x0 (array_like, optional) – Inital state, defaults to None

  • blockargs (dict :return: a DIFFSTEER block) – common Block options

Return type

DifSteer instance

Unicycle kinematic model with state \([x, y, heta]\), with with inputs given as wheel angular velocity.

Block ports

input ωL

Left-wheel angular velocity (radians/sec).

input ωR

Right-wheel angular velocity (radians/sec).

output q

configuration (x, y, θ)

Note

Wheel velocity is defined such that if both are positive the vehicle moves forward.

Seealso

Bicycle Unicycle

class roboticstoolbox.blocks.mobile.Unicycle(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.TransferBlock

UNICYCLE

inputs

outputs

states

2

1

3

float

float

__init__(w=1, speed_max=inf, accel_max=inf, steer_max=None, a=0, x0=None, **blockargs)[source]

Create a vehicle model with Unicycle kinematics.

Parameters
  • w (float, optional) – vehicle width, defaults to 1

  • speed_max (float, optional) – Velocity limit, defaults to 1

  • accel_max (float, optional) – maximum acceleration, defaults to math.inf

  • steer_max (float, optional) – maximum steering rate, defaults to 1

  • x0 (array_like, optional) – Inital state, defaults to None

  • blockargs (dict :return: a UNICYCLE block) – common Block options

Return type

Unicycle instance

Unicycle kinematic model with state \([x, y, \theta]\).

Block ports

input v

Vehicle speed (metres/sec). The velocity limit vlim is applied to the magnitude of this input.

input ω

Angular velocity (radians/sec). The steering limit slim is applied to the magnitude of this input.

output q

configuration (x, y, θ)

Seealso

Bicycle DiffSteer

class roboticstoolbox.blocks.mobile.VehiclePlot(*args, bd=None, **kwargs)[source]

Bases: bdsim.graphics.GraphicsBlock

VEHICLEPLOT

inputs

outputs

states

1

0

0

ndarray

__init__(animation=None, path=None, labels=['X', 'Y'], square=True, init=None, scale=True, **blockargs)[source]

Create a vehicle animation

Parameters
  • animation (VehicleAnimation subclass, optional) – Graphical animation of vehicle, defaults to None

  • path (str or dict, optional) – linestyle to plot path taken by vehicle, defaults to None

  • labels (array_like(2) or list) – axis labels (xlabel, ylabel), defaults to [“X”,”Y”]

  • square (bool, optional) – Set aspect ratio to 1, defaults to True

  • init (callable, optional) – initialize graphics, defaults to None

  • blockargs (dict :return: A VEHICLEPLOT block) – common Block options

Return type

VehiclePlot instance

Create a vehicle animation similar to the figure below.

Block ports

input q

configuration (x, y, θ)

Notes:

  • The init function is called after the axes are initialized and can be used to draw application specific detail on the plot. In the example below, this is the dot and star.

  • A dynamic trail, showing path to date can be animated if the option path is set to a linestyle.

example of generated graphic

Example of vehicle display (animated). The label at the top is the block name.

Multi rotor flying robots

class roboticstoolbox.blocks.uav.MultiRotor(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.TransferBlock

MULTIROTOR

inputs

outputs

states

1

1

16

A(4,)

dict

__init__(model, groundcheck=True, speedcheck=True, x0=None, **blockargs)[source]

Create a a multi-rotor dynamic model block.

Parameters
  • model (dict) – Vehicle geometric and inertial parameters

  • groundcheck (bool) – Prevent vehicle moving below ground, defaults to True

  • speedcheck (bool) – Check for zero rotor speed, defaults to True

  • x0 (float, optional) – Initial state, defaults to None

  • blockargs (dict) – common Block options

Returns

a MULTIROTOR block

Return type

MultiRotor instance

Block ports

input ω

a vector of input rotor speeds in (radians/sec). These are, looking down, clockwise from the front rotor which lies on the x-axis.

output x

a dictionary signal with the following items:

  • x pose in the world frame as \([x, y, z, \theta_Y, \theta_P, \theta_R]\)

  • vb translational velocity in the world frame (metres/sec)

  • w angular rates in the world frame as yaw-pitch-roll rates (radians/second)

  • a1s longitudinal flapping angles (radians)

  • b1s lateral flapping angles (radians)

Based on MATLAB code developed by Pauline Pounds 2004.

class roboticstoolbox.blocks.uav.MultiRotorMixer(*args, bd=None, **kwargs)[source]

Bases: bdsim.components.FunctionBlock

MULTIROTORMIXER

inputs

outputs

states

4

1

0

float

__init__(maxw=1000, minw=5, **blockargs)[source]

Create a block that displays/animates a multi-rotor flying vehicle.

Parameters
  • maxw (float) – maximum rotor speed in rad/s, defaults to 1000

  • minw (float) – minimum rotor speed in rad/s, defaults to 5

  • blockargs (dict) – common Block options

Returns

a MULTIROTORMIXER block

Return type

MultiRotorMixer instance

Block ports

input 𝛕r

roll torque

input 𝛕p

pitch torque

input 𝛕y

yaw torque

input T

total thrust

output ω

1D array of rotor speeds

Derived from Simulink model by Pauline Pounds 2004

class roboticstoolbox.blocks.uav.MultiRotorPlot(*args, bd=None, **kwargs)[source]

Bases: bdsim.graphics.GraphicsBlock

MULTIROTORPLOT

inputs

outputs

states

1

0

0

dict

__init__(model, scale=[- 2, 2, - 2, 2, 10], flapscale=1, projection='ortho', **blockargs)[source]

Create a block that displays/animates a multi-rotor flying vehicle.

Parameters
  • model (dict) – A dictionary of vehicle geometric and inertial properties

  • scale (array_like, optional) – dimensions of workspace: xmin, xmax, ymin, ymax, zmin, zmax, defaults to [-2,2,-2,2,10]

  • flapscale (float) – exagerate flapping angle by this factor, defaults to 1

  • projection (str) – 3D projection, one of: ‘ortho’ [default], ‘perspective’

  • blockargs (dict) – common Block options

Returns

a MULTIROTORPLOT block

Return type

MultiRotorPlot instance

Block ports

input y

a dictionary signal that includes the item:

  • x pose in the world frame as \([x, y, z, heta_Y, heta_P, heta_R]\)

  • X pose in the world frame as \([x, y, z, heta_Y, heta_P, heta_R]\)

  • a1s

  • b1s

example of generated graphic

Example of quad-rotor display.

Written by Pauline Pounds 2004

Vision blocks

These blocks are defined within the Machine Vision Toolbox for Python.