Remove speed params from things that don't need it

lib/farmbot/celery_script/ast/node/calibrate.ex

@@ -3,33 +3,27 @@ defmodule Farmbot.CeleryScript.AST.Node.Calibrate do
   use Farmbot.CeleryScript.AST.Node
   allow_args [:axis, :speed]
 
-  @default_speed 100
-
   def execute(%{axis: :all}, _, env) do
     env = mutate_env(env)
-    do_reduce([:z, :y, :x], @default_speed, env)
+    do_reduce([:z, :y, :x], env)
   end
 
-  def execute(%{speed: speed, axis: axis}, _, env) do
+  def execute(%{axis: axis}, _, env) do
     env = mutate_env(env)
-    case Farmbot.Firmware.calibrate(axis, speed) do
+    case Farmbot.Firmware.calibrate(axis) do
       :ok -> {:ok, env}
       {:error, reason} -> {:error, reason, env}
     end
   end
 
-  def execute(%{axis: _axis} = args, body, env) do
-    execute(Map.put(args, :speed, @default_speed), body, env)
-  end
-
-  defp do_reduce([axis | rest], speed, env) do
-    case execute(%{axis: axis, speed: speed}, [], env) do
-      {:ok, new_env} -> do_reduce(rest, speed, new_env)
+  defp do_reduce([axis | rest], env) do
+    case execute(%{axis: axis}, [], env) do
+      {:ok, new_env} -> do_reduce(rest, new_env)
       {:error, reason, env} -> {:error, reason, env}
     end
   end
 
-  defp do_reduce([], _, env) do
+  defp do_reduce([], env) do
     {:ok, env}
   end
 end

lib/farmbot/celery_script/ast/node/find_home.ex

@@ -3,43 +3,43 @@ defmodule Farmbot.CeleryScript.AST.Node.FindHome do
   use Farmbot.CeleryScript.AST.Node
   allow_args [:speed, :axis]
 
-  def execute(%{speed: speed, axis: :all}, _, env) do
+  def execute(%{axis: :all}, _, env) do
     env = mutate_env(env)
-    do_reduce([:z, :y, :x], speed, env)
+    do_reduce([:z, :y, :x], env)
   end
 
-  def execute(%{speed: speed, axis: axis}, _, env) do
+  def execute(%{axis: axis}, _, env) do
     env = mutate_env(env)
     ep = Farmbot.BotState.get_param(:"movement_enable_endpoints_#{axis}")
     ec = Farmbot.BotState.get_param(:"encoder_enabled_#{axis}")
-    do_find_home(ep, ec, axis, speed, env)
+    do_find_home(ep, ec, axis, env)
   end
 
-  defp do_reduce([axis | rest], speed, env) do
-    case execute(%{axis: axis, speed: speed}, [], env) do
-      {:ok, new_env} -> do_reduce(rest, speed, new_env)
+  defp do_reduce([axis | rest], env) do
+    case execute(%{axis: axis}, [], env) do
+      {:ok, new_env} -> do_reduce(rest, new_env)
       {:error, reason, env} -> {:error, reason, env}
     end
   end
 
-  defp do_reduce([], _, env) do
+  defp do_reduce([], env) do
     {:ok, env}
   end
 
-  defp do_find_home(ep, ec, axis, speed, env)
+  defp do_find_home(ep, ec, axis, env)
 
-  defp do_find_home(ep, ec, axis, _, env) when ((ep == 0) or (ep == nil)) and ((ec == 0) or (ec == nil)) do
+  defp do_find_home(ep, ec, axis, env) when ((ep == 0) or (ep == nil)) and ((ec == 0) or (ec == nil)) do
     {:error, "Could not find home on #{axis} axis because endpoints and encoders are disabled.", env}
   end
 
-  defp do_find_home(ep, ec, axis, speed, env) when ep == 1 or ec == 1 do
-    case Farmbot.Firmware.find_home(axis, speed) do
+  defp do_find_home(ep, ec, axis, env) when ep == 1 or ec == 1 do
+    case Farmbot.Firmware.find_home(axis) do
       :ok -> {:ok, env}
       {:error, reason} -> {:error, reason, env}
     end
   end
 
-  defp do_find_home(ep, ec, _axis, _speed, env) do
+  defp do_find_home(ep, ec, _axis, env) do
     {:error, "Unknown  state of endpoints: #{ep} or encoders: #{ec}", env}
   end
 

lib/farmbot/celery_script/ast/node/home.ex

