Merge pull request #184 from ConnorRigby/master

New release

VERSION

@@ -1 +1 @@
-2.0.3
+2.0.4

lib/bot_command/bot_command_handler.ex

@@ -7,28 +7,37 @@ defmodule BotCommandHandler do
   """
 
   def init(_args) do
-    {:ok, pid} = GenEvent.start_link(name: BotCommandEventManager)
-    GenEvent.add_handler(pid, BotCommandManager, [])
-    spawn fn -> get_events(pid) end
-    {:ok, pid}
+    Process.flag(:trap_exit, true)
+    {:ok, manager} = GenEvent.start_link(name: BotCommandEventManager)
+    GenEvent.add_handler(manager, BotCommandManager, [])
+    handler = spawn_link fn -> get_events(manager) end
+    {:ok, {manager,handler}}
   end
 
   def start_link(args) do
     GenServer.start_link(__MODULE__, args, name: __MODULE__)
   end
 
-  def handle_cast({:add_event, event}, pid) do
-    GenEvent.notify(pid, event)
-    {:noreply, pid}
+  def handle_cast({:add_event, event}, {manager,handler}) do
+    GenEvent.notify(manager, event)
+    {:noreply, {manager,handler}}
   end
 
-  def handle_call(:get_pid, _from,  pid) do
-    {:reply, pid, pid}
+  def handle_call(:get_pid, _from,  {manager,handler}) do
+    {:reply, manager, {manager,handler}}
   end
 
-  def handle_call(:e_stop, _from, pid) do
-    GenEvent.notify(pid, :e_stop)
-    {:reply, :ok, pid}
+  def handle_call(:e_stop, _from, {manager,handler}) do
+    Process.flag(:trap_exit, true)
+    GenEvent.notify(manager, :e_stop)
+    Process.exit(handler, :e_stop)
+    {:reply, :ok, {manager,handler}}
+  end
+
+  def handle_info({:EXIT, _pid, reason}, {manager,_handler}) do
+    Logger.debug("something bad happened in #{__MODULE__}: #{inspect reason}")
+    new_pid = spawn_link fn -> get_events(manager) end
+    {:noreply, {manager, new_pid}}
   end
 
   def get_pid do
@@ -42,16 +51,28 @@ defmodule BotCommandHandler do
   @doc """
     Gets events from the GenEvent server (pid)
   """
-  def get_events(pid) do
-    events = GenEvent.call(pid, BotCommandManager, :events)
-    for event <- events do
-      Process.sleep(150)
-      check_busy
-      BotStatus.busy true
-      do_handle(event)
-      Process.sleep(50)
-    end
-    get_events(pid)
+  def get_events(manager) when is_pid(manager) do
+    events = GenEvent.call(manager, BotCommandManager, :events)
+    do_events(events)
+    get_events(manager)
+  end
+
+  def do_events([]) do
+    do_events(nil)
+  end
+
+  def do_events(nil) do
+    Process.sleep(10)
+  end
+
+  def do_events(events) when is_list(events) do
+    event = List.first(events)
+    Process.sleep(150)
+    check_busy
+    BotStatus.busy true
+    do_handle(event)
+    Process.sleep(50)
+    do_events(events -- [event])
   end
 
   defp check_busy do

lib/bot_command/bot_command_manager.ex

@@ -2,16 +2,16 @@ defmodule BotCommandManager do
   use GenEvent
   require Logger
 
-  # add event to the log
-  def handle_event({event, params}, events) do
-    {:ok, [{event, params} | events]}
-  end
-
   def handle_event(:e_stop, _) do
     # Destroy the event queue
     {:ok, []}
   end
 
+  # add event to the log
+  def handle_event({event, params}, events) do
+    {:ok, [{event, params} | events]}
+  end
+
   # dump teh current events to be handled
   def handle_call(:events, events) do
     {:ok, Enum.reverse(events), [] }

lib/bot_command/bot_commands.ex

@@ -8,8 +8,11 @@ defmodule Command do
     EMERGENCY STOP
   """
   def e_stop do
+    BotCommandHandler.e_stop
     UartHandler.send("E")
