128 lines
4.9 KiB
C#
128 lines
4.9 KiB
C#
using System;
|
|
|
|
namespace TuneBoss.Core.Models
|
|
{
|
|
/// <summary>
|
|
/// A 1D lookup table as stored on the ECU: 8 raw-axis breakpoints mapped to
|
|
/// 8 conversion (output) values, plus 8 metadata bytes (scaling / sign / clamp).
|
|
///
|
|
/// Fixed 24-byte wire layout:
|
|
/// [0..7] raw axis breakpoints (signed when RawSignedFlag > 0)
|
|
/// [8..15] conversion/output vals (signed when ConvSignedFlag > 0)
|
|
/// [16] MaxRaw (follows raw sign)
|
|
/// [17] MinRaw (follows raw sign)
|
|
/// [18] RawSignedFlag (> 0 => axis bytes are signed)
|
|
/// [19] ConvSignedFlag (> 0 => value bytes are signed)
|
|
/// [20] RawMultiplier (firmware-side display scaling)
|
|
/// [21] ConvMultiplier
|
|
/// [22] RawRounding
|
|
/// [23] ConvOffset (ALWAYS signed)
|
|
///
|
|
/// Read with APP_MEMRD_1D (0x43), written with APP_MEMWR_1D (0x4B).
|
|
/// The sign flags and the four scaling bytes are round-tripped VERBATIM so a
|
|
/// write never disturbs metadata the firmware relies on.
|
|
/// </summary>
|
|
public sealed class OneDimTable
|
|
{
|
|
public const int PointCount = 8;
|
|
public const int WireLength = 24;
|
|
|
|
public int[] RawAxis { get; }
|
|
public int[] ConvValues { get; }
|
|
|
|
// metadata (bytes 16..23)
|
|
public int MaxRaw { get; set; }
|
|
public int MinRaw { get; set; }
|
|
public byte RawSignedFlag { get; set; }
|
|
public byte ConvSignedFlag { get; set; }
|
|
public byte RawMultiplier { get; set; }
|
|
public byte ConvMultiplier { get; set; }
|
|
public byte RawRounding { get; set; }
|
|
public sbyte ConvOffset { get; set; }
|
|
|
|
public bool IsRawSigned => RawSignedFlag > 0;
|
|
public bool IsConvSigned => ConvSignedFlag > 0;
|
|
|
|
public OneDimTable()
|
|
{
|
|
RawAxis = new int[PointCount];
|
|
ConvValues = new int[PointCount];
|
|
}
|
|
|
|
/// <summary>Decode a 24-byte block (e.g. the data section of a 0x51 0x43 response).</summary>
|
|
public static OneDimTable FromWire(byte[] data, int offset = 0)
|
|
{
|
|
if (data is null) throw new ArgumentNullException(nameof(data));
|
|
if (data.Length - offset < WireLength)
|
|
throw new ArgumentException($"1D payload needs {WireLength} bytes from offset {offset}.", nameof(data));
|
|
|
|
var t = new OneDimTable
|
|
{
|
|
RawSignedFlag = data[offset + 18],
|
|
ConvSignedFlag = data[offset + 19],
|
|
RawMultiplier = data[offset + 20],
|
|
ConvMultiplier = data[offset + 21],
|
|
RawRounding = data[offset + 22],
|
|
ConvOffset = unchecked((sbyte)data[offset + 23]),
|
|
};
|
|
|
|
bool rawSigned = t.RawSignedFlag > 0;
|
|
bool convSigned = t.ConvSignedFlag > 0;
|
|
|
|
for (int i = 0; i < PointCount; i++)
|
|
{
|
|
t.RawAxis[i] = Decode(data[offset + i], rawSigned);
|
|
t.ConvValues[i] = Decode(data[offset + 8 + i], convSigned);
|
|
}
|
|
|
|
t.MaxRaw = Decode(data[offset + 16], rawSigned);
|
|
t.MinRaw = Decode(data[offset + 17], rawSigned);
|
|
return t;
|
|
}
|
|
|
|
/// <summary>Produce the 24-byte data block to send with APP_MEMWR_1D.</summary>
|
|
public byte[] ToWirePayload()
|
|
{
|
|
var d = new byte[WireLength];
|
|
bool rawSigned = IsRawSigned;
|
|
bool convSigned = IsConvSigned;
|
|
|
|
for (int i = 0; i < PointCount; i++)
|
|
{
|
|
d[i] = Encode(RawAxis[i], rawSigned);
|
|
d[8 + i] = Encode(ConvValues[i], convSigned);
|
|
}
|
|
|
|
d[16] = Encode(MaxRaw, rawSigned);
|
|
d[17] = Encode(MinRaw, rawSigned);
|
|
d[18] = RawSignedFlag;
|
|
d[19] = ConvSignedFlag;
|
|
d[20] = RawMultiplier;
|
|
d[21] = ConvMultiplier;
|
|
d[22] = RawRounding;
|
|
d[23] = unchecked((byte)ConvOffset);
|
|
return d;
|
|
}
|
|
|
|
public OneDimTable Clone()
|
|
{
|
|
var c = new OneDimTable
|
|
{
|
|
MaxRaw = MaxRaw, MinRaw = MinRaw,
|
|
RawSignedFlag = RawSignedFlag, ConvSignedFlag = ConvSignedFlag,
|
|
RawMultiplier = RawMultiplier, ConvMultiplier = ConvMultiplier,
|
|
RawRounding = RawRounding, ConvOffset = ConvOffset,
|
|
};
|
|
Array.Copy(RawAxis, c.RawAxis, PointCount);
|
|
Array.Copy(ConvValues, c.ConvValues, PointCount);
|
|
return c;
|
|
}
|
|
|
|
private static int Decode(byte b, bool signed) => signed ? unchecked((sbyte)b) : b;
|
|
|
|
private static byte Encode(int v, bool signed) => signed
|
|
? unchecked((byte)(sbyte)Math.Clamp(v, sbyte.MinValue, sbyte.MaxValue))
|
|
: (byte)Math.Clamp(v, byte.MinValue, byte.MaxValue);
|
|
}
|
|
}
|