     * busy reports
 
   # State machine
-  The firmware starts in a `:boot` state. It then loads all paramaters
-  writes all paramaters, and goes to idle if all params were loaded successfully.
+  The firmware starts in a `:transport_boot` state, moving to `:boot`. It then
+  loads all paramaters writes all paramaters, and goes to idle if all params
+  were loaded successfully.
 
   State machine flows go as follows:
   ## Boot
-      :boot
+      :transport_boot
+      |> :boot
       |> :no_config
       |> :configuration
       |> :idle

  """
  defdelegate request(server \\ __MODULE__, code), to: Request

  def close_transport(server \\ __MODULE__) do
    _ = command(server, {nil, {:emergency_lock, []}})
    GenServer.call(server, :close_transport)
  end

  def open_transport(server \\ __MODULE__) do
  end

  @doc """

    {:noreply, state}
  end

  # Closing the transport will purge the buffer of queued commands in both
  # the `configuration_queue` and in the `command_queue`.
  def handle_call(:close_transport, _from, %{status: s} = state) when s != :transport_boot do
    true = Process.demonitor(state.transport_ref)
    :ok = GenServer.stop(state.transport_pid, :normal)

    state =
      goto(
        %{
          state
          | transport_pid: nil,
            transport_ref: nil,
            status: :transport_boot,
            command_queue: [],
            configuration_queue: []
        },
        :transport_boot
      )

    {:reply, :ok, state}
  end

  def handle_call(:close_transport, _, %{status: s} = state) do
    {:reply, {:error, s}, state}
  end

  def handle_call(:open_transport, _from, %{status: s} = state) when s == :transport_boot do
    send(self(), :timeout)
    {:reply, :ok, state}
  end

  def handle_call(:open_transport, _from, %{status: s} = state) do
    {:reply, {:error, s}, state}
  end

  def handle_call({_tag, _code} = gcode, from, state) do
