Merge pull request #198 from ConnorRigby/master

E stop fixes and regimen persistance

Author: ConnorRigby

lib/bot_command/bot_commands.ex

@@ -18,29 +18,44 @@ defmodule Command do
   def e_stop do
     msg = "E STOPPING!"
     Logger.debug(msg)
-    RPC.MessageHandler.log(msg, [:error_toast, :error_ticker], [@log_tag])
-    Serial.Handler.e_stop
-    Farmbot.Scheduler.e_stop
+    is_locked = BotState.get_status
+    |> Map.get(:informational_settings)
+    |> Map.get(:locked)
+    if(is_locked == false) do
+      GenServer.cast(BotState, {:update_info, :locked, true})
+      RPC.MessageHandler.log(msg, [:error_toast, :error_ticker], [@log_tag])
+      Serial.Handler.e_stop
+      Farmbot.Scheduler.e_stop_lock
+    end
   end
 
   @doc """
     resume from an e stop
   """
   @spec resume() :: :ok | :fail
   def resume do
-    RPC.MessageHandler.log("Bot Back Up and Running!", [:ticker], [@log_tag])
-    Serial.Handler.resume
-    params = BotState.get_status.mcu_params
-    case Enum.partition(params, fn({param, value}) ->
-      param_int = Gcode.Parser.parse_param(param)
-      Command.update_param(param_int, value)
-    end)
-    do
-      {_, []} ->
-        :ok
-      {_, failed} ->
-        Logger.error("Param setting failed! #{inspect failed}")
-        :fail
+    is_locked = BotState.get_status
+    |> Map.get(:informational_settings)
+    |> Map.get(:locked)
+    if(is_locked == true) do
+      Serial.Handler.resume
+      params = BotState.get_status.mcu_params
+      # The firmware takes forever to become ready again.
+      Process.sleep(2000)
+      case Enum.partition(params, fn({param, value}) ->
+        param_int = Gcode.Parser.parse_param(param)
+        Command.update_param(param_int, value)
+      end)
+      do
+        {_, []} ->
+          RPC.MessageHandler.log("Bot Back Up and Running!", [:ticker], [@log_tag])
+          GenServer.cast(BotState, {:update_info, :locked, false})
+          Farmbot.Scheduler.e_stop_unlock
+          :ok
+        {_, failed} ->
+          Logger.error("Param setting failed! #{inspect failed}")
+          :fail
+      end
     end
   end
 
