@kb1rma/libcomm14cux-ts 0.0.0

package/src/decoders/romRevision.ts

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// Derived from libcomm14cux (https://github.com/colinbourassa/libcomm14cux)
+// Copyright (C) Colin Bourassa. Licensed under the GNU GPL v3.
+// Ported to TypeScript and modified for comm14cux-ts, 2026.
+
+import { DataOffsetRev } from '../constants.js';
+
+/**
+ * Tells whether the ROM uses the Rev C data layout. The first row of a fuel
+ * map never reaches 0x30, so a larger value at the old Map 1 location means it
+ * is not map data.
+ *
+ * @param oldMap1FirstRow - The 16 bytes read from 0xC23F.
+ * @returns `true` for the Rev C layout.
+ */
+export function isRevC(oldMap1FirstRow: Uint8Array): boolean {
+  return oldMap1FirstRow.some((value) => value > 0x30);
+}
+
+/**
+ * Distinguishes Rev A from Rev B by the first main voltage factor byte.
+ *
+ * @param voltageFactorA - The byte read from 0xC79B.
+ * @returns Rev A if it is 0xFF, otherwise Rev B.
+ */
+export function classifyOldRevision(
+  voltageFactorA: number,
+): typeof DataOffsetRev.RevA | typeof DataOffsetRev.RevB {
+  return voltageFactorA === 0xff ? DataOffsetRev.RevA : DataOffsetRev.RevB;
+}

package/src/decoders/temperature.ts

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// Derived from libcomm14cux (https://github.com/colinbourassa/libcomm14cux)
+// Copyright (C) Colin Bourassa. Licensed under the GNU GPL v3.
+// Ported to TypeScript and modified for comm14cux-ts, 2026.
+import { InvalidReadingError } from '../errors.js';
+
+/** ADC count to degrees Fahrenheit (`temperature_adc_to_degrees_f`). */
+export const TEMPERATURE_ADC_TO_DEGREES_F: readonly number[] = [
+  266, 264, 260, 258, 255, 253, 249, 248, 244, 242, 239, 237, 233, 231, 228,
+  226, 222, 221, 219, 217, 215, 213, 212, 210, 208, 206, 204, 203, 201, 199,
+  197, 195, 194, 192, 190, 188, 186, 185, 183, 181, 179, 177, 176, 174, 172,
+  170, 168, 167, 165, 163, 161, 159, 158, 158, 156, 154, 152, 150, 149, 147,
+  145, 145, 143, 141, 140, 138, 138, 136, 136, 134, 132, 132, 131, 131, 129,
+  129, 127, 125, 125, 123, 123, 122, 122, 120, 120, 118, 118, 116, 116, 114,
+  114, 113, 113, 111, 111, 109, 109, 107, 107, 105, 105, 104, 104, 102, 102,
+  100, 100, 98, 98, 96, 96, 95, 95, 95, 93, 93, 91, 91, 89, 89, 87, 87, 86, 86,
+  84, 84, 82, 82, 82, 82, 80, 80, 78, 78, 78, 77, 77, 75, 75, 73, 73, 73, 71,
+  71, 71, 69, 69, 68, 68, 66, 66, 64, 64, 62, 62, 60, 60, 59, 59, 57, 57, 57,
+  55, 55, 53, 53, 51, 51, 50, 50, 48, 48, 46, 46, 44, 44, 44, 44, 42, 42, 42,
+  41, 41, 41, 39, 39, 37, 37, 37, 35, 35, 35, 35, 33, 33, 32, 32, 31, 31, 29,
+  29, 27, 27, 25, 25, 23, 23, 22, 22, 22, 20, 20, 18, 18, 18, 16, 16, 14, 14,
+  13, 13, 13, 11, 11, 11, 9, 9, 7, 7, 5, 5, 4, 4, 2, 2, 0, 0, -2, -2, -4, -4,
+  -4, -5, -5, -7, -7, -7, -9, -9, -9, -11, -11, -11, -13, -13, -13,
+];
+
+/**
+ * Converts a coolant or fuel temperature sensor ADC count to degrees
+ * Fahrenheit.
+ *
+ * @param adcCount - The byte read from the sensor location, 0 to 255.
+ * @returns Temperature in degrees Fahrenheit.
+ * @throws {@link InvalidReadingError} if `adcCount` is not 0 to 255.
+ */
+export function decodeTemperatureF(adcCount: number): number {
+  const degrees = TEMPERATURE_ADC_TO_DEGREES_F[adcCount];
+
+  if (degrees === undefined) {
+    throw new InvalidReadingError(`Invalid temperature ADC count: ${adcCount}`);
+  }
+
+  return degrees;
+}

package/src/decoders/throttle.ts

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// Derived from libcomm14cux (https://github.com/colinbourassa/libcomm14cux)
+// Copyright (C) Colin Bourassa. Licensed under the GNU GPL v3.
+// Ported to TypeScript and modified for comm14cux-ts, 2026.
+
+import { InvalidReadingError } from '../errors.js';
+
+const MAX_READING = 1023;
+
+/**
+ * Rejects a raw throttle reading above the 10-bit maximum.
+ *
+ * @param raw - The raw reading.
+ * @throws {@link InvalidReadingError} if `raw` is above 1023.
+ */
+export function assertThrottleReading(raw: number): void {
+  if (raw > MAX_READING) {
+    throw new InvalidReadingError(`Throttle reading out of range: ${raw}`);
+  }
+}
+
+/**
+ * Decodes the throttle position.
+ *
+ * @param raw - The 10-bit reading, 0 to 1023.
+ * @param minimum - 0 for an absolute reading, or the ECU's stored minimum for a
+ * corrected reading.
+ * @returns Position as a fraction from 0 (closed) to 1 (wide open).
+ * @throws {@link InvalidReadingError} if `raw` is above 1023.
+ */
+export function decodeThrottlePosition(raw: number, minimum: number): number {
+  assertThrottleReading(raw);
+
+  // A glitch can put the reading below the stored minimum; report zero
+  // (this also avoids dividing by zero when the minimum is 1023).
+  return raw > minimum ? (raw - minimum) / (MAX_READING - minimum) : 0;
+}

package/src/decoders/tuneRevision.ts

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// Derived from libcomm14cux (https://github.com/colinbourassa/libcomm14cux)
+// Copyright (C) Colin Bourassa. Licensed under the GNU GPL v3.
+// Ported to TypeScript and modified for comm14cux-ts, 2026.
+
+/**
+ * Tune identification stored in the ROM.
+ */
+export interface TuneRevision {
+  /**
+   * Decimal tune number decoded from two BCD bytes.
+   */
+  tuneNumber: number;
+  /**
+   * Checksum fixer byte.
+   */
+  checksumFixer: number;
+  /**
+   * Ident word, which differentiates builds of the same tune number.
+   */
+  tuneIdent: number;
+}
+
+function bcd(byte: number): number {
+  return (byte >> 4) * 10 + (byte & 0x0f);
+}
+
+/**
+ * Decodes the five tune identification bytes.
+ *
+ * @param bytes - The bytes read from 0xFFE9.
+ * @returns The tune number, checksum fixer and ident word.
+ */
+export function decodeTuneRevision(bytes: Uint8Array): TuneRevision {
+  const [b0 = 0, b1 = 0, fixer = 0, identHigh = 0, identLow = 0] = bytes;
+
+  return {
+    tuneNumber: bcd(b0) * 100 + bcd(b1),
+    checksumFixer: fixer,
+    tuneIdent: (identHigh << 8) | identLow,
+  };
+}