This is the work I did to create the sensor package for the LTR390 UV sensor.

Include Dependencies for Sensors
            Now we need to include the right dependencies for the other sensors that we have on the hat. In the book they talk about using some predefined libs :bmp280 and :sgp30 which will take some the needed functions in order to use the sensors. I might need to define my own but Ill see about using some libs if I can find them.

            In order to make this work with the current settings I will write my own conn.ex, config.ex and sensor_name.ex files. Keep in mind you will need to add in the dependencies to the sensor hub after you make them in order to add them to the Supervisor tree.

            conn.ex
                This is where I took a lot of the existing code and added in some of the new addresses and made sure that I set all the correct values in the config.

                @command_bit 0x80
                @enable_register 0x00
                @gain_register 0x05
                @control_register 0x04
                @als_data_register [0x0D, 0x0E, 0x0F]
                @uvs_data_register [0x10, 0x11, 0x12]

                def write_config(config, i2c, sensor) do
                    enable_byte = Config.to_enable_byte(config)
                    control_byte = Config.to_control_byte(config)
                    gain_byte = Config.to_gain_byte(config)

                    # Write ENABLE register (1 byte) with command bit set
                    I2C.write(i2c, sensor, <<@command_bit ||| @enable_register, enable_byte>>)

                    # Write CONTROL register (1 byte) with command bit set
                    I2C.write(i2c, sensor, <<@command_bit ||| @control_register, control_byte>>)

                    # Write the GAIN register
                    I2C.write(i2c, sensor, <<@command_bit ||| @gain_register, gain_byte>>)
                end

                The sensor for UV has two types of sensors so I needed to be sure that I set both of them and could read from either.

                def read(i2c, sensor, %Config{uvs_als: :uvs} = config) do
                    <<low, mid, high>> =
                    I2C.write_read!(i2c, sensor, <<@command_bit ||| hd(@uvs_data_register)>>, 3)

                    raw = low ||| mid <<< 8 ||| high <<< 16
                    Config.uvs_to_uvi(config, raw)
                end

                def read(i2c, sensor, %Config{uvs_als: :als} = config) do
                    <<low, mid, high>> =
                    I2C.write_read!(i2c, sensor, <<@command_bit ||| hd(@als_data_register)>>, 3)

                    # Convert using ALS formula when you fix it
                    raw = low ||| mid <<< 8 ||| high <<< 16
                    Config.als_to_lux(config, raw, 0)
                end

            config.ex
                This is where I had to set some new values for the struct and because there are some hardcoded formula that I would use for the conversion I set those values here too.

                @uv_sensitivity_base 2300.0

                defstruct resolution: :res_default,
                            measure_rate: :measure_rate_100_ms,
                            uvs_als: :uvs,
                            gain: :low,
                            reset: false

                def new, do: struct(__MODULE__)

                def new(opts) do
                    struct(__MODULE__, opts)
                end

                defp resolution(:res_20bit), do: 0b000
                defp resolution(:res_19bit), do: 0b001
                defp resolution(:res_18bit), do: 0b010
                defp resolution(:res_17bit), do: 0b011
                defp resolution(:res_16bit), do: 0b100
                defp resolution(:res_15bit), do: 0b101
                defp resolution(:res_default), do: 0b010

                defp measure_rate(:measure_rate_25_ms), do: 0b000
                defp measure_rate(:measure_rate_50_ms), do: 0b001
                defp measure_rate(:measure_rate_100_ms), do: 0b010
                defp measure_rate(:measure_rate_200_ms), do: 0b011
                defp measure_rate(:measure_rate_500_ms), do: 0b100
                defp measure_rate(:measure_rate_1000_ms), do: 0b101
                defp measure_rate(:measure_rate_2000_ms), do: 0b110
                defp measure_rate(:measure_rate_default), do: 0b010

                defp gain(:min), do: 0b000
                defp gain(:low), do: 0b001
                defp gain(:med), do: 0b010
                defp gain(:high), do: 0b011
                defp gain(:max), do: 0b100
                defp gain(:gain_default), do: 0b001
                defp uvs_als(:uvs), do: 1
                defp uvs_als(:als), do: 0
                defp reset(true), do: 1
                defp reset(_), do: 0

                def to_control_byte(%__MODULE__{resolution: resolution, measure_rate: measure_rate}) do
                    resolution(resolution) <<< 4 ||| measure_rate(measure_rate)
                end

                def to_gain_byte(%__MODULE__{gain: gain}) do
                    gain(gain)
                end

                def to_enable_byte(%__MODULE__{uvs_als: uvs_als, reset: reset}) do
                    reset_bit_rate = reset(reset) <<< 4
                    uvs_als_bit_rate = uvs_als(uvs_als) <<< 3
                    enable_bit_rate = 1 <<< 1
                    reserve_bit_rate = 1 <<< 0

                    reset_bit_rate ||| uvs_als_bit_rate ||| enable_bit_rate |||
                    reserve_bit_rate
                end

                defp integration_time_ms(:measure_rate_25_ms), do: 25
                defp integration_time_ms(:measure_rate_50_ms), do: 50
                defp integration_time_ms(:measure_rate_100_ms), do: 100
                defp integration_time_ms(:measure_rate_200_ms), do: 200
                defp integration_time_ms(:measure_rate_500_ms), do: 500
                defp integration_time_ms(:measure_rate_1000_ms), do: 1000
                defp integration_time_ms(:measure_rate_2000_ms), do: 2000
                defp integration_time_ms(:measure_rate_default), do: 100

                def gain_multiplier(:min), do: 1
                def gain_multiplier(:low), do: 3
                def gain_multiplier(:med), do: 6
                def gain_multiplier(:high), do: 9
                def gain_multiplier(:max), do: 18

                def als_to_lux(%{gain: gain, measure_rate: measure_rate}, raw_counts, wfac \\ 1.0) do
                    int_ms = integration_time_ms(measure_rate)
                    raw_counts * 0.6 / (gain_multiplier(gain) * (int_ms / 100)) * wfac
                end

                def uvs_to_uvi(%{gain: gain, measure_rate: measure_rate}, raw_counts, wfac \\ 1.0) do
                    int_ms = integration_time_ms(measure_rate)
                    sensitivity = @uv_sensitivity_base * (gain_multiplier(gain) / 18) * (int_ms / 400)
                    raw_counts / sensitivity * wfac
                end

            LTR390_UV.ex
                Again very similar to the other sensor but we have to get 2 types of measurements so I had to implement those.

                @impl true
                def init(%{address: address, i2c_bus_name: bus_name} = args) do
                    i2c = Comm.open(bus_name)

                    config =
                    args
                    |> Map.take([:gain, :resolution, :uvs_als, :measure_rate, :reset])
                    |> Config.new()

                    Comm.write_config(config, i2c, address)

                    # Calculate measure rate in milliseconds (example mapping)
                    measure_rate =
                    case config.measure_rate do
                        :it_25_ms -> 25
                        :it_50_ms -> 50
                        :it_100_ms -> 100
                        :it_200_ms -> 200
                        :it_500_ms -> 500
                        :it_1000_ms -> 1000
                        :it_2000_ms -> 2000
                        _ -> 100
                    end

                    # Schedule first measure after measure_rate
                    Process.send_after(self(), :measure, measure_rate)

                    state = %{
                    i2c: i2c,
                    address: address,
                    config: config,
                    resolution: config.resolution,
                    measure_rate: measure_rate,
                    reset: config.reset,
                    gain: config.gain,
                    uvs_als: config.uvs_als,
                    last_uvs: :no_reading,
                    last_als: :no_reading
                    }

                    {:ok, state}
                end

                def init(args) do
                    {bus_name, address} = Comm.discover()
                    transport = "bus: #{bus_name}, address: #{address}"
                    Logger.info("Starting LTR390_UV. Please specify an address and a bus.")
                    Logger.info("Starting on " <> transport)

                    defaults =
                    args
                    |> Map.put(:address, address)
                    |> Map.put(:i2c_bus_name, bus_name)

                    init(defaults)
                end

                @doc """
                This are set to take the last reading from the sensor, then update the reading with the new reading and
                appending it to the state. Once that is done it will switch to the other type of sensor and schedule an other
                reading.
                """
                @impl true
                def handle_info(
                        :measure,
                        %{
                        i2c: i2c,
                        address: address,
                        config: config,
                        measure_rate: measure_rate,
                        uvs_als: current_mode
                        } = state
                    ) do
                    last_reading = Comm.read(i2c, address, config)

                    # Toggle mode and update config accordingly
                    {new_state, new_config} =
                    case current_mode do
                        :uvs ->
                        {%{state | last_uvs: last_reading, uvs_als: :als}, %{config | uvs_als: :als}}

                        :als ->
                        {%{state | last_als: last_reading, uvs_als: :uvs}, %{config | uvs_als: :uvs}}
                    end

                    # Write new config to switch sensor mode
                    Comm.write_config(new_config, i2c, address)

                    # Schedule next measurement after full measure_rate
                    Process.send_after(self(), :measure, measure_rate)

                    {:noreply, %{new_state | config: new_config}}
                end

                @doc """
                This is called when the GenServer is asked to get the last measurements for both uvs and als.
                """
                @impl true
                def handle_call(:get_measurement, _from, state) do
                    last_uvs = state.last_uvs
                    last_als = state.last_als
                    {:reply, {last_uvs, last_als}, state}
                end

                @impl true
                def terminate(_reason, %{i2c: i2c}) do
                    Circuits.I2C.close(i2c)
                    :ok
                end

            I plan on finishing all the other sensors at some point and will be adding in the libs to gihub after I finish each one.