Elixir cost function

config/config.exs

@@ -1,5 +1,4 @@
 import Config
-config :elevator, num_floors: 4
 
 if config_env() == :dev do
   config :pre_commit, commands: ["format --check-formatted"], verbose: true

lib/elevator.ex

@@ -1,5 +1,6 @@
 defmodule Elevator do
-  @num_floors Application.compile_env(:elevator, :num_floors, 4)
+  @num_floors 4
+  @door_open_duration_ms 1000
   # ms
   @resend_period 50
   @msg_ts_cutoff 10000
@@ -9,6 +10,10 @@ defmodule Elevator do
     @num_floors
   end
 
+  def door_open_duration_ms do
+    @door_open_duration_ms
+  end
+
   def resend_period do
     @resend_period
   end

lib/elevator/application.ex

@@ -10,9 +10,9 @@ defmodule Elevator.Application do
       Elevator.Communicator,
       {Elevator.HallOrders, Elevator.num_floors()},
       Elevator.CabOrders,
-      {Elevator.Hardware.Driver, [{127, 0, 0, 1}, driver_port]},
       Elevator.FSM.State,
       Elevator.FSM.Action,
+      {Elevator.Hardware.Driver, [{127, 0, 0, 1}, driver_port]},
       Elevator.Hardware.InputPoller
     ]
 

lib/elevator/decision.ex

@@ -5,13 +5,11 @@ defmodule Elevator.Decision do
   These functions are intentionally pure to make them easy to unit test.
   """
 
-  # Private helpers
-
-  defp requests_above?(reqs, floor) do
+  def requests_above?(reqs, floor) do
     Enum.any?(reqs, fn {f, _} -> f > floor end)
   end
 
-  defp requests_below?(reqs, floor) do
+  def requests_below?(reqs, floor) do
     Enum.any?(reqs, fn {f, _} -> f < floor end)
   end
 
@@ -31,7 +29,6 @@ defmodule Elevator.Decision do
       btn_type == :cab -> true
       direction == :up and btn_type == :hall_up -> true
       direction == :down and btn_type == :hall_down -> true
-      direction == :stop -> true
       true -> false
     end
   end
@@ -49,9 +46,7 @@ defmodule Elevator.Decision do
   @doc "Single decision function for elevator behavior.
   Returns both direction and behavior for the current state and order snapshot."
   @spec next_action(Elevator.Types.combined_order_map(), Elevator.FSM.State.t()) ::
-          {:down, :moving | :door_open}
-          | {:up, :moving | :door_open}
-          | {:stop, :idle | :door_open}
+          {Elevator.Types.elev_dir(), :moving | :door_open | :idle}
   def next_action(
         orders,
         %Elevator.FSM.State{
@@ -61,16 +56,14 @@ defmodule Elevator.Decision do
         }
       ) do
     btns_at_floor = Map.get(orders, floor, MapSet.new())
+    direction = if direction in [:up, :down], do: direction, else: :down
 
     cond do
-      between_floors and direction == :stop ->
-        {:down, :moving}
-
       between_floors ->
         {direction, :moving}
 
       map_size(orders) == 0 ->
-        {:stop, :idle}
+        {direction, :idle}
 
       direction == :up ->
         cond do
@@ -87,7 +80,7 @@ defmodule Elevator.Decision do
             {:down, :moving}
 
           true ->
-            {:stop, :idle}
+            {:up, :idle}
         end
 
       direction == :down ->
@@ -105,21 +98,11 @@ defmodule Elevator.Decision do
             {:up, :moving}
 
           true ->
-            {:stop, :idle}
-        end
-
-      direction == :stop ->
-        cond do
-          MapSet.member?(btns_at_floor, :hall_up) -> {:up, :door_open}
-          MapSet.member?(btns_at_floor, :hall_down) -> {:down, :door_open}
-          MapSet.member?(btns_at_floor, :cab) -> {:stop, :door_open}
-          requests_above?(orders, floor) -> {:up, :moving}
-          requests_below?(orders, floor) -> {:down, :moving}
-          true -> {:stop, :idle}
+            {:down, :idle}
         end
 
       true ->
-        {:stop, :idle}
+        {:down, :idle}
     end
   end
 end

lib/elevator/fsm/action.ex

@@ -9,7 +9,6 @@ defmodule Elevator.FSM.Action do
   alias Elevator.HallOrders
   alias Elevator.Decision
 
-  @door_open_time 1000
   @motor_timeout 4000
   @action_interval 100
 
@@ -100,7 +99,7 @@ defmodule Elevator.FSM.Action do
     if state.behavior == :door_open and
          Time.after?(
            Time.utc_now(),
-           Time.add(state.door_open_time, @door_open_time, :millisecond)
+           Time.add(state.door_open_time, Elevator.door_open_duration_ms(), :millisecond)
          ) do
       if state.obstructed do
         State.open_door()

lib/elevator/fsm/state.ex

@@ -6,7 +6,7 @@ defmodule Elevator.FSM.State do
   alias Elevator.Hardware.Outputs
   alias Elevator.Types
 
-  defstruct direction: :stop,
+  defstruct direction: :down,
             behavior: :idle,
             floor: :unknown,
             between_floors: true,

lib/elevator/hall_orders.ex

@@ -12,8 +12,6 @@ defmodule Elevator.HallOrders do
   @type floor :: Elevator.Types.floor()
   @type hall_btn :: Elevator.Types.hall_btn()
 
-  @tracked_key {0, :hall_up}
-
   @hall_order_refresh_period 1000
 
   def start_link(arg) do
@@ -135,16 +133,6 @@ defmodule Elevator.HallOrders do
       end)
       |> Enum.into(%{})
 
-    old_tracked = Map.get(order_map, @tracked_key)
-    new_tracked = Map.get(new_order_map, @tracked_key)
-
-    if old_tracked != new_tracked do
-      Logger.info(fn ->
-        "Tracked hall order #{inspect(@tracked_key)} changed: " <>
-          "#{inspect(old_tracked)} -> #{inspect(new_tracked)}"
-      end)
-    end
-
     {:noreply, new_order_map, {:continue, :hall_update_state}}
   end
 
@@ -169,9 +157,11 @@ defmodule Elevator.HallOrders do
 
     new_order_value = order_map[key]
 
-    Logger.info(fn ->
-      "Hall button press #{inspect(key)}: #{inspect(old_order_value)} -> #{inspect(new_order_value)}"
-    end)
+    if old_order_value != new_order_value do
+      Logger.debug(fn ->
+        "hall_button_press floor=#{floor} button=#{direction} from=#{inspect(old_order_value)} to=#{inspect(new_order_value)}"
+      end)
+    end
 
     {:noreply, order_map, {:continue, :hall_update_state}}
   end