# `LIS3DH.Registers` Raw register accessors for the LIS3DH. Each function reads or writes a single 8-bit register. Higher-level helpers in `LIS3DH` and friends interpret the bytes as signed integers, scaled physical quantities, or named bit-fields. Register addresses, access modes and bit layouts are taken from *LIS3DH Datasheet DocID17530 Rev 2* §7 *Register mapping* and §8 *Registers description*. # `read_act_dur` ```elixir @spec read_act_dur(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `act_dur` register. ## Example iex> read_act_dur(conn) {:ok, <<0>>} # `read_act_ths` ```elixir @spec read_act_ths(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `act_ths` register. ## Example iex> read_act_ths(conn) {:ok, <<0>>} # `read_click_cfg` ```elixir @spec read_click_cfg(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `click_cfg` register. ## Example iex> read_click_cfg(conn) {:ok, <<0>>} # `read_click_src` ```elixir @spec read_click_src(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `click_src` register. ## Example iex> read_click_src(conn) {:ok, <<0>>} # `read_click_ths` ```elixir @spec read_click_ths(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `click_ths` register. ## Example iex> read_click_ths(conn) {:ok, <<0>>} # `read_ctrl_reg_0` ```elixir @spec read_ctrl_reg_0(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `ctrl_reg_0` register. ## Example iex> read_ctrl_reg_0(conn) {:ok, <<0>>} # `read_ctrl_reg_1` ```elixir @spec read_ctrl_reg_1(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `ctrl_reg_1` register. ## Example iex> read_ctrl_reg_1(conn) {:ok, <<0>>} # `read_ctrl_reg_2` ```elixir @spec read_ctrl_reg_2(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `ctrl_reg_2` register. ## Example iex> read_ctrl_reg_2(conn) {:ok, <<0>>} # `read_ctrl_reg_3` ```elixir @spec read_ctrl_reg_3(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `ctrl_reg_3` register. ## Example iex> read_ctrl_reg_3(conn) {:ok, <<0>>} # `read_ctrl_reg_4` ```elixir @spec read_ctrl_reg_4(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `ctrl_reg_4` register. ## Example iex> read_ctrl_reg_4(conn) {:ok, <<0>>} # `read_ctrl_reg_5` ```elixir @spec read_ctrl_reg_5(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `ctrl_reg_5` register. ## Example iex> read_ctrl_reg_5(conn) {:ok, <<0>>} # `read_ctrl_reg_6` ```elixir @spec read_ctrl_reg_6(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `ctrl_reg_6` register. ## Example iex> read_ctrl_reg_6(conn) {:ok, <<0>>} # `read_fifo_ctrl_reg` ```elixir @spec read_fifo_ctrl_reg(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `fifo_ctrl_reg` register. ## Example iex> read_fifo_ctrl_reg(conn) {:ok, <<0>>} # `read_fifo_src_reg` ```elixir @spec read_fifo_src_reg(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `fifo_src_reg` register. ## Example iex> read_fifo_src_reg(conn) {:ok, <<0>>} # `read_int1_cfg` ```elixir @spec read_int1_cfg(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `int1_cfg` register. ## Example iex> read_int1_cfg(conn) {:ok, <<0>>} # `read_int1_duration` ```elixir @spec read_int1_duration(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `int1_duration` register. ## Example iex> read_int1_duration(conn) {:ok, <<0>>} # `read_int1_src` ```elixir @spec read_int1_src(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `int1_src` register. ## Example iex> read_int1_src(conn) {:ok, <<0>>} # `read_int1_ths` ```elixir @spec read_int1_ths(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `int1_ths` register. ## Example iex> read_int1_ths(conn) {:ok, <<0>>} # `read_int2_cfg` ```elixir @spec read_int2_cfg(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `int2_cfg` register. ## Example iex> read_int2_cfg(conn) {:ok, <<0>>} # `read_int2_duration` ```elixir @spec read_int2_duration(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `int2_duration` register. ## Example iex> read_int2_duration(conn) {:ok, <<0>>} # `read_int2_src` ```elixir @spec read_int2_src(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `int2_src` register. ## Example iex> read_int2_src(conn) {:ok, <<0>>} # `read_int2_ths` ```elixir @spec read_int2_ths(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `int2_ths` register. ## Example iex> read_int2_ths(conn) {:ok, <<0>>} # `read_out_adc1_h` ```elixir @spec read_out_adc1_h(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `out_adc1_h` register. ## Example iex> read_out_adc1_h(conn) {:ok, <<0>>} # `read_out_adc1_l` ```elixir @spec read_out_adc1_l(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `out_adc1_l` register. ## Example iex> read_out_adc1_l(conn) {:ok, <<0>>} # `read_out_adc2_h` ```elixir @spec read_out_adc2_h(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `out_adc2_h` register. ## Example iex> read_out_adc2_h(conn) {:ok, <<0>>} # `read_out_adc2_l` ```elixir @spec read_out_adc2_l(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `out_adc2_l` register. ## Example iex> read_out_adc2_l(conn) {:ok, <<0>>} # `read_out_adc3_h` ```elixir @spec read_out_adc3_h(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `out_adc3_h` register. ## Example iex> read_out_adc3_h(conn) {:ok, <<0>>} # `read_out_adc3_l` ```elixir @spec read_out_adc3_l(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `out_adc3_l` register. ## Example iex> read_out_adc3_l(conn) {:ok, <<0>>} # `read_out_x_h` ```elixir @spec read_out_x_h(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `out_x_h` register. ## Example iex> read_out_x_h(conn) {:ok, <<0>>} # `read_out_x_l` ```elixir @spec read_out_x_l(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `out_x_l` register. ## Example iex> read_out_x_l(conn) {:ok, <<0>>} # `read_out_y_h` ```elixir @spec read_out_y_h(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `out_y_h` register. ## Example iex> read_out_y_h(conn) {:ok, <<0>>} # `read_out_y_l` ```elixir @spec read_out_y_l(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `out_y_l` register. ## Example iex> read_out_y_l(conn) {:ok, <<0>>} # `read_out_z_h` ```elixir @spec read_out_z_h(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `out_z_h` register. ## Example iex> read_out_z_h(conn) {:ok, <<0>>} # `read_out_z_l` ```elixir @spec read_out_z_l(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `out_z_l` register. ## Example iex> read_out_z_l(conn) {:ok, <<0>>} # `read_reference` ```elixir @spec read_reference(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `reference` register. ## Example iex> read_reference(conn) {:ok, <<0>>} # `read_status_reg` ```elixir @spec read_status_reg(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `status_reg` register. ## Example iex> read_status_reg(conn) {:ok, <<0>>} # `read_status_reg_aux` ```elixir @spec read_status_reg_aux(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `status_reg_aux` register. ## Example iex> read_status_reg_aux(conn) {:ok, <<0>>} # `read_temp_cfg_reg` ```elixir @spec read_temp_cfg_reg(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `temp_cfg_reg` register. ## Example iex> read_temp_cfg_reg(conn) {:ok, <<0>>} # `read_time_latency` ```elixir @spec read_time_latency(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `time_latency` register. ## Example iex> read_time_latency(conn) {:ok, <<0>>} # `read_time_limit` ```elixir @spec read_time_limit(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `time_limit` register. ## Example iex> read_time_limit(conn) {:ok, <<0>>} # `read_time_window` ```elixir @spec read_time_window(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `time_window` register. ## Example iex> read_time_window(conn) {:ok, <<0>>} # `read_who_am_i` ```elixir @spec read_who_am_i(Wafer.Conn.t()) :: {:ok, binary()} | {:error, reason :: any()} ``` Read the contents of the `who_am_i` register. ## Example iex> read_who_am_i(conn) {:ok, <<0>>} # `swap_act_dur` ```elixir @spec swap_act_dur(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `act_dur` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_act_dur(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_act_ths` ```elixir @spec swap_act_ths(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `act_ths` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_act_ths(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_click_cfg` ```elixir @spec swap_click_cfg(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `click_cfg` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_click_cfg(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_click_ths` ```elixir @spec swap_click_ths(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `click_ths` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_click_ths(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_ctrl_reg_0` ```elixir @spec swap_ctrl_reg_0(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `ctrl_reg_0` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_ctrl_reg_0(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_ctrl_reg_1` ```elixir @spec swap_ctrl_reg_1(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `ctrl_reg_1` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_ctrl_reg_1(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_ctrl_reg_2` ```elixir @spec swap_ctrl_reg_2(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `ctrl_reg_2` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_ctrl_reg_2(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_ctrl_reg_3` ```elixir @spec swap_ctrl_reg_3(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `ctrl_reg_3` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_ctrl_reg_3(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_ctrl_reg_4` ```elixir @spec swap_ctrl_reg_4(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `ctrl_reg_4` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_ctrl_reg_4(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_ctrl_reg_5` ```elixir @spec swap_ctrl_reg_5(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `ctrl_reg_5` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_ctrl_reg_5(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_ctrl_reg_6` ```elixir @spec swap_ctrl_reg_6(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `ctrl_reg_6` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_ctrl_reg_6(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_fifo_ctrl_reg` ```elixir @spec swap_fifo_ctrl_reg(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `fifo_ctrl_reg` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_fifo_ctrl_reg(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_int1_cfg` ```elixir @spec swap_int1_cfg(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `int1_cfg` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_int1_cfg(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_int1_duration` ```elixir @spec swap_int1_duration(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `int1_duration` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_int1_duration(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_int1_ths` ```elixir @spec swap_int1_ths(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `int1_ths` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_int1_ths(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_int2_cfg` ```elixir @spec swap_int2_cfg(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `int2_cfg` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_int2_cfg(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_int2_duration` ```elixir @spec swap_int2_duration(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `int2_duration` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_int2_duration(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_int2_ths` ```elixir @spec swap_int2_ths(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `int2_ths` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_int2_ths(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_reference` ```elixir @spec swap_reference(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `reference` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_reference(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_temp_cfg_reg` ```elixir @spec swap_temp_cfg_reg(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `temp_cfg_reg` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_temp_cfg_reg(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_time_latency` ```elixir @spec swap_time_latency(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `time_latency` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_time_latency(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_time_limit` ```elixir @spec swap_time_limit(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `time_limit` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_time_limit(conn, <<0>>) {:ok, <<0>>, _conn} # `swap_time_window` ```elixir @spec swap_time_window(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Swap the contents of the `time_window` register. Reads the contents of the register, then replaces it, returning the previous contents. Some drivers may implement this atomically. ## Example iex> swap_time_window(conn, <<0>>) {:ok, <<0>>, _conn} # `update_act_dur` ```elixir @spec update_act_dur(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `act_dur` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_act_dur(conn, transform) {:ok, _conn} # `update_act_ths` ```elixir @spec update_act_ths(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `act_ths` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_act_ths(conn, transform) {:ok, _conn} # `update_click_cfg` ```elixir @spec update_click_cfg(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `click_cfg` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_click_cfg(conn, transform) {:ok, _conn} # `update_click_ths` ```elixir @spec update_click_ths(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `click_ths` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_click_ths(conn, transform) {:ok, _conn} # `update_ctrl_reg_0` ```elixir @spec update_ctrl_reg_0(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `ctrl_reg_0` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_ctrl_reg_0(conn, transform) {:ok, _conn} # `update_ctrl_reg_1` ```elixir @spec update_ctrl_reg_1(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `ctrl_reg_1` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_ctrl_reg_1(conn, transform) {:ok, _conn} # `update_ctrl_reg_2` ```elixir @spec update_ctrl_reg_2(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `ctrl_reg_2` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_ctrl_reg_2(conn, transform) {:ok, _conn} # `update_ctrl_reg_3` ```elixir @spec update_ctrl_reg_3(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `ctrl_reg_3` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_ctrl_reg_3(conn, transform) {:ok, _conn} # `update_ctrl_reg_4` ```elixir @spec update_ctrl_reg_4(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `ctrl_reg_4` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_ctrl_reg_4(conn, transform) {:ok, _conn} # `update_ctrl_reg_5` ```elixir @spec update_ctrl_reg_5(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `ctrl_reg_5` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_ctrl_reg_5(conn, transform) {:ok, _conn} # `update_ctrl_reg_6` ```elixir @spec update_ctrl_reg_6(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `ctrl_reg_6` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_ctrl_reg_6(conn, transform) {:ok, _conn} # `update_fifo_ctrl_reg` ```elixir @spec update_fifo_ctrl_reg(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `fifo_ctrl_reg` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_fifo_ctrl_reg(conn, transform) {:ok, _conn} # `update_int1_cfg` ```elixir @spec update_int1_cfg(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `int1_cfg` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_int1_cfg(conn, transform) {:ok, _conn} # `update_int1_duration` ```elixir @spec update_int1_duration(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `int1_duration` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_int1_duration(conn, transform) {:ok, _conn} # `update_int1_ths` ```elixir @spec update_int1_ths(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `int1_ths` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_int1_ths(conn, transform) {:ok, _conn} # `update_int2_cfg` ```elixir @spec update_int2_cfg(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `int2_cfg` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_int2_cfg(conn, transform) {:ok, _conn} # `update_int2_duration` ```elixir @spec update_int2_duration(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `int2_duration` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_int2_duration(conn, transform) {:ok, _conn} # `update_int2_ths` ```elixir @spec update_int2_ths(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `int2_ths` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_int2_ths(conn, transform) {:ok, _conn} # `update_reference` ```elixir @spec update_reference(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `reference` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_reference(conn, transform) {:ok, _conn} # `update_temp_cfg_reg` ```elixir @spec update_temp_cfg_reg(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `temp_cfg_reg` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_temp_cfg_reg(conn, transform) {:ok, _conn} # `update_time_latency` ```elixir @spec update_time_latency(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `time_latency` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_time_latency(conn, transform) {:ok, _conn} # `update_time_limit` ```elixir @spec update_time_limit(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `time_limit` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_time_limit(conn, transform) {:ok, _conn} # `update_time_window` ```elixir @spec update_time_window(Wafer.Conn.t(), (<<_::_*8>> -> <<_::_*8>>)) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Update the contents of the `time_window` register using a transformation function. ## Example iex> transform = fn <> -> <<(data * 2)::size(8)>> end ...> update_time_window(conn, transform) {:ok, _conn} # `write_act_dur` ```elixir @spec write_act_dur(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `act_dur` register. ## Example iex> write_act_dur(conn, <<0>>) {:ok, _conn} # `write_act_ths` ```elixir @spec write_act_ths(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `act_ths` register. ## Example iex> write_act_ths(conn, <<0>>) {:ok, _conn} # `write_click_cfg` ```elixir @spec write_click_cfg(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `click_cfg` register. ## Example iex> write_click_cfg(conn, <<0>>) {:ok, _conn} # `write_click_ths` ```elixir @spec write_click_ths(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `click_ths` register. ## Example iex> write_click_ths(conn, <<0>>) {:ok, _conn} # `write_ctrl_reg_0` ```elixir @spec write_ctrl_reg_0(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `ctrl_reg_0` register. ## Example iex> write_ctrl_reg_0(conn, <<0>>) {:ok, _conn} # `write_ctrl_reg_1` ```elixir @spec write_ctrl_reg_1(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `ctrl_reg_1` register. ## Example iex> write_ctrl_reg_1(conn, <<0>>) {:ok, _conn} # `write_ctrl_reg_2` ```elixir @spec write_ctrl_reg_2(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `ctrl_reg_2` register. ## Example iex> write_ctrl_reg_2(conn, <<0>>) {:ok, _conn} # `write_ctrl_reg_3` ```elixir @spec write_ctrl_reg_3(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `ctrl_reg_3` register. ## Example iex> write_ctrl_reg_3(conn, <<0>>) {:ok, _conn} # `write_ctrl_reg_4` ```elixir @spec write_ctrl_reg_4(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `ctrl_reg_4` register. ## Example iex> write_ctrl_reg_4(conn, <<0>>) {:ok, _conn} # `write_ctrl_reg_5` ```elixir @spec write_ctrl_reg_5(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `ctrl_reg_5` register. ## Example iex> write_ctrl_reg_5(conn, <<0>>) {:ok, _conn} # `write_ctrl_reg_6` ```elixir @spec write_ctrl_reg_6(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `ctrl_reg_6` register. ## Example iex> write_ctrl_reg_6(conn, <<0>>) {:ok, _conn} # `write_fifo_ctrl_reg` ```elixir @spec write_fifo_ctrl_reg(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `fifo_ctrl_reg` register. ## Example iex> write_fifo_ctrl_reg(conn, <<0>>) {:ok, _conn} # `write_int1_cfg` ```elixir @spec write_int1_cfg(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `int1_cfg` register. ## Example iex> write_int1_cfg(conn, <<0>>) {:ok, _conn} # `write_int1_duration` ```elixir @spec write_int1_duration(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `int1_duration` register. ## Example iex> write_int1_duration(conn, <<0>>) {:ok, _conn} # `write_int1_ths` ```elixir @spec write_int1_ths(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `int1_ths` register. ## Example iex> write_int1_ths(conn, <<0>>) {:ok, _conn} # `write_int2_cfg` ```elixir @spec write_int2_cfg(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `int2_cfg` register. ## Example iex> write_int2_cfg(conn, <<0>>) {:ok, _conn} # `write_int2_duration` ```elixir @spec write_int2_duration(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `int2_duration` register. ## Example iex> write_int2_duration(conn, <<0>>) {:ok, _conn} # `write_int2_ths` ```elixir @spec write_int2_ths(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `int2_ths` register. ## Example iex> write_int2_ths(conn, <<0>>) {:ok, _conn} # `write_reference` ```elixir @spec write_reference(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `reference` register. ## Example iex> write_reference(conn, <<0>>) {:ok, _conn} # `write_temp_cfg_reg` ```elixir @spec write_temp_cfg_reg(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `temp_cfg_reg` register. ## Example iex> write_temp_cfg_reg(conn, <<0>>) {:ok, _conn} # `write_time_latency` ```elixir @spec write_time_latency(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `time_latency` register. ## Example iex> write_time_latency(conn, <<0>>) {:ok, _conn} # `write_time_limit` ```elixir @spec write_time_limit(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `time_limit` register. ## Example iex> write_time_limit(conn, <<0>>) {:ok, _conn} # `write_time_window` ```elixir @spec write_time_window(Wafer.Conn.t(), data :: binary()) :: {:ok, Wafer.Conn.t()} | {:error, reason :: any()} ``` Write new contents to the `time_window` register. ## Example iex> write_time_window(conn, <<0>>) {:ok, _conn} --- *Consult [api-reference.md](api-reference.md) for complete listing*