defmodule Nrf24 do
@moduledoc """
Library for trasmitting and receiveing data with nRF24L01+
transciever.
It works, by default, in ShockBurst mode with ACK (auto
acknowledgement) and CRC check enabled. However it can be configured
to disable both.
"""
use GenServer
require Logger
alias Nrf24.Transciever
# Client
@type init_options() :: [
name: GenServer.name(),
ce_pin: integer(),
csn_pin: integer(),
channel: integer(),
crc_length: 0 | 1 | 2,
speed: :low | :medium | :hi,
pipes: [
[
pipe_no: integer(),
address: integer(),
payload_size: integer(),
auto_ack: boolean()
]
]
]
@doc """
nRF24L01+ GenServer start_link options
* `:name` - GenServer nome
* `:bus_name` - SPI bus name (e.g. "spidev0.0", "spidev1.0", default: "spidev0.0")
* `:ce_pin` - Rasbperry PI pin to which transciever's CE pin is connected
* `:csn_pin` - Rasbperry PI pin to which transciever's CSN pin is connected
* `:channel` - Frequency channel on which transciever will operate (default: 0x4c)
* `:crc_length` - CRC length for transmitted data verification (values: 1, 2, default: 2)
* `:speed` - Data transfer speed (values: low, med, high, default: med)
Data speed values:
* `:low` - 250Kbp
* `:medium` - 1Mbps
* `:high` - 2Mbps
Pipe configuration options:
* `:pipe_no` - Pipe number (values 0 to 5)
* `:address` - For pipes 0 and 1 5-byte address and for other single byte address
* `:payload_size` - Size of data that will be received through the pipe
* `:auto_ack` - Turning auto-acknowledge on or off for the pipe (default: true)
If pipes configuration is missing, default, factory set, valuse will be used.
"""
@spec start_link(init_options()) :: GenServer.on_start()
def start_link(args) do
options = Keyword.take(args, [:name])
GenServer.start_link(__MODULE__, args, options)
end
# Server
@impl GenServer
def init(args) do
bus_name = Keyword.get(args, :bus_name, "spidev0.0")
case Circuits.SPI.open(bus_name) do
{:error, error} ->
{:stop, error}
{:ok, spi} ->
ce_pin = Keyword.get(args, :ce_pin)
csn_pin = Keyword.get(args, :csn_pin)
channel = Keyword.get(args, :channel, 0x4C)
crc_length = Keyword.get(args, :crc_length, 2)
speed = Keyword.get(args, :speed, :medium)
with {:ok, _} <- Transciever.set_channel(spi, channel),
{:ok, _} <- Transciever.set_crc_length(spi, crc_length),
{:ok, _} <- Transciever.set_speed(spi, speed) do
Keyword.get(args, :pipes, [])
|> Enum.each(fn pipe_opts ->
pipe_no = Keyword.get(pipe_opts, :pipe_no)
Transciever.set_pipe(spi, pipe_no, pipe_opts)
end)
state = %{
spi: spi,
ce_pin: ce_pin,
csn_pin: csn_pin
}
{:ok, state}
else
{:error, error} -> {:stop, error}
end
end
end
@impl GenServer
def handle_call({:set_channel, channel}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.set_channel(spi, channel), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call({:set_crc_length, length}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.set_crc_length(spi, length), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call(:set_receive_mode, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.set_receive_mode(spi), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call(:set_transmit_mode, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.set_transmit_mode(spi), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call(:power_on, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.power_on(spi), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call(:power_off, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.power_off(spi), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call({:set_speed, speed}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.set_speed(spi, speed), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call({:set_pipe_address, pipe_no, address}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.set_pipe_address(spi, pipe_no, address), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call({:set_trasmit_address, address}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.set_transmit_address(spi, address), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call({:set_payload_size, pipe_no, payload_size}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.set_payload_size(spi, pipe_no, payload_size), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call({:ack_on, pipe_no}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.ack(spi, pipe_no, true), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call({:ack_off, pipe_no}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.ack(spi, pipe_no, false), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call({:enable_pipe, pipe_no}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.enable_pipe(spi, pipe_no), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call({:disable_pipe, pipe_no}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.disable_pipe(spi, pipe_no), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call({:set_retransmit_delay, delay}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.set_retransmit_delay(spi, delay), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call({:set_retransmit_count, count}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.set_retransmit_count(spi, count), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call(:reset_status, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.reset_status(spi), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call({:set_pipe, pipe_no, options}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.set_pipe(spi, pipe_no, options), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call(:start_listening, _from, state = %{spi: spi, ce_pin: ce_pin}) do
if is_reference(spi) do
{:reply, Transciever.start_listening(spi, ce_pin), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call(:stop_listening, _from, state = %{spi: spi, ce_pin: ce_pin}) do
if is_reference(spi) do
{:reply, Transciever.stop_listening(spi, ce_pin), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call(:reset_device, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.reset(spi), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call({:read_data, payload_size}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.read_data(spi, payload_size), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call({:write_register, reg, value}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.write_register(spi, reg, value), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call({:read_register, reg}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.read_register(spi, reg), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
def handle_call({:read_register, reg, bytes_no}, _from, state = %{spi: spi}) do
if is_reference(spi) do
{:reply, Transciever.read_register(spi, reg, bytes_no), state}
else
{:reply, {:error, :spi_not_opened}}
end
end
@impl GenServer
def handle_cast({:send, address, data}, state = %{spi: spi, csn_pin: csn_pin, ce_pin: ce_pin}) do
with :ok <- Transciever.start_sending(spi, address),
{:ok, ce} <- Transciever.send_data(spi, data, csn_pin, ce_pin) do
Process.send_after(self(), {:stop_sending, ce}, 1)
else
{:error, error} ->
Logger.info("Send data failed with error: #{inspect(error)}")
_ ->
Logger.info("Send data failed with unknown error")
end
{:noreply, state}
end
@impl GenServer
def handle_info({:stop_sending, ce}, state) do
Transciever.stop_sending(ce)
{:noreply, state}
end
@impl GenServer
def terminate(_reason, %{spi: spi}) do
if is_reference(spi), do: Circuits.SPI.close(spi)
end
end
