Sync to GitHub

Author: CI

lib/bacnet/stack/segmentator.ex

@@ -493,27 +493,55 @@ defmodule BACnet.Stack.Segmentator do
 
               Telemetry.execute_segmentator_sequence_start(self(), new_sequence, state)
 
-              # Send first segment and wait for Segment ACK
-              case module.send(portal, destination, Map.get(segments, 0), opts) do
+              # If the transport module support reply_postponed/3, send Reply-Postponed Frame
+              # ASHRAE 135 Clause 9.8 (it is unlikely another transport layer implements it for any other reason)
+              postponed_result =
+                if function_exported?(module, :reply_postponed, 3) do
+                  case module.reply_postponed(portal, destination, []) do
+                    :ok ->
+                      :ok
+
+                    # An error like :slave_mode is not continuable,
+                    # as only a master node can hold the token,
+                    # and we need the token for segmentation
+                    {:error, continuable}
+                    when continuable in [:no_reply_pending, :destination_is_not_expecting_reply] ->
+                      :ok
+
+                    {:error, _err} = err ->
+                      err
+                  end
+                else
+                  :ok
+                end
+
+              case postponed_result do
                 :ok ->
-                  new_state = %State{
-                    state
-                    | sequences: Map.put(state.sequences, id, new_sequence)
-                  }
-
-                  {:ok, new_state}
-
-                {:error, _err} = error ->
-                  log_transport_send_error(error)
-
-                  Telemetry.execute_segmentator_sequence_stop(
-                    self(),
-                    new_sequence,
-                    :transport_error,
-                    state
-                  )
-
-                  {error, state}
+                  # Send first segment and wait for Segment ACK
+                  case module.send(portal, destination, Map.get(segments, 0), opts) do
+                    :ok ->
+                      new_state = %State{
+                        state
+                        | sequences: Map.put(state.sequences, id, new_sequence)
+                      }
+
+                      {:ok, new_state}
+
+                    {:error, _err} = error ->
+                      log_transport_send_error(error)
+
+                      Telemetry.execute_segmentator_sequence_stop(
+                        self(),
+                        new_sequence,
+                        :transport_error,
+                        state
+                      )
+
+                      {error, state}
+                  end
+
+                _other ->
+                  {postponed_result, state}
               end
             else
               # Too many segments for the remote device, send BUFFER_OVERFLOW Abort

lib/bacnet/stack/transport/mstp_transport.ex

@@ -620,6 +620,14 @@ if Code.ensure_loaded?(Circuits.UART) do
       GenServer.call(transport, {:is_destination_routed, destination})
     end
 
+    @doc """
+    Verifies whether the given destination is valid for the transport module.
+    """
+    @spec is_valid_destination(destination_address()) :: boolean()
+    def is_valid_destination(destination) do
+      is_integer(destination) and destination >= 0 and destination <= 255
+    end
+
     @doc """
     Sends data to the BACnet network.
 
@@ -792,11 +800,29 @@ if Code.ensure_loaded?(Circuits.UART) do
     end
 
     @doc """
