feat: support interrupts and power saving mode

Author: mnishiguchi

lib/veml7700.ex

@@ -65,7 +65,7 @@ defmodule VEML7700 do
   end
 
   @doc """
-  Get the ambient light settings.
+  Get the ambient light sensor settings.
   """
   @spec get_als_config(GenServer.server()) ::
           {:error, any} | {:ok, {setting_names :: [atom], resolution :: float}}
@@ -74,14 +74,72 @@ defmodule VEML7700 do
   end
 
   @doc """
-  Set the ambient light settings.
+  Set the ambient light sensor settings.
   """
   @spec set_als_config(GenServer.server(), als_gain | als_integration_time) ::
           {:error, any} | {:ok, {setting_names :: [atom], resolution :: float}}
   def set_als_config(server \\ __MODULE__, als_setting_names) do
     GenServer.call(server, {:set_als_config, als_setting_names})
   end
 
+  @doc """
+  Get the low threshold.
+  """
+  @spec get_low_threshold(GenServer.server()) :: {:error, any} | {:ok, 0..0xFFFF}
+  def get_low_threshold(server \\ __MODULE__) do
+    GenServer.call(server, :get_low_threshold)
+  end
+
+  @doc """
+  Set the low threshold.
+  """
+  @spec set_low_threshold(GenServer.server(), 0..0xFFFF) :: {:error, any} | :ok
+  def set_low_threshold(server \\ __MODULE__, value) do
+    GenServer.call(server, {:set_low_threshold, value})
+  end
+
+  @doc """
+  Get the high threshold.
+  """
+  @spec get_high_threshold(GenServer.server()) :: {:error, any} | {:ok, 0..0xFFFF}
+  def get_high_threshold(server \\ __MODULE__) do
+    GenServer.call(server, :get_high_threshold)
+  end
+
+  @doc """
+  Set the high threshold.
+  """
+  @spec set_high_threshold(GenServer.server(), 0..0xFFFF) :: {:error, any} | :ok
+  def set_high_threshold(server \\ __MODULE__, value) do
+    GenServer.call(server, {:set_high_threshold, value})
+  end
+
+  @doc """
+  Get the power saving mode.
+  """
+  @spec get_power_saving(GenServer.server()) ::
+          {:error, any} | {:ok, {mode :: 0..3, enabled :: boolean}}
+  def get_power_saving(server \\ __MODULE__) do
+    GenServer.call(server, :get_power_saving)
+  end
+
+  @doc """
+  Set the power saving mode.
+  """
+  @spec set_power_saving(GenServer.server(), mode :: 0..3, enabled :: boolean) ::
+          {:error, any} | :ok
+  def set_power_saving(server \\ __MODULE__, mode, enabled) do
+    GenServer.call(server, {:set_power_saving, mode, enabled})
+  end
+
+  @doc """
+  Get the interrupt status.
+  """
+  @spec get_interrupt_status(GenServer.server()) :: {:error, any} | {:ok, 0..0xFFFF}
+  def get_interrupt_status(server \\ __MODULE__) do
+    GenServer.call(server, :get_interrupt_status)
+  end
+
   ## GenServer callbacks
 
   @impl GenServer
@@ -165,6 +223,48 @@ defmodule VEML7700 do
     end
   end
 
+  def handle_call(:get_low_threshold, _from, state) do
+    result = Comm.read_low_threshold(state.transport)
+
+    {:reply, result, state}
+  end
+
+  def handle_call({:set_low_threshold, value}, _from, state) do
+    result = Comm.write_low_threshold(state.transport, value)
+
+    {:reply, result, state}
+  end
+
+  def handle_call(:get_high_threshold, _from, state) do
+    result = Comm.read_high_threshold(state.transport)
+
+    {:reply, result, state}
+  end
+
+  def handle_call({:set_high_threshold, value}, _from, state) do
+    result = Comm.write_high_threshold(state.transport, value)
+
+    {:reply, result, state}
+  end
+
+  def handle_call(:get_power_saving, _from, state) do
+    result = Comm.read_power_saving(state.transport)
+
+    {:reply, result, state}
+  end
+
+  def handle_call({:set_power_saving, mode, enable}, _from, state) do
+    result = Comm.write_power_saving(state.transport, mode, enable)
+
+    {:reply, result, state}
+  end
+
+  def handle_call(:get_interrupt_status, _from, state) do
+    result = Comm.read_interrupt_status(state.transport)
+
+    {:reply, result, state}
+  end
+
   @impl GenServer
   def handle_info(:perform_measurement, state) do
     new_state =

