BME280 (Humidity, Temperature, Air Pressure)
        Don't forget to add the {:circuits_i2c, "~> 1.1"} to the BME280 project and then add the :Bme280 to the sensor_but mix.exs

        config.ex
            defstruct mode: :normal,
                        osrs_t: :osrs_2x,
                        osrs_p: :osrs_16x,
                        osrs_h: :osrs_1x,
                        standby_time: :standby_0_5_ms,
                        filter: :filter_16,
                        spi3w_en: false

            def new, do: struct(__MODULE__)

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

            @doc """
            This will be responsible for the: Humidity oversampling.
            """
            def to_ctrl_hum_byte(%__MODULE__{osrs_h: osrs_h}) do
                osrs_h_bit = osrs_h_to_bit(osrs_h)
                0b00000000 ||| osrs_h_bit
            end

            @doc """
            This will be responsible for the: Pressure oversampling, Temperature oversampling and
            the Mode that the sensor is currently operating in.
            """
            def to_ctrl_meas_byte(%__MODULE__{osrs_t: osrs_t, osrs_p: osrs_p, mode: mode}) do
                osrs_t_bit = osrs_t_to_bit(osrs_t)
                osrs_p_bit = osrs_p_to_bit(osrs_p)
                mode_bit = mode_to_bit(mode)
                0b00000000 ||| osrs_t_bit <<< 5 ||| osrs_p_bit <<< 2 ||| mode_bit
            end

            @doc """
            This will be responsable for the: filtering, standby time and SPI 3-wire mode.
            """
            def to_config_byte(%__MODULE__{standby_time: standby_time, filter: filter, spi3w_en: spi3w_en}) do
                standby_time_bit = standby_time_to_bit(standby_time)
                filter_bit = filter_to_bit(filter)
                spi3w_en_bit = spi3w_en_bit(spi3w_en)

                0b00000000 ||| standby_time_bit <<< 5 ||| filter_bit <<< 2 ||| spi3w_en_bit
            end

            @spec integration_ms(%__MODULE__{}) :: non_neg_integer()
            def integration_ms(%__MODULE__{
                    mode: mode,
                    osrs_t: osrs_t,
                    osrs_p: osrs_p,
                    osrs_h: osrs_h,
                    standby_time: standby_time
                }) do
                # Convert oversampling atoms to approximate times in ms
                t = osrs_to_ms(osrs_t)
                p = osrs_to_ms(osrs_p)
                h = osrs_to_ms(osrs_h)

                # Base measurement overhead (ms)
                base = 1

                # Standby time (ms)
                standby_ms =
                case mode do
                    :normal -> standby_time_to_ms(standby_time)
                    _ -> 0
                end

                # Total integration time
                total = t + p + h + base + standby_ms

                # Always round up to the nearest integer
                max(1, round(total))
            end

        comm.ex
            @ctrl_hum 0xF2
            @ctrl_meas 0xF4
            @config_register 0xF5
            @data_register 0xF7

            def write_config(config, i2c, sensor) do
                ctrl_hum_byte = Config.to_ctrl_hum_byte(config)
                ctrl_meas_byte = Config.to_ctrl_meas_byte(config)
                config_byte = Config.to_config_byte(config)

                # Write CTRL_HUM register (1 byte)
                I2C.write(i2c, sensor, <<@ctrl_hum, ctrl_hum_byte>>)

                :timer.sleep(100)  # Small delay to ensure the sensor is ready

                # Write CTRL_MEAS register (1 byte)
                I2C.write(i2c, sensor, <<@ctrl_meas, ctrl_meas_byte>>)

                # Write CONFIG register (1 byte)
                I2C.write(i2c, sensor, <<@config_register, config_byte>>)
            end

            def read(i2c, sensor) do
                <<press_msb, press_lsb, press_xlsb, temp_msb, temp_lsb, temp_xlsb, hum_msb, hum_lsb>> =
                I2C.write_read!(i2c, sensor, <<@data_register>>, 8)

                combined_pressure = (press_msb <<< 12) ||| (press_lsb <<< 4) ||| (press_xlsb >>> 4)
                combined_temperature = (temp_msb <<< 12) ||| (temp_lsb <<< 4) ||| (temp_xlsb >>> 4)
                combined_humidity = (hum_msb <<< 8) ||| hum_lsb

                {combined_pressure, combined_temperature, combined_humidity}
            end

        bme280.ex

        calibration.ex
            alias Bme280.Calibration

            @spec convert({integer, integer, integer}, Calibration.t()) ::
                    %{temperature_c: float, pressure_pa: float, humidity_rh: float}
            def convert({adc_P, adc_T, adc_H}, calib) do
                {temp_c, t_fine} = compensate_temp(adc_T, calib)
                press_pa = compensate_press(adc_P, t_fine, calib)
                hum_pct = compensate_hum(adc_H, t_fine, calib)

                %{
                temperature_c: temp_c,
                pressure_pa: press_pa,
                humidity_rh: hum_pct
                }
            end

            def compensate_temp(adc_T, calib) do
                var1 =
                (adc_T / 16384.0 - calib.dig_T1 / 1024.0) * calib.dig_T2

                var2 =
                (adc_T / 131_072.0 - calib.dig_T1 / 8192.0) *
                    (adc_T / 131_072.0 - calib.dig_T1 / 8192.0) *
                    calib.dig_T3

                t_fine = var1 + var2
                temperature = t_fine / 5120.0
                {temperature, t_fine}
            end

            def compensate_press(adc_P, t_fine, calib) do
                var1 = t_fine / 2.0 - 64000.0
                var2 = var1 * var1 * calib.dig_P6 / 32768.0
                var2 = var2 + var1 * calib.dig_P5 * 2.0
                var2 = var2 / 4.0 + calib.dig_P4 * 65536.0
                var3 = calib.dig_P3 * var1 * var1 / 524_288.0
                var1 = (var3 + calib.dig_P2 * var1) / 524_288.0
                var1 = (1.0 + var1 / 32768.0) * calib.dig_P1

                if var1 == 0 do
                0
                else
                p = 1_048_576.0 - adc_P
                p = (p - var2 / 4096.0) * 6250.0 / var1
                var1 = calib.dig_P9 * p * p / 2_147_483_648.0
                var2 = p * calib.dig_P8 / 32768.0
                p + (var1 + var2 + calib.dig_P7) / 16.0
                end
            end

            def compensate_hum(adc_H, t_fine, calib) do
                h = t_fine - 76800.0

                h =
                (adc_H - (calib.dig_H4 * 64.0 + calib.dig_H5 / 16384.0 * h)) *
                    (calib.dig_H2 / 65536.0) *
                    (1.0 +
                    calib.dig_H6 / 67_108_864.0 * h *
                        (1.0 + calib.dig_H3 / 67_108_864.0 * h))

                cond do
                h > 100.0 -> 100.0
                h < 0.0 -> 0.0
                true -> h
                end
            end
        converter.ex
            defstruct [
                :dig_T1,
                :dig_T2,
                :dig_T3,
                :dig_P1,
                :dig_P2,
                :dig_P3,
                :dig_P4,
                :dig_P5,
                :dig_P6,
                :dig_P7,
                :dig_P8,
                :dig_P9,
                :dig_H1,
                :dig_H2,
                :dig_H3,
                :dig_H4,
                :dig_H5,
                :dig_H6
            ]

            @temp_press_start 0x88
            # 0x88..0xA1
            @temp_press_len 26
            @hum_start 0xE1
            # 0xE1..0xE7
            @hum_len 7

            def read_all(i2c, sensor) do
                # Read temperature & pressure calibration (0x88..0xA0 = 25 bytes)
                t_p_data =
                I2C.write_read!(i2c, sensor, <<@temp_press_start>>, @temp_press_len)
                |> ensure_binary()

                <<
                dig_T1_lsb,
                dig_T1_msb,
                dig_T2_lsb,
                dig_T2_msb,
                dig_T3_lsb,
                dig_T3_msb,
                dig_P1_lsb,
                dig_P1_msb,
                dig_P2_lsb,
                dig_P2_msb,
                dig_P3_lsb,
                dig_P3_msb,
                dig_P4_lsb,
                dig_P4_msb,
                dig_P5_lsb,
                dig_P5_msb,
                dig_P6_lsb,
                dig_P6_msb,
                dig_P7_lsb,
                dig_P7_msb,
                dig_P8_lsb,
                dig_P8_msb,
                dig_P9_lsb,
                dig_P9_msb,
                _reserved,
                dig_H1
                >> = t_p_data

                # Read humidity calibration (0xE1..0xE7 = 7 bytes)
                h_data =
                I2C.write_read!(i2c, sensor, <<@hum_start>>, @hum_len)
                |> ensure_binary()

                <<dig_H2_lsb, dig_H2_msb, dig_H3, h4_lsb, h4_msb_bits, h5_msb_bits, dig_H6>> = h_data

                %__MODULE__{
                dig_T1: dig_T1_msb <<< 8 ||| dig_T1_lsb,
                dig_T2: signed(dig_T2_msb <<< 8 ||| dig_T2_lsb),
                dig_T3: signed(dig_T3_msb <<< 8 ||| dig_T3_lsb),
                dig_P1: dig_P1_msb <<< 8 ||| dig_P1_lsb,
                dig_P2: signed(dig_P2_msb <<< 8 ||| dig_P2_lsb),
                dig_P3: signed(dig_P3_msb <<< 8 ||| dig_P3_lsb),
                dig_P4: signed(dig_P4_msb <<< 8 ||| dig_P4_lsb),
                dig_P5: signed(dig_P5_msb <<< 8 ||| dig_P5_lsb),
                dig_P6: signed(dig_P6_msb <<< 8 ||| dig_P6_lsb),
                dig_P7: signed(dig_P7_msb <<< 8 ||| dig_P7_lsb),
                dig_P8: signed(dig_P8_msb <<< 8 ||| dig_P8_lsb),
                dig_P9: signed(dig_P9_msb <<< 8 ||| dig_P9_lsb),
                dig_H1: dig_H1,
                dig_H2: signed(dig_H2_msb <<< 8 ||| dig_H2_lsb),
                dig_H3: dig_H3,
                dig_H4: signed(h4_lsb <<< 4 ||| (h4_msb_bits &&& 0x0F)),
                dig_H5: signed((h5_msb_bits &&& 0xF0) >>> 4 ||| h5_msb_bits <<< 4),
                dig_H6: signed(dig_H6)
                }
            end

            defp signed(value) when value > 0x7FFF, do: value - 0x10000
            defp signed(value), do: value

            # Convert list to binary if needed
            defp ensure_binary(data) when is_list(data), do: :erlang.list_to_binary(data)
            defp ensure_binary(data) when is_binary(data), do: data
            
        export MIX_TARGET=rpi3a
        ./upload.sh 192.168.x.x
        ssh 192.168.x.x


        If you want to just test the comm.ex and config.ex
        alias Bme280.Comm
        alias Bme280.Config

        bus_name = "i2c-1"          # or whatever your I²C bus is
        {_bus, sensor} = Comm.discover()     # returns 0x76 (the sensor address)

        i2c = Comm.open(bus_name)    # open the bus
        config = Config.new()        # default config

        Comm.write_config(config, i2c, sensor)  # write config
        Comm.read(i2c, sensor)                  # read raw values

        if you want to test the GenServer on Bme280.ex
        Bme280.start_link()
        Bme280.get_measurement()