     * 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

  def init(args) do
    transport = Keyword.fetch!(args, :transport)
    side_effects = Keyword.get(args, :side_effects)
    fw = self()
    fun = fn {_, _} = code -> GenServer.cast(fw, code) end
    args = Keyword.put(args, :handle_gcode, fun)

    with {:ok, pid} <- GenServer.start_link(transport, args) do
      Process.monitor(pid)
      Logger.debug("Starting Firmware: #{inspect(args)}")

      state = %State{
        transport_pid: pid,
        transport: transport,
        side_effects: side_effects,
        status: :boot,
        command_queue: [],
        configuration_queue: []
      }

      {:ok, state}
    end
  end

  def terminate(reason, state) do
    for {pid, _code} <- state.command_queue, do: send(pid, reason)
  end

  def handle_info({:DOWN, _ref, :process, pid, reason}, %{transport_pid: pid} = state) do
    {:stop, reason, state}
  end

  # @spec handle_info(:timeout, state) :: {:noreply, state}


  @type state :: %State{
          transport: module(),
          transport_pid: nil | pid(),
          transport_ref: nil | reference(),
          transport_args: Keyword.t(),
          side_effects: nil | module(),
          status: status(),
          tag: GCODE.tag(),
