Circuits.UART: cannot receive data after disconnect/reconnect

Hi,

I have a problem with Circuits.UART: I wrote a simple application which read from a specific Serial device (arduino). If disconnected, Elixir will wait for it but currently Elixir find the newly connected device, open port and seems to read data (led is flashing on arduino because of serial activity) but handle_info/2 do not catch any message. Sometimes the led is simply not flashing after arduino is detected.
I am an Elixir beginner, any idea about this problem and optimizations are welcomed !

The code:
application.ex

defmodule Serial.Application do
  @moduledoc false

  use Application
  use Supervisor
  require Logger

  def init(_arg) do
        #IO.puts "Serial.Core.init()"
  end

  def start(_type, _args) do
    IO.puts "[#{__MODULE__}] started at #{inspect self()}"
    IO.puts "[#{__MODULE__}] Booting subprocesses..."

    children = [
      {Serial.Listener, []}
     ]

    opts = [strategy: :one_for_one, name: Serial.Supervisor]
    Supervisor.start_link(children, opts)
  end
end

listener.ex

defmodule Serial.Listener do
  use GenServer
  require Logger

  def start_link(args) do
    Logger.info "[#{__MODULE__}] started at #{inspect self()}"
    state = %{
      number: 3,
      core_pid: Enum.at(args, 0),
      serial_pid: nil,
      device: %{manufacturer: "Arduino (www.arduino.cc)", product_id: 67, serial_number: "95433", vendor_id: 9025}
    }
    GenServer.start_link(__MODULE__, state, [name: :serial_listener])
  end

  def init(state) do
    :observer.start
    case Circuits.UART.start_link do
      {:ok, pid}      ->
        Logger.info "[#{__MODULE__}] Circuits.UART started at: #{inspect(pid)}"
        state = Map.put(state, :serial_pid, pid)
        start_reader(pid, state)
        {:ok, state}

      {:error, reason} ->
        Logger.error "[#{__MODULE__}] cannot start Circuits.UART: #{reason}"
        {:error, reason}
    end
  end


  def start_reader(_pid, state) do
    Logger.info "STATE: #{inspect state}"
    available_devices = Circuits.UART.enumerate

    if map_size(available_devices) > 0 do
      Enum.each  available_devices,  fn {device_path, property} ->
        Logger.info "[#{__MODULE__}] device found #{device_path} --> #{inspect(property)}"

        if property == state.device do
          Logger.info "[#{__MODULE__}] selected device #{device_path} --> #{inspect(property)}"

          Circuits.UART.configure(state.serial_pid, framing: {Circuits.UART.Framing.Line, separator: "\r\n"})
          Circuits.UART.open(state.serial_pid, device_path, speed: 115200, active: true)
        end
      end

    else
      Logger.warn "[#{__MODULE__}] no device found"
      device_watch(state)
    end

    {:ok, state}
  end


  def handle_info({:circuits_uart, _serial_port, data}, state) do
    case data do
      {:error, :eio} ->
        Logger.warn "[#{__MODULE__}] device disconnected"
        watcher_pid = spawn(fn -> device_watch(state) end )
        Logger.info "[#{__MODULE__}] Watcher spawned at  #{inspect watcher_pid}"

      text ->
        Logger.debug text
    end
    {:noreply, state}
  end


  def device_watch(state) do
    available_devices = Circuits.UART.enumerate

    if map_size(available_devices) > 0 do
      Enum.each  available_devices,  fn {device_path, property} ->
        if property == state.device do
          Logger.info "[#{__MODULE__}] device back #{device_path} --> #{inspect(property)}"

          #Circuits.UART.close(state.serial_pid)
          #Circuits.UART.flush(state.serial_pid, :both)
          start_reader(state.serial_pid, state)
        end
      end

    else
      Logger.info "[#{__MODULE__}] wait for device..."
      Process.sleep(2000)
      device_watch(state)
    end
    {:noreply, state}
  end

end