@@ -197,16 +212,27 @@ defmodule Command do
   """
   @spec read_param(number) :: command_output
   def read_param(param) when is_integer param do
-    Gcode.Handler.block_send "F21 P#{param}"
+    case Gcode.Handler.block_send "F21 P#{param}" do
+      :timeout ->
+        Process.sleep(100)
+        read_param(param)
+      whatever -> whatever
+    end
   end
 
   @doc """
     Update a param. Param needs to be an integer.
   """
   @spec update_param(number | nil, number) :: command_output
   def update_param(param, value) when is_integer param do
-    Gcode.Handler.block_send "F22 P#{param} V#{value}"
-    Command.read_param(param)
+    case Gcode.Handler.block_send "F22 P#{param} V#{value}" do
+      :timeout ->
+        Process.sleep(10)
+        update_param(param, value)
+      _ ->
+      Process.sleep(100)
+      Command.read_param(param)
+    end
   end
 
   def update_param(nil, _value) do

lib/bot_state/bot_state.ex

@@ -6,6 +6,7 @@ defmodule BotState do
   @twelve_hours 3600000
 
   def init(_) do
+    NetMan.put_pid(BotState)
     save_interval
     check_updates
     {:ok, load}
@@ -30,6 +31,10 @@ defmodule BotState do
   end
 
   def load do
+    token = case  FarmbotAuth.get_token() do
+      {:ok, token} -> token
+      _ -> nil
+    end
     default_state = %{
       mcu_params: %{},
       location: [0, 0, 0],
@@ -41,10 +46,11 @@ defmodule BotState do
       informational_settings: %{
         controller_version: Fw.version,
         private_ip: nil,
-        throttled: get_throttled
+        throttled: get_throttled,
+        locked: false
       },
       authorization: %{
-        token: nil,
+        token: token,
         email: nil,
         pass: nil,
         server: nil,
@@ -185,6 +191,7 @@ defmodule BotState do
   end
 
   def handle_info({:connected, network, ip_addr}, state) do
+    Process.sleep(2000) # UGH
     # GenServer.cast(BotState, {:update_info, :private_ip, address})
     new_info = Map.put(state.informational_settings, :private_ip, ip_addr)
     email = state.authorization.email
@@ -202,8 +209,13 @@ defmodule BotState do
           Map.put(state, :authorization, auth)
           |> Map.put(:informational_settings, new_info)
         }
+      # If the bot is faster than your router (often) this can happen.
+      {:error, "enetunreach"} ->
+        Logger.warn("Something super weird happened.. Probably a race condition.")
+        # Just crash ourselves and try again.
+        {:crash, state}
       error ->
-        Logger.error("Something bad happened: #{inspect error}")
+        Logger.error("Something bad happened when logging in!: #{inspect error}")
         Fw.factory_reset
         {:noreply, state}
       end
@@ -235,8 +247,9 @@ defmodule BotState do
     GenServer.cast(__MODULE__, {:creds, {email, pass, server}})
   end
 
+  # setting that timeout is probably going to be a disaster.
   def get_status do
-    GenServer.call(__MODULE__, :state)
+    GenServer.call(__MODULE__, :state, :infinity)
   end
 
   def get_current_pos do

lib/bot_sync/bot_sync.ex

@@ -3,18 +3,32 @@ defmodule BotSync do
   require Logger
 
   def init(_args) do
-    {:ok, %{token: nil,
+    token = case FarmbotAuth.get_token() do
+      {:ok, token} -> token
+      _ -> nil
+    end
+    {:ok, %{token: token,
             resources: load_old_resources,
             corpuses: load_old_corpuses
             }}
   end
 
   def load_old_corpuses do
-    []
+    case SafeStorage.read(__MODULE__.Corpuses) do
+      {:ok, old} ->
+        Enum.each(old, fn(corpus) ->
+          Logger.debug("Compiling last known good corpuses.")
+          m = String.to_atom("Elixir.SequenceInstructionSet_"<>"#{corpus.tag}")
+          m.create_instruction_set(corpus)
+        end)
+        old
+      _ -> []
+    end
+    # []
   end
 
   def load_old_resources do
-     Sync.create(%{"checksum" => "loading...",
+     default = Sync.create(%{"checksum" => "loading...",
       "device" => %{
         "id" => -1,
         "planting_area_id" => -1,
@@ -27,6 +41,10 @@ defmodule BotSync do
       "regimens" =>      [],
       "sequences" =>     [],
       "users" =>         []})
+      case SafeStorage.read(__MODULE__.Resources) do
+        {:ok, %Sync{} = old_state} -> old_state
+        _ -> default
+      end
   end
 
   def start_link(args) do
@@ -37,8 +55,9 @@ defmodule BotSync do
     {:noreply, %{token: nil, resources: old, corpuses: oldc}}
   end
 
+  # When new stuff comes in from a sync
   def handle_cast(:sync, %{token: token, resources: old, corpuses: oldc}) do
-    server = Map.get(token, "unencoded") |> Map.get("iss")
+    "//" <> server = Map.get(token, "unencoded") |> Map.get("iss")
     auth = Map.get(token, "encoded")
 
     case HTTPotion.get "#{server}/api/sync",
@@ -61,19 +80,16 @@ defmodule BotSync do
        end
        new_merged = Map.merge(old ,new)
        RPC.MessageHandler.log("Synced", [], ["BotSync"])
+       SafeStorage.write(__MODULE__.Resources, :erlang.term_to_binary(new_merged))
+       SafeStorage.write(__MODULE__.Corpuses, :erlang.term_to_binary(oldc))
        {:noreply, %{token: token, resources: new_merged, corpuses: oldc }}
      error ->
-       Logger.debug("Couldn't get resources: #{error}")
+       Logger.debug("Couldn't get resources: #{inspect error}")
        RPC.MessageHandler.log("Error syncing: #{inspect error}", [:error_toast], ["BotSync"])
        {:noreply, %{token: token, resources: old, corpuses: oldc}}
     end
   end
 
-  def handle_call(_,_from, %{token: nil, resources: old, corpuses: oldc}) do
-    Logger.debug("Please make sure you have a token first.")
-    {:reply, :no_token, %{token: nil, resources: old, corpuses: oldc}}
-  end
-
   def handle_call({:save_sequence, seq}, _from, %{token: token, resources: resources, corpuses: oldc}) do
     new_resources = Map.put(resources, "sequences", [seq | Map.get(resources, "sequences")] )
     {:reply, :ok, %{token: token, resources: new_resources, corpuses: oldc}}
@@ -122,13 +138,13 @@ defmodule BotSync do
         msg = "Compiling Sequence Instruction Set"
         Logger.debug(msg)
         RPC.MessageHandler.log(msg, [], ["BotSync"])
-        server = Map.get(token, "unencoded") |> Map.get("iss")
+        "//"<>server = Map.get(token, "unencoded") |> Map.get("iss")
         c = get_corpus_from_server(server, id)
         m = String.to_atom("Elixir.SequenceInstructionSet_"<>"#{id}")
         m.create_instruction_set(c)
         {:reply, Module.concat(SiS, "Corpus_#{id}"),
           %{token: token,
-            resources: resources, corpuses: oldc ++ [Corpus.create(c)] }}
+            resources: resources, corpuses: oldc ++ [c] }}
       _corpuses ->
         {:reply, Module.concat(SiS, "Corpus_#{id}"),
           %{token: token, resources: resources, corpuses: oldc}}
@@ -145,6 +161,7 @@ defmodule BotSync do
                            headers: _headers,
                            status_code: 200} ->
          Poison.decode!(body)
+         |> Corpus.create
         error -> error
      end
   end