add VEML7700 sim

Author: mnishiguchi

config/config.exs

@@ -10,6 +10,7 @@ config :circuits_sim,
     {CircuitsSim.Device.MCP23008, bus_name: "i2c-1", address: 0x21},
     {CircuitsSim.Device.AHT20, bus_name: "i2c-1", address: 0x38},
     {CircuitsSim.Device.SHT4X, bus_name: "i2c-1", address: 0x44},
+    {CircuitsSim.Device.VEML7700, bus_name: "i2c-1", address: 0x48},
     {CircuitsSim.Device.SGP30, bus_name: "i2c-1", address: 0x58},
     {CircuitsSim.Device.BMP280, bus_name: "i2c-1", address: 0x76},
     {CircuitsSim.Device.BMP280, bus_name: "i2c-1", address: 0x77},

lib/circuits_sim/device/veml7700.ex

@@ -0,0 +1,137 @@
+defmodule CircuitsSim.Device.VEML7700 do
+  @moduledoc """
+  Vishay VEML7700 ambient light sensors. This sim works for VEML6030 as well.
+
+  VEML7700 sensors are at address 0x10; VEML6030 typically at 0x48.
+  See the [datasheet](https://www.vishay.com/docs/84286/veml7700.pdf) for details.
+
+  Call `set_state/3` to change the state of the sensor.
+  """
+  alias CircuitsSim.I2C.I2CDevice
+  alias CircuitsSim.I2C.I2CServer
+
+  defstruct als_config: 0x0000,
+            als_threshold_high: 0x0000,
+            als_threshold_low: 0x0000,
+            als_power_saving: 0x0000,
+            als_output: 0x0000,
+            white_output: 0x0000,
+            interrupt_status: 0x0000
+
+  @type t() :: %__MODULE__{
+          als_config: 0..0xFFFF,
+          als_threshold_high: 0..0xFFFF,
+          als_threshold_low: 0..0xFFFF,
+          als_power_saving: 0..0xFFFF,
+          als_output: 0..0xFFFF,
+          white_output: 0..0xFFFF,
+          interrupt_status: 0..0xFFFF
+        }
+
+  @spec child_spec(keyword()) :: Supervisor.child_spec()
+  def child_spec(args) do
+    device = __MODULE__.new()
+    I2CServer.child_spec_helper(device, args)
+  end
+
+  @spec new(keyword) :: t()
+  def new(_options \\ []) do
+    %__MODULE__{}
+  end
+
+  @spec set_state(String.t(), Circuits.I2C.address(), keyword()) :: :ok
+  def set_state(bus_name, address, kv) do
+    I2CServer.send_message(bus_name, address, {:set_state, kv})
+  end
+
+  ## protocol implementation
+
+  defimpl I2CDevice do
+    @cmd_als_config 0
+    @cmd_als_threshold_high 1
+    @cmd_als_threshold_low 2
+    @cmd_als_power_saving 3
+    @cmd_als_output 4
+    @cmd_white_output 5
+    @cmd_interrupt_status 6
+
+    @impl I2CDevice
+    def read(state, count) do
+      {:binary.copy(<<0>>, count), state}
+    end
+
+    @impl I2CDevice
+    def write(state, <<@cmd_als_config, value::little-16>>) do
+      %{state | als_config: value}
+    end
+
+    def write(state, <<@cmd_als_threshold_high, data::little-16>>) do
+      %{state | als_threshold_high: data}
+    end
+
+    def write(state, <<@cmd_als_threshold_low, data::little-16>>) do
+      %{state | als_threshold_low: data}
+    end
+
+    def write(state, <<@cmd_als_power_saving, data::little-16>>) do
+      %{state | als_power_saving: data}
+    end
+
+    def write(state, _), do: state
+
+    @impl I2CDevice
+    def write_read(state, <<@cmd_als_config>>, read_count) do
+      result = <<state.als_config::little-16>> |> trim_pad(read_count)
+      {result, state}
+    end
+
+    def write_read(state, <<@cmd_als_threshold_high>>, read_count) do
+      result = <<state.als_threshold_high>> |> trim_pad(read_count)
+      {result, state}
+    end
+
+    def write_read(state, <<@cmd_als_threshold_low>>, read_count) do
+      result = <<state.als_threshold_low::little-16>> |> trim_pad(read_count)
+      {result, state}
+    end
+
+    def write_read(state, <<@cmd_als_power_saving>>, read_count) do
+      result = <<state.als_power_saving::little-16>> |> trim_pad(read_count)
+      {result, state}
+    end
+
+    def write_read(state, <<@cmd_als_output>>, read_count) do
+      result = <<state.als_output::little-16>> |> trim_pad(read_count)
+      {result, state}
+    end
+
+    def write_read(state, <<@cmd_white_output>>, read_count) do
+      result = <<state.white_output::little-16>> |> trim_pad(read_count)
+      {result, state}
+    end
+
+    def write_read(state, <<@cmd_interrupt_status>>, read_count) do
+      result = <<state.interrupt_status::little-16>> |> trim_pad(read_count)
+      {result, state}
+    end
+
+    def write_read(state, _to_write, read_count) do
+      {:binary.copy(<<0>>, read_count), state}
+    end
+
+    defp trim_pad(x, count) when byte_size(x) >= count, do: :binary.part(x, 0, count)
+    defp trim_pad(x, count), do: x <> :binary.copy(<<0>>, count - byte_size(x))
+
+    @impl I2CDevice
+    def render(state) do
+      light_lux = Float.round(state.light_lux * 1.0, 3)
+      "Light: #{light_lux} lux"
+    end
+
+    @impl I2CDevice
+    @spec handle_message(struct, {:set_state, keyword}) :: {:ok, struct}
+    def handle_message(state, {:set_state, kv}) do
+      {:ok, struct!(state, kv)}
+    end
+  end
+end

test/circuits_sim/device/veml7700_test.exs

@@ -0,0 +1,35 @@
+defmodule CircuitsSim.Device.VEML7700Test do
+  use ExUnit.Case
+
+  alias CircuitsSim.I2C.I2CServer
+  alias CircuitsSim.Device.VEML7700, as: VEML7700Sim
+
+  @i2c_address 0x48
+  @cmd_config 0x00
+  @cmd_light 0x04
+
+  setup context do
+    i2c_bus = to_string(context.test)
+    start_supervised!({VEML7700Sim, bus_name: i2c_bus, address: @i2c_address})
+
+    [i2c_bus: i2c_bus]
+  end
+
+  test "reads and writes registers", %{i2c_bus: i2c_bus} do
+    VEML7700Sim.set_state(i2c_bus, @i2c_address, als_config: 0, als_output: 440)
+
+    # read ambient light sensor settings
+    assert {:ok, <<0, 0>>} = I2CServer.write_read(i2c_bus, @i2c_address, <<@cmd_config>>, 2)
+
+    # write ambient light sensor settings
+    config = 0b0001100000000000
+    assert :ok = I2CServer.write(i2c_bus, @i2c_address, <<@cmd_config, config::little-16>>)
+
+    # read ambient light sensor settings
+    assert {:ok, <<0, 24>>} = I2CServer.write_read(i2c_bus, @i2c_address, <<@cmd_config>>, 2)
+
+    # read ambient light sensor output data
+    assert {:ok, <<440::little-16>>} =
+             I2CServer.write_read(i2c_bus, @i2c_address, <<@cmd_light>>, 2)
+  end
+end