Chapter 3 Aggregating Sensor Data (29)
    We now need to wrap each GenServer so that they will power on and gather data when the device is powered on. Each sensor needs to be its own GenServer and will have a Supervisor to deal with the start and aggrigration of the data.

    Wrapping Sensors in GenServers
        We will start a new mix project withing the Poncho
            $ mix new veml6030
            $ cd veml6030

        Once that is done we need to update the deps to have the i2c interface and firmware

            {:circuits_i2c, "~> 0.3.8"}

        This project will continue to get more and more complex so keeping the aggrigration in it's own project will help to keep everything in the right spot.

        Build a Core from the Spec Sheet
            Acronim: CRC mean to Construct |> Reduce |> Convert. This is the way we will take the raw data and make it useable for out site.

            Start off by creating a file at the location lib/veml6030/config.ex (this will go inside the veml6030 project and you will create an other veml6030 folder)
                defmodule Veml6030.Config do
                    defstruct [
                        gain: :gain_1_4th,
                        int_time: :it_100ms,
                        shutdown: false,
                        interrupt: false
                    ]

                    def new, do: struct(__MODULE__)
                    def new(opts) when is_list(opts) do
                        struct(__MODULE__, opts)
                    end
                end

            We now have the constructor out of the way now we need to deal with the converter. This will be the format of the integers that we will use.
                def to_integer(config) do
                    reserved = 0
                    persistence_protect = 0
                    <<integer::16>> = <<
                        reserved::3,
                        gain(config.gain)::2,
                        reserved::1,
                        int_time(config.int_time)::4,
                        persistence_protect::2,
                        reserved::2,
                        interrupt(config.interrupt)::1,
                        shutdown(config.shutdown)::1
                    >>
                    integer
                end

            This is what we will use to deal with all the settings of the sensors, in order to pattern match different settings. These will take a setting we want and transform them into bits based off the spec sheet. 
                defp gain(:gain_1x), do: 0b0
                defp gain(:gain_2x), do: 0b01
                defp gain(:gain_1_8th), do: 0b10
                defp gain(:gain_1_4th), do: 0b11
                defp gain(:gain_default), do: 0b11
                defp int_time(:it_25_ms), do: 0b1100
                defp int_time(:it_50_ms), do: 0b1000
                defp int_time(:it_100_ms), do: 0b0000
                defp int_time(:it_200_ms), do: 0b0001
                defp int_time(:it_400_ms), do: 0b0010
                defp int_time(:it_800_ms), do: 0b0011
                defp int_time(:it_default), do: 0b0000
                defp shutdown(true), do: 1
                defp shutdown(_), do: 0
                defp interrupt(true), do: 1
                defp interrupt(_), do: 0

            We will now need to worry about the conversion factor for the values that we get from the sensor.
                @to_lumens_factor %{
                    {:it_800_ms, :gain_2x} => 0.0036,
                    {:it_800_ms, :gain_1x} => 0.0072,
                    {:it_800_ms, :gain_1_4th} => 0.0288,
                    {:it_800_ms, :gain_1_8th} => 0.0576,
                    {:it_400_ms, :gain_2x} => 0.0072,
                    {:it_400_ms, :gain_1x} => 0.0144,
                    {:it_400_ms, :gain_1_4th} => 0.0576,
                    {:it_400_ms, :gain_1_8th} => 0.1152,
                    {:it_200_ms, :gain_2x} => 0.0144,
                    {:it_200_ms, :gain_1x} => 0.0288,
                    {:it_200_ms, :gain_1_4th} => 0.1152,
                    {:it_200_ms, :gain_1_8th} => 0.2304,
                    {:it_100_ms, :gain_2x} => 0.0288,
                    {:it_100_ms, :gain_1x} => 0.0576,
                    {:it_100_ms, :gain_1_4th} => 0.2304,
                    {:it_100_ms, :gain_1_8th} => 0.4608,
                    {:it_50_ms, :gain_2x} => 0.0576,
                    {:it_50_ms, :gain_1x} => 0.1152,
                    {:it_50_ms, :gain_1_4th} => 0.4608,
                    {:it_50_ms, :gain_1_8th} => 0.9216,
                    {:it_25_ms, :gain_2x} => 0.1152,
                    {:it_25_ms, :gain_1x} => 0.2304,
                    {:it_25_ms, :gain_1_4th} => 0.9216,
                    {:it_25_ms, :gain_1_8th} => 1.8432
                }

                def to_lumens(config, measurement) do
                    @to_lumens_factor[{config.int_time, config.gain}] * measurement
                end
                            
            Let's take it on a test drive
                iex(1) ▶ VEML6030.Config.new()
                %VEML6030.Config{
                gain: :gain_1_4th,
                int_time: :it_100_ms,
                interrupt: false,
                shutdown: false
                }
                iex(2) ▶ VEML6030.Config.new() |>
                ...(2) ▶ VEML6030.Config.to_integer() |>
                ...(2) ▶ inspect(base: :hex)
                "0x1800"
                iex(3) ▶ [gain: :gain_1x] |>
                ...(3) ▶ VEML6030.Config.new() |>
                ...(3) ▶ VEML6030.Config.to_integer() |>
                ...(3) ▶ inspect(base: :hex)
                "0x0"