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
