# `EtherCAT.Bus.Transaction`
[🔗](https://github.com/sid2baker/ethercat/blob/main/lib/ethercat/bus/transaction.ex#L1)

Builder for ordered EtherCAT datagram transactions.

`Transaction` is the caller-side unit of atomic intent. The bus may coalesce
multiple reliable transactions into one frame, but each transaction still
receives its own ordered list of results.

Transactions may be built incrementally:

    Transaction.new()
    |> Transaction.fpwr(0x1001, Registers.al_control(0x08))
    |> Transaction.fprd(0x1001, Registers.al_status())

Or created directly for a single datagram:

    Transaction.fprd(0x1001, Registers.al_status())
    Transaction.lrw({0x0000, image})

# `t`

```elixir
@opaque t()
```

# `aprd`

```elixir
@spec aprd(
  non_neg_integer(),
  {non_neg_integer(), pos_integer()}
) :: t()
```

# `aprd`

```elixir
@spec aprd(t(), non_neg_integer(), {non_neg_integer(), pos_integer()}) :: t()
```

Auto-increment read. `position` is 0-based. `reg` is `{offset, length}`.

# `aprw`

```elixir
@spec aprw(
  non_neg_integer(),
  {non_neg_integer(), binary()}
) :: t()
```

# `aprw`

```elixir
@spec aprw(t(), non_neg_integer(), {non_neg_integer(), binary()}) :: t()
```

Auto-increment read/write. `reg` is `{offset, data}`.

# `apwr`

```elixir
@spec apwr(
  non_neg_integer(),
  {non_neg_integer(), binary()}
) :: t()
```

# `apwr`

```elixir
@spec apwr(t(), non_neg_integer(), {non_neg_integer(), binary()}) :: t()
```

Auto-increment write. `reg` is `{offset, data}`.

# `armw`

```elixir
@spec armw(
  non_neg_integer(),
  {non_neg_integer(), pos_integer() | binary()}
) :: t()
```

# `armw`

```elixir
@spec armw(t(), non_neg_integer(), {non_neg_integer(), pos_integer() | binary()}) ::
  t()
```

Auto-increment read multiple write (ARMW). `reg` is `{offset, length_or_data}`.
When `length` is an integer, a zero-filled binary of that size is used as the
write payload.

# `brd`

```elixir
@spec brd({non_neg_integer(), pos_integer()}) :: t()
```

# `brd`

```elixir
@spec brd(
  t(),
  {non_neg_integer(), pos_integer()}
) :: t()
```

Broadcast read. `reg` is `{offset, length}`.

# `brw`

```elixir
@spec brw({non_neg_integer(), binary()}) :: t()
```

# `brw`

```elixir
@spec brw(
  t(),
  {non_neg_integer(), binary()}
) :: t()
```

Broadcast read/write. `reg` is `{offset, data}`.

# `bwr`

```elixir
@spec bwr({non_neg_integer(), binary()}) :: t()
```

# `bwr`

```elixir
@spec bwr(
  t(),
  {non_neg_integer(), binary()}
) :: t()
```

Broadcast write. `reg` is `{offset, data}`.

# `datagrams`

```elixir
@spec datagrams(t()) :: [EtherCAT.Bus.Datagram.t()]
```

# `fprd`

```elixir
@spec fprd(
  non_neg_integer(),
  {non_neg_integer(), pos_integer()}
) :: t()
```

# `fprd`

```elixir
@spec fprd(t(), non_neg_integer(), {non_neg_integer(), pos_integer()}) :: t()
```

Configured address read. `reg` is `{offset, length}` from `Registers`.

# `fprw`

```elixir
@spec fprw(
  non_neg_integer(),
  {non_neg_integer(), binary()}
) :: t()
```

# `fprw`

```elixir
@spec fprw(t(), non_neg_integer(), {non_neg_integer(), binary()}) :: t()
```

Configured address read/write. `reg` is `{offset, data}`.

# `fpwr`

```elixir
@spec fpwr(
  non_neg_integer(),
  {non_neg_integer(), binary()}
) :: t()
```

# `fpwr`

```elixir
@spec fpwr(t(), non_neg_integer(), {non_neg_integer(), binary()}) :: t()
```

Configured address write. `reg` is `{offset, data}` from `Registers`.

# `frmw`

```elixir
@spec frmw(
  non_neg_integer(),
  {non_neg_integer(), pos_integer() | binary()}
) :: t()
```

# `frmw`

```elixir
@spec frmw(t(), non_neg_integer(), {non_neg_integer(), pos_integer() | binary()}) ::
  t()
```

Configured address read multiple write (FRMW). `reg` is `{offset, length_or_data}`.
When `length` is an integer, a zero-filled binary of that size is used as the
write payload.

# `lrd`

```elixir
@spec lrd({non_neg_integer(), pos_integer()}) :: t()
```

# `lrd`

```elixir
@spec lrd(
  t(),
  {non_neg_integer(), pos_integer()}
) :: t()
```

Logical memory read. `addr_len` is `{addr, length}`.

# `lrw`

```elixir
@spec lrw({non_neg_integer(), binary()}) :: t()
```

# `lrw`

```elixir
@spec lrw(
  t(),
  {non_neg_integer(), binary()}
) :: t()
```

Logical memory read/write. `addr_data` is `{addr, data}`.

# `lwr`

```elixir
@spec lwr({non_neg_integer(), binary()}) :: t()
```

# `lwr`

```elixir
@spec lwr(
  t(),
  {non_neg_integer(), binary()}
) :: t()
```

Logical memory write. `addr_data` is `{addr, data}`.

# `new`

```elixir
@spec new() :: t()
```

---

*Consult [api-reference.md](api-reference.md) for complete listing*