fix stub handler, _if, toggle_pin

.gitignore

@@ -5,6 +5,7 @@
 /*.ez
 /doc
 /cover
+ttb_last_config
 
 # Nerves artifacts
 /_images

config/host/dev.exs

@@ -43,7 +43,7 @@ config :farmbot, Farmbot.System.ConfigStorage,
 # SystemTasks for host mode.
 config :farmbot, :behaviour,
   authorization: Farmbot.Bootstrap.Authorization,
-  system_tasks: Farmbot.Host.SystemTasks,
-  firmware_handler: Farmbot.Firmware.UartHandler
+  system_tasks: Farmbot.Host.SystemTasks
+  # firmware_handler: Farmbot.Firmware.UartHandler
 
 config :farmbot, :uart_handler, tty: "/dev/ttyACM0"

lib/farmbot/bot_state/bot_state.ex

@@ -123,6 +123,10 @@ defmodule Farmbot.BotState do
     GenStage.call(__MODULE__, {:get_pin_value, num})
   end
 
+  def get_current_pos do
+    GenStage.call(__MODULE__, :get_current_pos)
+  end
+
   @doc false
   def set_busy(bool) do
     GenStage.call(__MODULE__, {:set_busy, bool})
@@ -214,6 +218,10 @@ defmodule Farmbot.BotState do
     {:reply, state.user_env, [], state}
   end
 
+  def handle_call(:get_current_pos, _from, state) do
+    {:reply, state.location_data.position, [], state}
+  end
+
   defp do_handle([], state), do: state
 
   defp do_handle([{:config, "settings", key, val} | rest], state) do

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

@@ -21,28 +21,34 @@ defmodule Farmbot.CeleryScript.AST.Node.If do
     end
   end
 
-  defp eval_lhs(:x), do: -1
-  defp eval_lhs(:y), do: -1
-  defp eval_lhs(:z), do: -1
-  defp eval_lhs({:pin, pin}), do: -1
+  defp eval_lhs(axis) when axis in [:x, :y, :z] do
+    Farmbot.BotState.get_current_pos |> Map.get(axis)
+  end
+
+  defp eval_lhs({:pin, pin}) do
+    case Farmbot.BotState.get_pin_value(pin) do
+      {:ok, val} -> val
+      {:error, reason} -> {:error, reason}
+    end
+  end
 
   defp eval_if(nil, :is_undefined, _), do: true
   defp eval_if(_,   :is_undefined, _), do: false
   defp eval_if(nil, _, _), do: {:error, "left hand side undefined."}
 
   defp eval_if(lhs, :>, rhs) when lhs > rhs, do: true
-  defp eval_if(lhs, :>, rhs), do: false
+  defp eval_if(_lhs, :>, _rhs), do: false
 
   defp eval_if(lhs, :<, rhs) when lhs < rhs, do: true
-  defp eval_if(lhs, :<, rhs), do: false
+  defp eval_if(_lhs, :<, _rhs), do: false
 
   defp eval_if(lhs, :==, rhs) when lhs == rhs, do: true
-  defp eval_if(lhs, :==, rhs), do: false
+  defp eval_if(_lhs, :==, _rhs), do: false
 
   defp eval_if(lhs, :!=, rhs) when lhs != rhs, do: true
-  defp eval_if(lhs, :!=, rhs), do: false
+  defp eval_if(_lhs, :!=, _rhs), do: false
 
-  defp do_jump({:error, reason} = err, _, _, env), do: {:error, reason, env}
+  defp do_jump({:error, reason}, _, _, env), do: {:error, reason, env}
 
   defp do_jump(true,  _else, then_, env), do: Farmbot.CeleryScript.execute(then_, env)
   defp do_jump(false, else_, _then, env), do: Farmbot.CeleryScript.execute(else_, env)

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

@@ -16,13 +16,4 @@ defmodule Farmbot.CeleryScript.AST.Node.TogglePin do
       {:error, reason} -> {:error, reason, env}
     end
   end
-
-  defp do_get_pin_value(num, env) do
-    case Farmbot.BotState.get_pin_value(num) do
-      {:ok, 0}  -> Node.WritePin.execute(%{pin_mode: :digital, pin_number: num, pin_value: 1}, [], env)
-      {:ok, 1}  -> Node.WritePin.execute(%{pin_mode: :digital, pin_number: num, pin_value: 0}, [], env)
-      {:ok, -1} -> Node.WritePin.execute(%{pin_mode: :digital, pin_number: num, pin_value: 0}, [], env)
-      {:error, reason} -> {:error, reason, env}
-    end
-  end
 end

lib/farmbot/firmware/firmware.ex

@@ -117,7 +117,7 @@ defmodule Farmbot.Firmware do
   end
 
   def handle_call({fun, _}, _from, state = %{initialized: false}) when fun not in  [:read_all_params, :update_param, :emergency_unlock, :emergency_lock] do
-    {:reply, {:error, :uninitialized}, state}
+    {:reply, {:error, :uninitialized}, [], state}
   end
 
   def handle_call({fun, args}, from, state) do

lib/farmbot/firmware/handler.ex

@@ -54,7 +54,10 @@ defmodule Farmbot.Firmware.Handler do
   @callback update_param(handler, fw_param, number) :: fw_ret_val
 
   @doc "Read a paramater."
-  @callback read_param(handler, fw_param) :: {:ok, number} | {:error, term}
+  @callback read_param(handler, fw_param) :: fw_ret_val
+
+  @doc "Read all params"
+  @callback read_all_params(handler) :: fw_ret_val
 
   @doc "Lock the firmware."
   @callback emergency_lock(handler) :: fw_ret_val
@@ -67,4 +70,5 @@ defmodule Farmbot.Firmware.Handler do
 
   @doc "Write a pin."
   @callback write_pin(handler, pin, pin_mode, number) :: fw_ret_val
+
 end

lib/farmbot/firmware/stub_handler.ex

@@ -42,6 +42,10 @@ defmodule Farmbot.Firmware.StubHandler do
     GenStage.call(handler, {:read_param, param})
   end
 
+  def read_all_params(handler) do
+    GenStage.call(handler, :read_all_params)
+  end
+
   def emergency_lock(handler) do
     GenStage.call(handler, :emergency_lock)
   end
@@ -66,8 +70,13 @@ defmodule Farmbot.Firmware.StubHandler do
               locked?: false
   end
 
+  defp do_idle(pid) do
+    Process.send_after(pid, :idle_timer, 1000)
+  end
+
   def init([]) do
     state = %State{pos: struct(Vec3)}
+    do_idle(self())
     {:producer, state, dispatcher: GenStage.BroadcastDispatcher}
   end
 
@@ -75,6 +84,11 @@ defmodule Farmbot.Firmware.StubHandler do
     {:noreply, [], state}
   end
 
+  def handle_info(:idle_timer, state) do
+    do_idle(self())
+    {:noreply, [:idle], state}
+  end
+
   def handle_call({:move_absolute, pos, _speed}, _from, state) do
     {:reply, :ok, [{:report_current_position, pos.x, pos.y, pos.z}], %{state | pos: pos}}
   end
@@ -97,7 +111,7 @@ defmodule Farmbot.Firmware.StubHandler do
   end
 
   def handle_call({:read_pin, pin, mode}, _from, state) do
-    {:reply, {:ok, 1}, [{:report_pin_mode, pin, mode}, {:report_pin_value, pin, 1}], state}
+    {:reply, :ok, [{:report_pin_mode, pin, mode}, {:report_pin_value, pin, 1}], state}
   end
 
   def handle_call({:write_pin, pin, mode, value}, _from, state) do
@@ -118,7 +132,12 @@ defmodule Farmbot.Firmware.StubHandler do
   end
 
   def handle_call({:read_param, param}, _from, state) do
-    {:reply, state.fw_params[param], [], state}
+    res = state.fw_params[param]
+    {:reply, :ok, [{:report_paramater_value, param, res}], state}
+  end
+
+  def handle_call(:read_all_params, _from, state) do
+    {:reply, :ok, [:report_params_complete], state}
   end
 
   def handle_call(:emergency_lock, _from, state) do