inclusion of С++ libraries into the atomvm kernel

[npolevara]

Is there any way to include ready-made C++ libraries in the AtomVM kernel or in the AVM file build using Elixir/Erlang and get their functions similar to those already in atomvm kernel?
I encountered some problems while writing a program in Elixir for the TOF sensor, as most of the data received from the sensor is clearly raw, but already transformed using the library.
For example:
https://github.com/adafruit/Adafruit_VL6180X

[UncleGrumpy]

It is possible to use Arduino libraries in an esp-idf project, but it gets complicated and I don't think this has been tested with AtomVM. If you find an ESP-IDF based driver for the LV6180x you will have a much easier time. There is some minimal instruction on how to add a 3rd party components in the ESP32 section of the Build Instructions.

I don't have any of these sensors, so I can't test, but you might have better luck with this ESP-IDF based driver for VL6180x: https://github.com/CasCard/VL6180X-ESP32.

To get a better idea how to incorporate this into an AtomVM driver you can look at some of the other AtomVM organization repos, like atomvm_esp32cam for a nif example using the external esp-cam driver, and atomgl for a port example. You can look through the list of add on drivers on the atomvm.org Extensions page for more examples.

[petermm]

since it's i2c you can also go that route, there is actually code here https://github.com/OleMchls/nerves_vl6180x/blob/main/lib/vl6180x.ex - in theory you can run that code on the genserver.ex PR #1476 with an atomvm circuits_i2c backend https://github.com/petermm/circuits_i2c - but consider it experimental..

[npolevara]

Thanks! @petermm, @UncleGrumpy, I'll try the Nerves implementation and also check the ESP32 CAM documentation. It looks like everything is already written for Nerves, but I just don't have a raspberry_pi on hands, but have a lot of 32's chips.

[petermm]

yeah, ideally we should create an erlang driver for it, I vibed this for you https://ampcode.com/threads/T-019c4807-1afe-7225-b6aa-2f3efaa839b1 - but maybe better on the discord or telegram, and we can get you going..

[npolevara]

@petermm This is one of hundreds of sensors for which the company already has a C++ implementation. I haven't explored the sensor market before, but it seems more logical to me to write some kind of parser/connector/bridge from C++ to ERL/AVM. This story will repeat itself every time the AtomVM community needs to integrate new hardware with code. Unfortunately, my C++ skills are only sufficient for making an [#include <Adafruit_I2CDevice.h>] 😁. Correct me if I'm wrong.
I tried to do this with Gemini, but I was stuck with AVM compilation errors.

[petermm]

I get the frustration, but one really wants to avoid the c code/nifs unless absolutely necessary (eg. things need to go very fast or is computational intensive) - the entire reason for atomvm is to write nice erlang/elixir, and not worry about xyz in c code...

The adafruit driver is also just using i2c - so in this use case it's all about learning that - if you start with the https://github.com/atomvm/AtomVM/blob/main/examples/elixir/esp32/SHT31.ex example you should be able to change it into something that works for VL6180X using the linked elixir code..

(you can see the adafruit code does identical things as the elixir code)

I tried looking quickly for my sensor, but couldn't locate it - know I have one - somewhere:/

[npolevara]

Thank you @petermm ,I will try. I am very interested in this topic.

[petermm]

try and adapt this (from the vibe code), but do reach out on the forums, or discord/telegram..