@@ -3,27 +3,19 @@ defmodule Farmbot.CeleryScript.AST.Node.Home do
   use Farmbot.CeleryScript.AST.Node
   allow_args [:speed, :axis]
 
-  def execute(%{speed: speed, axis: :all}, _, env) do
+  def execute(%{axis: :all}, _, env) do
     env = mutate_env(env)
-    do_reduce([:z, :y, :x], speed, env)
-  end
-
-  def execute(%{speed: speed, axis: axis}, _, env) do
-    env = mutate_env(env)
-    case Farmbot.Firmware.home(axis, speed) do
+    case Farmbot.Firmware.home_all() do
       :ok -> {:ok, env}
       {:error, reason} -> {:error, reason, env}
     end
   end
 
-  defp do_reduce([axis | rest], speed, env) do
-    case execute(%{axis: axis, speed: speed}, [], env) do
-      {:ok, new_env} -> do_reduce(rest, speed, new_env)
-      {:error, reason, env} -> {:error, reason, env}
+  def execute(%{axis: axis}, _, env) do
+    env = mutate_env(env)
+    case Farmbot.Firmware.home(axis) do
+      :ok -> {:ok, env}
+      {:error, reason} -> {:error, reason, env}
     end
   end
-
-  defp do_reduce([], _, env) do
-    {:ok, env}
-  end
 end

lib/farmbot/firmware/firmware.ex

@@ -10,18 +10,23 @@ defmodule Farmbot.Firmware do
   end
 
   @doc "Calibrate an axis."
-  def calibrate(axis, speed) do
-    GenStage.call(__MODULE__, {:calibrate, [axis, speed]}, :infinity)
+  def calibrate(axis) do
+    GenStage.call(__MODULE__, {:calibrate, [axis]}, :infinity)
   end
 
   @doc "Find home on an axis."
-  def find_home(axis, speed) do
-    GenStage.call(__MODULE__, {:find_home, [axis, speed]}, :infinity)
+  def find_home(axis) do
+    GenStage.call(__MODULE__, {:find_home, [axis]}, :infinity)
+  end
+
+  @doc "Home every axis."
+  def home_all() do
+    GenStage.call(__MODULE__, {:home_all, []}, :infinity)
   end
 
   @doc "Home an axis."
-  def home(axis, speed) do
-    GenStage.call(__MODULE__, {:home, [axis, speed]}, :infinity)
+  def home(axis) do
+    GenStage.call(__MODULE__, {:home, [axis]}, :infinity)
   end
 
   @doc "Manually set an axis's current position to zero."

lib/farmbot/firmware/handler.ex

@@ -39,16 +39,19 @@ defmodule Farmbot.Firmware.Handler do
   @callback move_absolute(handler, vec3, speed, speed, speed) :: fw_ret_val
 
   @doc "Calibrate an axis."
-  @callback calibrate(handler, axis, speed) :: fw_ret_val
+  @callback calibrate(handler, axis) :: fw_ret_val
 
   @doc "Find home on an axis."
-  @callback find_home(handler, axis, speed) :: fw_ret_val
+  @callback find_home(handler, axis) :: fw_ret_val
 
   @doc "Manually set an axis's current position to zero."
   @callback zero(handler, axis) :: fw_ret_val
 
   @doc "Home an axis."
-  @callback home(handler, axis, speed) :: fw_ret_val
+  @callback home(handler, axis) :: fw_ret_val
+
+  @doc "Home every axis."
+  @callback home_all(handler) :: fw_ret_val
 
   @doc "Update a paramater."
   @callback update_param(handler, fw_param, number) :: fw_ret_val

lib/farmbot/firmware/stub_handler.ex

@@ -18,16 +18,20 @@ defmodule Farmbot.Firmware.StubHandler do
     GenStage.call(handler, {:move_absolute, pos, x_speed, y_speed, z_speed})
   end
 
-  def calibrate(handler, axis, speed) do
-    GenStage.call(handler, {:calibrate, axis, speed})
+  def calibrate(handler, axis) do
+    GenStage.call(handler, {:calibrate, axis})
   end
 
-  def find_home(handler, axis, speed) do
-    GenStage.call(handler, {:find_home, axis, speed})
+  def find_home(handler, axis) do
+    GenStage.call(handler, {:find_home, axis})
   end
 
-  def home(handler, axis, speed) do
-    GenStage.call(handler, {:home, axis, speed})
+  def home_all(handler) do
+    GenStage.call(handler, :home_all)
+  end
+
+  def home(handler, axis) do
+    GenStage.call(handler, {:home, axis})
   end
 
   def zero(handler, axis) do