lib/veml7700/comm.ex

@@ -26,11 +26,16 @@ defmodule VEML7700.Comm do
           |> Register.Configuration.set(als_setting_names)
           |> Register.Configuration.to_integer()
 
-        :ok = write_register(transport, :als_config, new_value)
-        read_als_config(transport)
+        case write_register(transport, :als_config, new_value) do
+          :ok ->
+            read_als_config(transport)
 
-      error ->
-        error
+          {:error, error} ->
+            {:error, error}
+        end
+
+      {:error, error} ->
+        {:error, error}
     end
   end
 
@@ -51,6 +56,67 @@ defmodule VEML7700.Comm do
     end
   end
 
+  ## register 01
+
+  @spec write_high_threshold(Transport.t(), 0..0xFFFF) :: {:error, any} | :ok
+  def write_high_threshold(transport, value) do
+    write_register(transport, :als_threshold_high, value)
+  end
+
+  @spec read_high_threshold(Transport.t()) :: {:error, any} | {:ok, 0..0xFFFF}
+  def read_high_threshold(transport) do
+    read_register(transport, :als_threshold_high)
+  end
+
+  ## register 02
+
+  @spec write_low_threshold(Transport.t(), 0..0xFFFF) :: {:error, any} | :ok
+  def write_low_threshold(transport, value) do
+    write_register(transport, :als_threshold_low, value)
+  end
+
+  @spec read_low_threshold(Transport.t()) :: {:error, any} | {:ok, 0..0xFFFF}
+  def read_low_threshold(transport) do
+    read_register(transport, :als_threshold_low)
+  end
+
+  ## register 03
+
+  @spec write_power_saving(Transport.t(), 0..3, boolean) :: {:error, any} | :ok
+  def write_power_saving(transport, mode, enable) do
+    case read_register(transport, :als_power_saving) do
+      {:ok, current_value} ->
+        new_value =
+          current_value
+          |> Register.PowerSaving.from_integer()
+          |> Register.PowerSaving.set_enabled(enable)
+          |> Register.PowerSaving.set_mode(mode)
+          |> Register.PowerSaving.to_integer()
+
+        write_register(transport, :als_power_saving, new_value)
+
+      {:error, error} ->
+        {:error, error}
+    end
+  end
+
+  @spec read_power_saving(Transport.t()) ::
+          {:error, any} | {:ok, {mode :: 0..3, enabled :: boolean}}
+  def read_power_saving(transport) do
+    case read_register(transport, :als_power_saving) do
+      {:ok, current_value} ->
+        {mode, enabled} =
+          current_value
+          |> Register.PowerSaving.from_integer()
+          |> Register.PowerSaving.to_tuple()
+
+        {:ok, {mode, enabled}}
+
+      {:error, error} ->
+        {:error, error}
+    end
+  end
+
   ## register 04
 
   @spec read_als_output(Transport.t(), number) :: {:error, any} | {:ok, Measurement.t()}
@@ -64,6 +130,20 @@ defmodule VEML7700.Comm do
     end
   end
 
+  ## register 06
+
+  @spec read_interrupt_status(Transport.t()) ::
+          {:error, any} | {:ok, [:high_threshold_crossed | :low_threshold_crossed]}
+  def read_interrupt_status(transport) do
+    case read_register(transport, :interrupt_status) do
+      {:ok, new_value} ->
+        {:ok, Register.InterruptStatus.from_integer(new_value)}
+
+      {:error, error} ->
+        {:error, error}
+    end
+  end
+
   ## generic read and write
 
   # Write value with command name

lib/veml7700/register/configuration.ex

@@ -56,7 +56,7 @@ defmodule VEML7700.Register.Configuration do
   @doc """
   Sets configuration values with one or more setting name atoms
   """
-  @spec set(map, atom | [atom]) :: map
+  @spec set(struct, atom | [atom]) :: struct
   def set(t, setting_name) when is_atom(setting_name) do
     set(t, [setting_name])
   end
@@ -74,15 +74,15 @@ defmodule VEML7700.Register.Configuration do
   @doc """
   Gets configuration values with one or more setting name atoms
   """
