EtherCAT.Simulator.Fault (ethercat v0.4.2)

Copy Markdown View Source

Builder API for EtherCAT.Simulator.inject_fault/1.

This keeps the public fault surface readable without changing the simulator's internal tuple representation.

Typical usage:

alias EtherCAT.Simulator.Fault

EtherCAT.Simulator.inject_fault(Fault.drop_responses())

EtherCAT.Simulator.inject_fault(
  Fault.disconnect(:outputs)
  |> Fault.next(30)
)

EtherCAT.Simulator.inject_fault(
  Fault.script([
    Fault.drop_responses(),
    Fault.wait_for(Fault.healthy_polls(:outputs, 10)),
    Fault.retreat_to_safeop(:outputs)
  ])
)

Fault.describe(Fault.disconnect(:outputs) |> Fault.next(3))

Summary

Types

effect()

@type effect() ::
  :drop_responses
  | {:wkc_offset, integer()}
  | {:command_wkc_offset, atom(), integer()}
  | {:logical_wkc_offset, atom(), integer()}
  | {:disconnect, atom()}
  | {:retreat_to_safeop, atom()}
  | {:power_cycle, atom()}
  | {:latch_al_error, atom(), non_neg_integer()}
  | {:mailbox_abort, atom(), non_neg_integer(), non_neg_integer(),
     non_neg_integer(), mailbox_step() | nil}
  | {:mailbox_protocol_fault, atom(), non_neg_integer(), non_neg_integer(),
     mailbox_step(), term()}
  | {:nested, t() | raw_fault()}
  | {:script, [t()]}
  | {:wait_for_milestone, milestone()}

mailbox_step()

@type mailbox_step() ::
  :request | :upload_init | :upload_segment | :download_init | :download_segment

milestone()

@type milestone() ::
  {:healthy_exchanges, pos_integer()}
  | {:healthy_polls, atom(), pos_integer()}
  | {:mailbox_step, atom(), mailbox_step(), pos_integer()}

raw_fault()

schedule()

@type schedule() ::
  :immediate
  | {:next_exchange, pos_integer()}
  | {:after_ms, non_neg_integer()}
  | {:after_milestone, milestone()}

t()

@type t() :: %EtherCAT.Simulator.Fault{effect: effect(), schedule: schedule()}

Functions

after_milestone(fault, milestone)

@spec after_milestone(t(), milestone()) :: t()

after_ms(fault, delay_ms)

@spec after_ms(t(), non_neg_integer()) :: t()

command_wkc_offset(command_name, delta)

@spec command_wkc_offset(atom(), integer()) :: t()

describe(fault)

@spec describe(t() | raw_fault()) :: String.t()

disconnect(slave_name)

@spec disconnect(atom()) :: t()

drop_responses()

@spec drop_responses() :: t()

healthy_exchanges(count)

@spec healthy_exchanges(pos_integer()) :: milestone()

healthy_polls(slave_name, count)

@spec healthy_polls(atom(), pos_integer()) :: milestone()

latch_al_error(slave_name, code)

@spec latch_al_error(atom(), non_neg_integer()) :: t()

logical_wkc_offset(slave_name, delta)

@spec logical_wkc_offset(atom(), integer()) :: t()

mailbox_abort(slave_name, index, subindex, abort_code, opts \\ [])

@spec mailbox_abort(
  atom(),
  non_neg_integer(),
  non_neg_integer(),
  non_neg_integer(),
  keyword()
) :: t()

mailbox_protocol_fault(slave_name, index, subindex, stage, fault_kind)

@spec mailbox_protocol_fault(
  atom(),
  non_neg_integer(),
  non_neg_integer(),
  mailbox_step(),
  term()
) :: t()

mailbox_step(slave_name, step, count)

@spec mailbox_step(atom(), mailbox_step(), pos_integer()) :: milestone()

next(fault, count \\ 1)

@spec next(t(), pos_integer()) :: t()

normalize(fault)

@spec normalize(t() | raw_fault()) :: {:ok, raw_fault()} | :error

power_cycle(slave_name)

@spec power_cycle(atom()) :: t()

retreat_to_safeop(slave_name)

@spec retreat_to_safeop(atom()) :: t()

script(steps)

@spec script([t(), ...]) :: t()

wait_for(milestone)

@spec wait_for(milestone()) :: t()

wkc_offset(delta)

@spec wkc_offset(integer()) :: t()