-    Process.exit(Process.whereis(BotCommandHandler), :kill)
+    SerialMessageManager.sync_notify({:send, "F82"})
+    pid = Process.whereis(UartHandler)
+    Process.exit(pid, :e_stop)
     :ok
   end
 

lib/json_rpc/json_rpc_message_handler.ex

@@ -80,6 +80,8 @@ defmodule RPCMessageHandler do
   # E STOP
   def do_handle("emergency_stop", _) do
     Command.e_stop
+    SequenceManager.e_stop
+    :ok
   end
 
   # Home All

lib/sequence/sequence_manager.ex

@@ -1,6 +1,7 @@
 defmodule SequenceManager do
   use GenServer
   require Logger
+
   def init(_arge) do
     {:ok, %{current: nil, global_vars: %{}, log: []}}
   end
@@ -9,6 +10,16 @@ defmodule SequenceManager do
     GenServer.start_link(__MODULE__, args, name: __MODULE__)
   end
 
+  def handle_call(:e_stop, _from, %{current: pid, global_vars: _, log: _})
+  when is_pid(pid) do
+    pid_exit = Process.exit(pid, :e_stop)
+    {:reply, pid_exit, %{current: nil, global_vars: %{}, log: []}}
+  end
+
+  def handle_call(:e_stop, _from, %{current: nil, global_vars: _, log: _}) do
+    {:reply, :no_process, %{current: nil, global_vars: %{}, log: []}}
+  end
+
   def handle_call({:add, seq}, _from, %{current: nil, global_vars: globals, log: []})
   when is_map(seq) do
     {:ok, pid} = Sequencer.do_sequence(seq)
@@ -55,4 +66,8 @@ defmodule SequenceManager do
     RPCMessageHandler.log(huh)
     Logger.debug(huh)
   end
+
+  def e_stop do
+    GenServer.call(__MODULE__, :e_stop)
+  end
 end

lib/sequence/sequencer.ex

@@ -134,8 +134,9 @@ defmodule Sequencer do
   end
 
   def terminate(reason, state) do
-    GenServer.call(SequenceManager, {:done, self()})
+    Logger.debug("Something weird happened")
     RPCMessageHandler.log("Sequence: #{state.name} finished with error: #{inspect reason}")
+    GenServer.call(SequenceManager, {:done, self()})
   end
 
   def load_external_sequence(url) do

lib/serial/gcode_message_handler.ex

@@ -55,7 +55,9 @@ defmodule GcodeMessageHandler do
 
   def do_handle({:gcode, { :report_current_position, position }}) do
     [x, y, z] = parse_coords(position)
+    Logger.debug("Reporting position #{inspect {x, y, z}}")
     BotStatus.set_pos(x,y,z)
+    RPCMessageHandler.send_status
   end
 
   def do_handle({:gcode, {:report_parameter_value, param }}) do

lib/serial/uart_handler.ex

@@ -39,6 +39,10 @@ defmodule UartHandler do
     GenServer.cast(__MODULE__, {:connect, tty, baud, active})
   end
 
+  def send("E") do
+    GenServer.call(__MODULE__, {:send, "E"})
+  end
+
   def send(str) do
     GenServer.cast(__MODULE__, {:send, str})
   end
@@ -48,6 +52,12 @@ defmodule UartHandler do
     {:reply, state, state}
   end
 
+
+  def handle_call({:send, "E"}, _from, {pid, tty}) do
+    Nerves.UART.write(pid, "E")
+    {:reply, :ok, {pid, tty}}
+  end
+
   def handle_cast({:connect, tty, baud, active}, state) do
     Nerves.UART.open(state, tty, speed: baud, active: active)
     Nerves.UART.configure(state, framing: {Nerves.UART.Framing.Line, separator: "\r\n"}, rx_framing_timeout: 500)
@@ -56,7 +66,7 @@ defmodule UartHandler do
 
   def handle_cast({:send, str}, {pid, tty}) do
     Nerves.UART.write(pid, str)
-    {:noreply,  {pid, tty}}
+    {:noreply, {pid, tty}}
   end
 
   def handle_info({:nerves_uart, _tty, {:error, _}}, state) do