-  @spec to_list(map) :: [atom]
+  @spec to_list(struct) :: [atom]
   def to_list(t), do: get(t, @register_names)
 
-  @spec get(map, atom) :: atom
+  @spec get(struct, atom) :: atom
   def get(t, register_name) when is_atom(register_name) do
     get(t, [register_name]) |> List.first()
   end
 
-  @spec get(map, [atom]) :: [atom]
+  @spec get(struct, [atom]) :: [atom]
   def get(t, register_names) when is_list(register_names) do
     Enum.reduce(@possible_settings, [], fn {setting_name, register_name, value}, acc ->
       if register_name in register_names and value == Map.fetch!(t, register_name) do
@@ -120,7 +120,7 @@ defmodule VEML7700.Register.Configuration do
     uint16 >>> position &&& mask
   end
 
-  @spec resolution(map) :: float
+  @spec resolution(struct) :: float
   def resolution(t) do
     als_gain = get(t, :als_gain)
     als_integration_time = get(t, :als_integration_time)

lib/veml7700/register/interrupt_status.ex

@@ -5,22 +5,33 @@ defmodule VEML7700.Register.InterruptStatus do
   import Bitwise
 
   # interrupt flags (bits 15:14)
-  @interrupt_high 0x4000
-  @interrupt_low 0x8000
+  @interrupt_high_crossed 0x4000
+  @interrupt_low_crossed 0x8000
+
+  @doc """
+  Converts 16-bit integer to list
+  """
+  @spec from_integer(0..0xFFFF) :: [:low_threshold_crossed | :high_threshold_crossed]
+  def from_integer(uint16) do
+    result = []
+    result = if(low_threshold?(uint16), do: [:low_threshold_crossed | result], else: result)
+    result = if(high_threshold?(uint16), do: [:high_threshold_crossed | result], else: result)
+    result
+  end
 
   @doc """
   Returns true when low threshold exceeded.
   """
   @spec low_threshold?(0..0xFFFF) :: boolean
   def low_threshold?(uint16) do
-    (uint16 &&& @interrupt_low) > 0
+    (uint16 &&& @interrupt_low_crossed) > 0
   end
 
   @doc """
   Returns true when high threshold exceeded.
   """
   @spec high_threshold?(0..0xFFFF) :: boolean
   def high_threshold?(uint16) do
-    (uint16 &&& @interrupt_high) > 0
+    (uint16 &&& @interrupt_high_crossed) > 0
   end
 end

lib/veml7700/register/power_saving.ex

@@ -0,0 +1,43 @@
+defmodule VEML7700.Register.PowerSaving do
+  @moduledoc false
+  # The configuration register (0x03)
+
+  defstruct mode: 0, enabled: 0, reserved1: 0, reserved2: 0
+
+  @spec new(keyword) :: struct
+  def new(kv \\ []), do: struct!(__MODULE__, kv)
+
+  @spec set_enabled(struct, boolean) :: struct
+  def set_enabled(t, true), do: struct!(t, enabled: 1)
+  def set_enabled(t, false), do: struct!(t, enabled: 0)
+
+  @spec set_mode(struct, 0..3) :: struct
+  def set_mode(t, mode) when is_integer(mode) and mode in 0..3 do
+    struct!(t, mode: mode)
+  end
+
+  @doc """
+  Converts struct to 16-bit integer
+  """
+  @spec to_integer(struct) :: 0..0xFFFF
+  def to_integer(t) do
+    <<value::little-16>> = <<t.reserved1::5, t.mode::2, t.enabled::1, t.reserved2::8>>
+    value
+  end
+
+  @doc """
+  Converts 16-bit integer to struct
+  """
+  @spec from_integer(0..0xFFFF) :: struct
+  def from_integer(value) do
+    <<reserved1::5, mode::2, enabled::1, reserved2::8>> = <<value::little-16>>
+    new(reserved1: reserved1, mode: mode, enabled: enabled, reserved2: reserved2)
+  end
+
+  @spec to_tuple(struct) :: {0..3, boolean}
+  def to_tuple(t), do: {t.mode, enabled?(t)}
+
+  @spec enabled?(struct) :: boolean
+  def enabled?(%{enabled: 1}), do: true
+  def enabled?(%{enabled: 0}), do: false
+end