LM4

[PLO-NIKO]

Are there any chance we can get the LM4 integrated as well, as the reading on LM4 with this is wrong, as the data structure is not the same?

[OlliV]

Very little, as I haven't been able to buy one. This code would need to be adapted for LM4
https://github.com/OlliV/open-light-master/blob/main/lib/ble/lm3.ts#L24-L106

The main reason it doesn't work is that LM3 and LM4 measure different wavelengths.

[PLO-NIKO]

I have the new matrics for the LM4, if it has any interest?

[OlliV]

I have the new matrics for the LM4, if it has any interest?

Sure!

[HonzaaD]

I have the new matrics for the LM4, if it has any interest?

I'm also joining in, I have a new LM4 and would like to get the most out of it.

[makerwolf]

I have the new matrics for the LM4, if it has any interest?

@PLO-NIKO could you share the metrics for the LM4?

[PLO-NIKO]

` ///

/// Performs colorimetric calculations (Lux, CCT, chromaticity, and Duv) from AS7341 sensor data.
/// Version 2 with optional CCT smoothing over the last N readings (within a time window).
///

public static class As7341ColorCalculatorV2
{
// --- Configuration Constants ------------------------------------------------
public const double CCT_LUX_MIN = 5.0; // Minimum lux to report CCT
public const double CCT_MIN = 0.0; // Lower bound for CCT
public const double CCT_MAX = 15000.0; // Upper bound for CCT
public const int FIXED_CCT_OFFSET = -76; // Offset applied after gain

    public const double CalPowerReference = 3305.0;
    public const double CalPowerCorrectionFactor = -0.947;

    /// <summary>
    /// When true, applies the quadratic correction (CorrectCCT) regardless of other settings.
    /// </summary>
    public const bool USE_CUSTOM_CCT_CORRECTION = true;

    /// <summary>
    /// When true, clamps the computed CCT to [CCT_MIN, CCT_MAX] and enforces CCT_LUX_MIN.
    /// </summary>
    public static bool UseCctBounds { get; set; } = true;

    /// <summary>
    /// If true, also clamps CCT to a stable maximum to avoid instability above CctStableMax.
    /// </summary>
    public static bool UseStableCctLimit { get; set; } = false;

    /// <summary>
    /// Stable CCT upper limit (Kelvin). Readings above this will be clamped when UseStableCctLimit is true.
    /// </summary>
    public static double CctStableMax { get; set; } = 10000.0;

    // --- Smoothing Settings ------------------------------------------------------
    /// <summary>
    /// When true, averages CCT over the last CctSmoothingCount readings within the smoothing window.
    /// </summary>
    public static bool UseCctSmoothing { get; set; } = true;

    /// <summary>
    /// Number of recent CCT readings to include in smoothing.
    /// </summary>
    public const int CctSmoothingCount = 4;

    /// <summary>
    /// Maximum age of readings to include in smoothing (seconds).
    /// </summary>
    public static readonly TimeSpan CctSmoothingMaxAge = TimeSpan.FromSeconds(10);

    // Thread-safe history of recent CCT readings
    private static readonly object _historyLock = new object();
    private static readonly LinkedList<(DateTime time, double cct)> _cctHistory = new LinkedList<(DateTime, double)>();

    // --- Gain Settings -----------------------------------------------------------
    /// <summary>Scale factor to convert raw Y to lux.</summary>
    public static double LuxGain { get; set; } = 0.094;
    /// <summary>Scale factor to adjust raw CCT calculation.</summary>
    public static double CctGain { get; set; } = 0.703;

    // --- Regression Matrix (F1..F8 -> X, Y, Z) -----------------------------------
    private static readonly double[,] M = new double[8, 3]
    {
        {  1.0941533,  -0.846312,   7.3111637 },
        {  3.9575146,   0.1573942,  31.208729  },
        {  1.0834547,   0.7809895,  10.766341  },
        { -0.038636,    5.9429088,  -1.077367  },
        {  3.031054,    7.4237086,   0.501092  },
        {  3.563769,    3.9823614,  -1.293768  },
        {  3.551561,    1.4783982,   0.4297808 },
        { -1.045693,   -0.883656,   -1.763941  }
    };

    /// <summary>
    /// Applies a quadratic correction to the CCT reading based on UPTEK MK350S calibration.
    /// </summary>
    public static double CorrectCCT(double shownCCT)
    {
        const double A = 4.52e-5;
        const double B = 0.6910;
        const double C = 171.3;
        return A * shownCCT * shownCCT + B * shownCCT + C;
    }

    /// <summary>
    /// Converts interleaved little-endian bytes to an array of ushorts.
    /// </summary>
    public static ushort[] ConvertBytesToUshorts(byte[] data)
    {
        if (data == null) throw new ArgumentNullException(nameof(data));
        if (data.Length % 2 != 0) throw new ArgumentException("Byte array length must be even.");
        int count = data.Length / 2;
        var result = new ushort[count];
        for (int i = 0; i < count; i++)
            result[i] = (ushort)(data[2 * i] | (data[2 * i + 1] << 8));
        return result;
    }

    public static ColorResult ComputeLuxCctFromRaw(
        ushort[] rawData,
        double calPower,
        double[] calibrationFactors = null)
    {
        if (rawData == null || rawData.Length < 8)
            throw new ArgumentException("rawData must contain at least 8 channels.");

        calibrationFactors ??= new double[8] { 1, 1, 1, 1, 1, 1, 1, 1 };



        // 1) Map raw channels to CIE 1931 X, Y, Z
        double X = 0, Y = 0, Z = 0;
        for (int j = 0; j < 3; j++)
        {
            double sum = 0;
            for (int i = 0; i < 8; i++)
                sum += rawData[i] * M[i, j] * calibrationFactors[i];
            switch (j)
            {
                case 0: X = sum; break;
                case 1: Y = sum; break;
                default: Z = sum; break;
            }
        }

        // 2) Compute xy chromaticity
        double sumXYZ = X + Y + Z;
        if (sumXYZ < 1e-9)
            return new ColorResult(); // dark, all zeros
        double x = X / sumXYZ;
        double y = Y / sumXYZ;

        // 3) Compute raw CCT via McCamy's approximation
        double cct = 0;
        double denom = 0.1858 - y;
        if (Math.Abs(denom) > 1e-6)
        {
            double n = (x - 0.3320) / denom;
            cct = 449.0 * Math.Pow(n, 3)
                + 3525.0 * Math.Pow(n, 2)
                + 6823.3 * n
                + 5520.33;
            cct = cct * CctGain - FIXED_CCT_OFFSET;

            if (USE_CUSTOM_CCT_CORRECTION)
                cct = CorrectCCT(cct);

            if (UseCctBounds)
            {
                if (Y * LuxGain <= CCT_LUX_MIN)
                    cct = 0;
                cct = Math.Min(Math.Max(cct, CCT_MIN), CCT_MAX);
            }

            if (UseStableCctLimit && cct > CctStableMax)
                cct = CctStableMax;
        }

        if (UseCctSmoothing)
        {
            var now = DateTime.UtcNow;
            lock (_historyLock)
            {
                _cctHistory.AddLast((now, cct));
                while (_cctHistory.Count > 0 && (now - _cctHistory.First.Value.time) > CctSmoothingMaxAge)
                    _cctHistory.RemoveFirst();
                if (_cctHistory.Count > 0)
                    cct = _cctHistory.Average(e => e.cct);
                while (_cctHistory.Count > CctSmoothingCount)
                    _cctHistory.RemoveFirst();
            }
        }

        // 4) Compute illuminance with CAL_POWER correction
        double lux = Y * LuxGain;
        
        //Removed correction as it did not fit correctly - we will make a correction-factor by calibration-file instead
        //lux = CorrectLuxMeasurement(lux, calPower);

        // 5) Compute CIE1976 u', v'
        double uvDen = X + 15 * Y + 3 * Z;
        double u = uvDen > 1e-9 ? 4 * X / uvDen : 0;
        double v = uvDen > 1e-9 ? 9 * Y / uvDen : 0;

        // 6) Compute Duv
        double Duv = ComputeDuv(cct, u, v);

        return new ColorResult
        {
            Lux = lux,
            Cct = cct,
            x = x,
            y = y,
            u = u,
            v = v,
            Duv = Duv
        };
    }

    public static double GetInterpolatedCalPowerFactor(double calPower)
    {
        var knownCalPowers = new Dictionary<double, double>
{
    { 3276, 1.0199 },
    { 3305, 1.0000 },
    { 3310, 1.0161 },
    { 3324, 0.9853 }
};

        var sortedKeys = knownCalPowers.Keys.OrderBy(k => k).ToList();

        if (calPower <= sortedKeys.First())
            return knownCalPowers[sortedKeys.First()];

        if (calPower >= sortedKeys.Last())
            return knownCalPowers[sortedKeys.Last()];

        for (int i = 0; i < sortedKeys.Count - 1; i++)
        {
            var lowerKey = sortedKeys[i];
            var upperKey = sortedKeys[i + 1];

            if (calPower >= lowerKey && calPower <= upperKey)
            {
                double lowerFactor = knownCalPowers[lowerKey];
                double upperFactor = knownCalPowers[upperKey];

                double fraction = (calPower - lowerKey) / (upperKey - lowerKey);
                return lowerFactor + (upperFactor - lowerFactor) * fraction;
            }
        }

        return 1.0; // Default fallback, should never reach here
    }

    public static double CorrectLuxMeasurement(double measuredLux, double calPower)
    {
        double factor = GetInterpolatedCalPowerFactor(calPower);
        return measuredLux * factor;
    }

    private static double ComputeDuv(double cct, double u, double v)
    {
        double u_bb = 0, v_bb = 0;
        if (cct > 0)
        {
            double T = Math.Max(cct, 1667.0);
            double x_bb = T <= 4000.0
                ? -0.2661239e9 / (T * T * T) - 0.2343580e6 / (T * T) + 0.8776956e3 / T + 0.179910
                : -3.0258469e9 / (T * T * T) + 2.1070379e6 / (T * T) + 0.2226347e3 / T + 0.240390;
            double y_bb;
            if (T <= 2222.0)
                y_bb = -1.1063814 * Math.Pow(x_bb, 3) - 1.34811020 * Math.Pow(x_bb, 2) + 2.18555832 * x_bb - 0.20219683;
            else if (T <= 4000.0)
                y_bb = -0.9549476 * Math.Pow(x_bb, 3) - 1.37418593 * Math.Pow(x_bb, 2) + 2.09137015 * x_bb - 0.16748867;
            else
                y_bb = 3.0817580 * Math.Pow(x_bb, 3) - 5.87338670 * Math.Pow(x_bb, 2) + 3.75112997 * x_bb - 0.37001483;

            double bbDen = -2 * x_bb + 12 * y_bb + 3;
            if (Math.Abs(bbDen) > 1e-9)
            {
                u_bb = 4 * x_bb / bbDen;
                v_bb = 9 * y_bb / bbDen;
            }
        }
        double du = u - u_bb;
        double dv = v - v_bb;
        return Math.Sqrt(du * du + dv * dv) * (v < v_bb ? -1 : 1);
    }


    /// <summary>
    /// Container for all computed colorimetric values.
    /// </summary>
    public struct ColorResult
    {
        public double Lux;
        public double Cct;
        public double x;
        public double y;
        public double u;
        public double v;
        public double Duv;
    }
}`

[HonzaaD]

Great, but how do I use it? Could I ask for instructions?

` ///

/// Provádí kolorimetrické výpočty (Lux, CCT, chromatika a Duv) z dat ze senzoru AS7341.
/// Verze 2 s volitelným vyhlazováním CCT přes posledních N naměřených hodnot (v časovém okně).
///

[OlliV]

I'm open for contributions. I can't integrate this myself because I haven't been able to get an LM4.