defmodule VL6180X do
  @compile {:no_warn_undefined, [I2C]}

  import Bitwise

  @vl6180x_default_i2c_addr 0x29
  @vl6180x_reg_system_interrupt_config 0x014
  @vl6180x_reg_system_interrupt_clear 0x015
  @vl6180x_reg_system_fresh_out_of_reset 0x016
  @vl6180x_reg_sysrange_start 0x018
  @vl6180x_reg_sysals_start 0x038
  @vl6180x_reg_sysals_analogue_gain 0x03F
  @vl6180x_reg_sysals_integration_period_hi 0x040
  @vl6180x_reg_result_als_val 0x050
  @vl6180x_reg_result_range_val 0x062
  @vl6180x_reg_result_range_status 0x04D
  @vl6180x_reg_result_interrupt_status_gpio 0x04F

  @range_states %{
    0b0000 => :no_error,
    0b0001 => :vcsel_continuity_test,
    0b0010 => :vcsel_watchdog_test,
    0b0011 => :vcsel_watchdog,
    0b0100 => :pll1_lock,
    0b0101 => :pll2_lock,
    0b0110 => :early_convergence_estimate,
    0b0111 => :max_convergence,
    0b1000 => :no_target_ignore,
    0b1001 => :not_used,
    0b1010 => :not_used,
    0b1011 => :max_signal_to_noise_ratio,
    0b1100 => :raw_ranging_algo_underflow,
    0b1101 => :raw_ranging_algo_overflow,
    0b1110 => :ranging_algo_underflow,
    0b1111 => :ranging_algo_overflow
  }

  @als_gain_1 0x06
  @als_gain_1_25 0x05
  @als_gain_1_67 0x04
  @als_gain_2_5 0x03
  @als_gain_5 0x02
  @als_gain_10 0x01
  @als_gain_20 0x00
  @als_gain_40 0x07

  @poll_max_retries 1000
  @poll_delay_ms 1

  def start do
    i2c = I2C.open([{:scl, 15}, {:sda, 4}, {:clock_speed_hz, 400_000}])
    init(i2c, @vl6180x_default_i2c_addr)
    loop(i2c)
  end

  defp loop(i2c) do
    val = range(i2c, @vl6180x_default_i2c_addr)
    :erlang.display(val)
    Process.sleep(1000)
    loop(i2c)
  end

  defp init(bus, device) do
    for {reg, val} <- [
      {0x0207, 0x01}, {0x0208, 0x01}, {0x0096, 0x00}, {0x0097, 0xFD},
      {0x00E3, 0x00}, {0x00E4, 0x04}, {0x00E5, 0x02}, {0x00E6, 0x01},
      {0x00E7, 0x03}, {0x00F5, 0x02}, {0x00D9, 0x05}, {0x00DB, 0xCE},
      {0x00DC, 0x03}, {0x00DD, 0xF8}, {0x009F, 0x00}, {0x00A3, 0x3C},
      {0x00B7, 0x00}, {0x00BB, 0x3C}, {0x00B2, 0x09}, {0x00CA, 0x09},
      {0x0198, 0x01}, {0x01B0, 0x17}, {0x01AD, 0x00}, {0x00FF, 0x05},
      {0x0100, 0x05}, {0x0199, 0x05}, {0x01A6, 0x1B}, {0x01AC, 0x3E},
      {0x01A7, 0x1F}, {0x0030, 0x00},
      {0x0011, 0x10}, {0x010A, 0x30}, {0x003F, 0x46}, {0x0031, 0xFF},
      {0x0040, 0x63}, {0x002E, 0x01},
      {0x001B, 0x09}, {0x003E, 0x31}, {0x0014, 0x24}
    ] do
      write8(bus, device, reg, val)
    end

    write8(bus, device, @vl6180x_reg_system_fresh_out_of_reset, 0x00)
  end

  defp range(bus, device) do
    with {:ok, _} <- poll_until(bus, device, @vl6180x_reg_result_range_status,
                        fn v -> (v &&& 0x01) == 0x01 end),
         _ = write8(bus, device, @vl6180x_reg_sysrange_start, 0x01),
         {:ok, _} <- poll_until(bus, device, @vl6180x_reg_result_interrupt_status_gpio,
                        fn v -> (v &&& 0x07) == 0x04 end),
         {:ok, range_val} <- read8(bus, device, @vl6180x_reg_result_range_val) do
      write8(bus, device, @vl6180x_reg_system_interrupt_clear, 0x07)
      {:ok, range_val}
    end
  end

  defp range_status(bus, device) do
    case read8(bus, device, @vl6180x_reg_result_range_status) do
      {:ok, val} ->
        code = (val >>> 4) &&& 0x0F
        {:ok, @range_states[code]}

      error ->
        error
    end
  end

  defp lux(_bus, _device, gain) when gain > 0x07, do: {:error, :gain_too_high}

  defp lux(bus, device, gain) do
    {:ok, int_cfg} = read8(bus, device, @vl6180x_reg_system_interrupt_config)
    new_cfg = (int_cfg &&& ~~~0x38) ||| (0x04 <<< 3)
    write8(bus, device, @vl6180x_reg_system_interrupt_config, new_cfg)
    write16(bus, device, @vl6180x_reg_sysals_integration_period_hi, 100)
    write8(bus, device, @vl6180x_reg_sysals_analogue_gain, 0x40 ||| gain)
    write8(bus, device, @vl6180x_reg_sysals_start, 0x01)

    with {:ok, _} <- poll_until(bus, device, @vl6180x_reg_result_interrupt_status_gpio,
                        fn v -> ((v >>> 3) &&& 0x07) == 0x04 end),
         {:ok, raw_lux} <- read16(bus, device, @vl6180x_reg_result_als_val) do
      write8(bus, device, @vl6180x_reg_system_interrupt_clear, 0x07)
      {:ok, raw_lux * 0.32 / gain_factor(gain)}
    end
  end

  defp write8(bus, device, address, data) do
    I2C.write_bytes(bus, device, <<address >>> 8 &&& 0xFF, address &&& 0xFF, data>>)
  end

  defp write16(bus, device, address, val16) do
    I2C.write_bytes(bus, device, <<address >>> 8 &&& 0xFF, address &&& 0xFF,
                                   val16 >>> 8 &&& 0xFF, val16 &&& 0xFF>>)
  end

  defp read8(bus, device, address) do
    I2C.write_bytes(bus, device, <<address >>> 8 &&& 0xFF, address &&& 0xFF>>)

    case I2C.read_bytes(bus, device, 1) do
      {:ok, <<val>>} -> {:ok, val}
      {:error, _} = err -> err
    end
  end

  defp read16(bus, device, address) do
    I2C.write_bytes(bus, device, <<address >>> 8 &&& 0xFF, address &&& 0xFF>>)

    case I2C.read_bytes(bus, device, 2) do
      {:ok, <<val::16>>} -> {:ok, val}
      {:error, _} = err -> err
    end
  end

  defp poll_until(bus, device, address, pred) do
    poll_until(bus, device, address, pred, @poll_max_retries)
  end

  defp poll_until(_bus, _device, _address, _pred, 0), do: {:error, :timeout}

  defp poll_until(bus, device, address, pred, remaining) do
    case read8(bus, device, address) do
      {:ok, val} ->
        if pred.(val) do
          {:ok, val}
        else
          :timer.sleep(@poll_delay_ms)
          poll_until(bus, device, address, pred, remaining - 1)
        end

      {:error, _} = err ->
        err
    end
  end

  defp gain_factor(@als_gain_1), do: 1.0
  defp gain_factor(@als_gain_1_25), do: 1.25
  defp gain_factor(@als_gain_1_67), do: 1.67
  defp gain_factor(@als_gain_2_5), do: 2.5
  defp gain_factor(@als_gain_5), do: 5.0
  defp gain_factor(@als_gain_10), do: 10.0
  defp gain_factor(@als_gain_20), do: 20.0
  defp gain_factor(@als_gain_40), do: 40.0
end