@@ -118,15 +122,15 @@ defmodule Farmbot.Firmware.StubHandler do
     {:reply, :ok, stub_responses, %{state | pos: pos}}
   end
 
-  def handle_call({:calibrate, _axis, _speed}, _from, state) do
+  def handle_call({:calibrate, _axis}, _from, state) do
     {:reply, :ok, [:done], state}
   end
 
-  def handle_call({:find_home, _axis, _speed}, _from, state) do
+  def handle_call({:find_home, _axis}, _from, state) do
     {:reply, :ok, [:done], state}
   end
 
-  def handle_call({:home, axis, _speed}, _from, state) do
+  def handle_call({:home, axis}, _from, state) do
     state = %{state | pos: %{state.pos | axis => 0}}
     response = [
       :"report_axis_home_complete_#{axis}",
@@ -138,6 +142,20 @@ defmodule Farmbot.Firmware.StubHandler do
     {:reply, :ok, response, state}
   end
 
+  def handle_call(:home_all, _from, state) do
+    state = %{state | pos: %{state.pos | x: 0, y: 0, z: 0}}
+    response = [
+      :report_axis_home_complete_x,
+      :report_axis_home_complete_y,
+      :report_axis_home_complete_z,
+      {:report_current_position,        state.pos.x, state.pos.y, state.pos.z},
+      {:report_encoder_position_scaled, state.pos.x, state.pos.y, state.pos.z},
+      {:report_encoder_position_raw,    state.pos.x, state.pos.y, state.pos.z},
+      :done
+    ]
+    {:reply, :ok, response, state}
+  end
+
   def handle_call({:read_pin, pin, mode}, _from, state) do
     {:reply, :ok, [{:report_pin_mode, pin, mode}, {:report_pin_value, pin, 1}, :done], state}
   end

lib/farmbot/firmware/uart_handler/uart_handler.ex

@@ -16,16 +16,20 @@ defmodule Farmbot.Firmware.UartHandler do
     GenStage.call(handler, {:move_absolute, pos, x_speed, y_speed, z_speed})
   end
 
-  def calibrate(handler, axis, speed) do
-    GenStage.call(handler, {:calibrate, axis, speed})
+  def calibrate(handler, axis) do
+    GenStage.call(handler, {:calibrate, axis,})
   end
 
-  def find_home(handler, axis, speed) do
-    GenStage.call(handler, {:find_home, axis, speed})
+  def find_home(handler, axis) do
+    GenStage.call(handler, {:find_home, axis})
   end
 
-  def home(handler, axis, speed) do
-    GenStage.call(handler, {:home, axis, speed})
+  def home(handler, axis) do
+    GenStage.call(handler, {:home, axis})
+  end
+
+  def home_all(handler) do
+    GenStage.call(handler, :home_all)
   end
 
   def zero(handler, axis) do
@@ -248,7 +252,7 @@ defmodule Farmbot.Firmware.UartHandler do
     do_write(wrote, state)
   end
 
-  def handle_call({:calibrate, axis, _speed}, _from, state) do
+  def handle_call({:calibrate, axis}, _from, state) do
     num = case axis |> to_string() do
       "x" -> 14
       "y" -> 15
@@ -257,20 +261,24 @@ defmodule Farmbot.Firmware.UartHandler do
     do_write("F#{num}", state)
   end
 
-  def handle_call({:find_home, axis, speed}, _from, state) do
+  def handle_call({:find_home, axis}, _from, state) do
     cmd = case axis |> to_string() do
-      "x" -> "11 A#{speed}"
-      "y" -> "12 B#{speed}"
-      "z" -> "13 C#{speed}"
+      "x" -> "11"
+      "y" -> "12"
+      "z" -> "13"
     end
     do_write("F#{cmd}", state)
   end
 
-  def handle_call({:home, axis, speed}, _from, state) do
+  def handle_call(:home_all, _from, state) do
+    do_write("G28", state)
+  end
+
+  def handle_call({:home, axis}, _from, state) do
     cmd = case axis |> to_string() do
-      "x" -> "X0 A#{speed}"
-      "y" -> "Y0 B#{speed}"
-      "z" -> "Z0 C#{speed}"
+      "x" -> "X0"
+      "y" -> "Y0"
+      "z" -> "Z0"
     end
     do_write("G00 #{cmd}", state)
   end