-    Verifies whether the given destination is valid for the transport module.
+    Sends a Reply-Postponed Frame to the destination.
+
+    Sending an explicit Reply-Postponed Frame is necessary,
+    when the reply is to be segmented.
+    A segmented Complex-ACK APDU can only be transmitted
+    when we hold the token (ASHRAE 135 Clause 9.8).
+
+    There are no options at this time.
     """
-    @spec is_valid_destination(destination_address()) :: boolean()
-    def is_valid_destination(destination) do
-      is_integer(destination) and destination >= 0 and destination <= 255
+    @spec reply_postponed(
+            portal :: TransportBehaviour.portal(),
+            destination :: source_address(),
+            opts :: Keyword.t()
+          ) ::
+            :ok
+            | {:error, term()}
+            | {:error, :slave_mode}
+            | {:error, :no_reply_pending}
+            | {:error, :destination_is_not_expecting_reply}
+    def reply_postponed(portal, destination, opts \\ [])
+        when is_server(portal) and is_integer(destination) and destination >= 0 and
+               destination <= 254 and is_list(opts) do
+      GenServer.call(portal, {:reply_postponed, destination, opts}, @call_timeout)
     end
 
     @doc false
@@ -1311,6 +1337,63 @@ if Code.ensure_loaded?(Circuits.UART) do
       {:stop, :normal, :ok, state}
     end
 
+    def handle_call(:get_state, _from, %State{} = state) do
+      log_debug(fn ->
+        "BacMstpTransport: Received get_state request"
+      end)
+
+      {:reply, state.transport_state, state}
+    end
+
+    def handle_call(:disable_token_passing, _from, %State{local_address: local_addr} = state)
+        when local_addr < @min_slave_addr do
+      log_debug(fn ->
+        "BacMstpTransport: Received disable_token_passing request during state " <>
+          String.upcase(Atom.to_string(state.transport_state))
+      end)
+
+      new_state = %{state | disable_token_passing: true}
+
+      {:reply, :ok, new_state}
+    end
+
+    def handle_call(:disable_token_passing, _from, %State{} = state) do
+      log_debug(fn ->
+        "BacMstpTransport: Received disable_token_passing reques in slave_mode"
+      end)
+
+      {:reply, {:error, :slave_mode}, state}
+    end
+
+    def handle_call({:configure, %{} = opts}, _from, %State{} = state) do
+      log_debug(fn -> "BacMstpTransport: Received configure request" end)
+
+      new_opts = Map.merge(state.opts, opts)
+
+      reply =
+        case Map.fetch(opts, :baudrate) do
+          {:ok, baudrate} ->
+            with :ok <- UART.configure(state.uart_pid, speed: baudrate) do
+              ReceiveFSM.configure(state.receive_fsm, %{
+                baudrate: baudrate,
+                log_communication: new_opts.log_communication_rcv
+              })
+            end
+
+          :error ->
+            :ok
+        end
+
+      case reply do
+        :ok ->
+          new_state = %{state | opts: new_opts}
+          {:reply, :ok, new_state}
+
+        _other ->
+          {:reply, reply, state}
+      end
+    end
+
     def handle_call(:get_local_address, _from, %State{} = state) do
       log_debug("BacMstpTransport: Received get_local_address request")
 
@@ -1357,7 +1440,7 @@ if Code.ensure_loaded?(Circuits.UART) do
 
       {reply, new_state} =
         send_frame_data_not_expecting_reply(
-          %{state | transport_state: :idle},
+          %{state | transport_state: :idle, answer_invoke_id: nil},
           destination,
           data
         )
@@ -1483,63 +1566,46 @@ if Code.ensure_loaded?(Circuits.UART) do
       {:reply, {:error, :slave_mode}, state}
     end
 
-    def handle_call(:get_state, _from, %State{} = state) do
+    def handle_call(
+          {:reply_postponed, destination, _opts},
+          _from,
+          %State{local_address: local_addr, state_machine: %{source_address: source}} = state
+        )
+        when local_addr < @min_slave_addr do
       log_debug(fn ->
-        "BacMstpTransport: Received get_state request"
+        "BacMstpTransport: Received reply_postponed request"
       end)
 
-      {:reply, state.transport_state, state}
-    end
+      {reply, new_state} =
+        cond do
+          source != destination ->
+            {{:error, :destination_is_not_expecting_reply}, state}
 
-    def handle_call(:disable_token_passing, _from, %State{local_address: local_addr} = state)
-        when local_addr < @min_slave_addr do
-      log_debug(fn ->
-        "BacMstpTransport: Received disable_token_passing request during state " <>
-          String.upcase(Atom.to_string(state.transport_state))
-      end)
+          state.transport_state == :answer_data_request ->
+            # Remove the reply timer
+            state = state_cancel_silence_timer(state)
+            state = state_set_silence_timer(state, :timer_lost_token, @param_t_no_token)
 
-      new_state = %{state | disable_token_passing: true}
+            case send_frame_reply_postponed(state, destination) do
+              {:ok, state} -> {:ok, %{state | transport_state: :idle, answer_invoke_id: nil}}
+              {:error, state} -> {{:error, :sending_failed}, state}
+            end
 
-      {:reply, :ok, new_state}
+          true ->
+            {{:error, :no_reply_pending}, state}
+        end
+
+      {:reply, reply, new_state}
     end
 
-    def handle_call(:disable_token_passing, _from, %State{} = state) do
+    def handle_call({:reply_postponed, _destination, _opts}, _from, %State{} = state) do
       log_debug(fn ->
-        "BacMstpTransport: Received disable_token_passing reques in slave_mode"
+        "BacMstpTransport: Received reply_postponed request in slave mode"
       end)
 
       {:reply, {:error, :slave_mode}, state}
     end
 
-    def handle_call({:configure, %{} = opts}, _from, %State{} = state) do
-      log_debug(fn -> "BacMstpTransport: Received configure request" end)
-
-      new_opts = Map.merge(state.opts, opts)
-
-      reply =
-        case Map.fetch(opts, :baudrate) do
-          {:ok, baudrate} ->
-            with :ok <- UART.configure(state.uart_pid, speed: baudrate) do
-              ReceiveFSM.configure(state.receive_fsm, %{
-                baudrate: baudrate,
-                log_communication: new_opts.log_communication_rcv
-              })
-            end
-
-          :error ->
-            :ok
-        end
-
-      case reply do
-        :ok ->
-          new_state = %{state | opts: new_opts}
-          {:reply, :ok, new_state}
-
-        _other ->
-          {:reply, reply, state}
-      end
-    end
-
     def handle_call(_call, _from, state) do
       {:noreply, state}
     end

lib/bacnet/stack/transport_behaviour.ex

@@ -211,7 +211,16 @@ defmodule BACnet.Stack.TransportBehaviour do
               opts :: Keyword.t()
             ) :: :ok | {:error, term()}
 
-  @optional_callbacks max_ext_apdu_length: 0, max_ext_npdu_length: 0
+  @doc """
+  Sends a Reply-Postponed Frame to the destination, if supported by the Transport.
+
+  For some transports this is necessary in some situations, as such this is an optional callback,
+  with undefined options.
+  """
+  @callback reply_postponed(portal :: portal(), destination :: term(), opts :: Keyword.t()) ::
+              :ok | {:error, term()}
+
+  @optional_callbacks max_ext_apdu_length: 0, max_ext_npdu_length: 0, reply_postponed: 3
 
   @doc """
   Produces a supervisor child spec based on the BACnet transport `open` callback, as such