Create Haltech_To_Arduino_DRAFT.ino

Author: traviscea

Haltech_To_Arduino_DRAFT.ino

@@ -0,0 +1,303 @@
+// =======================================================
+// Travis Digital Dash – Haltech CAN → TS Dash Serial Bridge
+// Arduino Mega 2560 + MCP2515 (16MHz) @ 500kbps
+//
+// Serial side emulates the INI requirements:
+//   queryCommand   = "Q"  -> returns "speeduino-travis"
+//   versionInfo    = "S"  -> returns VERSION string
+//   ochGetCommand  = "r"  -> returns 87-byte output block
+//
+// INI OutputChannels (selected):
+//   rpm             U16 @ 0
+//   oilanalograw    U08 @ 3    (°C + 40)
+//   mapraw          U16 @ 4    (kPa absolute)
+//   coolantanalograw U08 @ 7   (°C + 40)
+//   oilPressure     U08 @ 10   (PSI)
+//   fuelPressure    U08 @ 11   (PSI)
+//   fuellevel       U08 @ 15   (%)
+//   vss             U16 @ 19   (kph)
+//   leftTurn        U08 @ 40   (0/1)
+//   rightTurn       U08 @ 41   (0/1)
+//   cel             U08 @ 42   (0/1)
+//   highBeam        U08 @ 43   (0/1)
+//   handbrake       U08 @ 44   (0/1)
+// =======================================================
+
+#include <Arduino.h>
+#include <SPI.h>
+#include <mcp_can.h>
+
+// ===================== IDENTITY (INI MATCH) =====================
+static const char SIGNATURE[] = "speeduino-travis";
+static const char VERSION[]   = "Travis Digital Dash v1.0";
+
+// ===================== SERIAL =====================
+static constexpr uint32_t BAUD_RATE = 115200;
+
+// ===================== CAN (MCP2515) =====================
+#define CAN_CS_PIN   53
+#define CAN_INT_PIN  2
+#define CAN_CLOCK    MCP_16MHZ
+#define CAN_SPEED    CAN_500KBPS
+
+MCP_CAN CAN(CAN_CS_PIN);
+
+// =======================================================
+// HALTECH CAN MAPPING (DEFAULTS / YOU MAY NEED TO ADJUST)
+// -------------------------------------------------------
+// Haltech CAN layouts can vary by ECU config and stream.
+// These defaults are *common* patterns, but if any channel
+// shows wrong, sniff the bus and update IDs/bytes/scales.
+// =======================================================
+
+// --------- Frame IDs (11-bit) ----------
+static constexpr uint16_t ID_RPM_MAP      = 0x360; // rpm + map
+static constexpr uint16_t ID_TEMPS        = 0x361; // clt + oil temp (example)
+static constexpr uint16_t ID_PRESSURES    = 0x362; // oil psi + fuel psi (example)
+static constexpr uint16_t ID_SPEED_FUEL   = 0x363; // speed kph + fuel % (example)
+static constexpr uint16_t ID_INDICATORS   = 0x364; // turn/cel/high/handbrake (example)
+
+// --------- Byte layouts / scaling ----------
+// RPM:        U16 little-endian, units rpm
+// MAP:        U16 little-endian, units kPa absolute
+// CLT/OIL:    int16 or u16? (varies). We convert to °C then encode as U08 (°C + 40).
+// Pressures:  usually kPa or PSI; we output PSI already scaled in firmware (U08).
+// Speed:      U16 kph
+// Fuel:       U08 percent
+//
+// If your Haltech stream uses different scaling (e.g. 0.1 kPa, 0.1°C), adjust here:
+static constexpr float TEMP_SCALE = 1.0f;   // e.g. 0.1f if temp is in 0.1°C
+static constexpr float MAP_SCALE  = 1.0f;   // e.g. 0.1f if map is in 0.1 kPa
+static constexpr float RPM_SCALE  = 1.0f;   // e.g. 0.5f if half-RPM, etc.
+static constexpr float PSI_SCALE  = 1.0f;   // e.g. 0.145038 if kPa->psi, etc.
+
+// ===================== OUTPUT BLOCK =====================
+static constexpr uint8_t OCH_BLOCK_SIZE = 87;  // ini: ochBlockSize = 87
+static uint8_t och[OCH_BLOCK_SIZE];
+
+// ===================== LIVE VALUES (decoded from CAN) =====================
+static volatile uint16_t g_rpm = 0;
+static volatile uint16_t g_map_kpa = 100;     // default ~atmosphere
+static volatile int16_t  g_clt_c = 20;
+static volatile int16_t  g_oil_c = 20;
+static volatile uint8_t  g_oil_psi = 0;
+static volatile uint8_t  g_fuel_psi = 0;
+static volatile uint16_t g_speed_kph = 0;
+static volatile uint8_t  g_fuel_pct = 0;
+
+static volatile uint8_t  g_leftTurn = 0;
+static volatile uint8_t  g_rightTurn = 0;
+static volatile uint8_t  g_cel = 0;
+static volatile uint8_t  g_highBeam = 0;
+static volatile uint8_t  g_handbrake = 0;
+
+// Optional: basic timeout protection
+static uint32_t lastCanRxMs = 0;
+
+// ===================== SMALL HELPERS =====================
+static inline uint16_t u16le(const uint8_t *b) {
+  return (uint16_t)b[0] | ((uint16_t)b[1] << 8);
+}
+static inline int16_t s16le(const uint8_t *b) {
+  return (int16_t)((uint16_t)b[0] | ((uint16_t)b[1] << 8));
+}
+
+static inline uint8_t clampU8(int v) {
+  if (v < 0) return 0;
+  if (v > 255) return 255;
+  return (uint8_t)v;
+}
+
+static inline uint8_t tempC_to_iniRaw(int16_t tempC) {
+  // INI expects U08 = (°C + 40)
+  return clampU8((int)tempC + 40);
+}
+
+static void writeU16LE(uint8_t *dst, uint16_t v) {
+  dst[0] = (uint8_t)(v & 0xFF);
+  dst[1] = (uint8_t)(v >> 8);
+}
+
+// ===================== CAN RECEIVE =====================
+static void handleCanFrame(uint16_t id, const uint8_t *buf, uint8_t len) {
+  (void)len;
+  lastCanRxMs = millis();
+
+  switch (id) {
+    case ID_RPM_MAP: {
+      // [0..1]=RPM, [2..3]=MAP (kPa abs)
+      uint16_t rpmRaw = u16le(&buf[0]);
+      uint16_t mapRaw = u16le(&buf[2]);
+
+      uint32_t rpm = (uint32_t)(rpmRaw * RPM_SCALE);
+      uint32_t map = (uint32_t)(mapRaw * MAP_SCALE);
+
+      if (rpm > 30000) rpm = 30000;
+      if (map > 4000)  map = 4000;
+
+      g_rpm = (uint16_t)rpm;
+      g_map_kpa = (uint16_t)map;
+    } break;
+
+    case ID_TEMPS: {
+      // Example: [0..1]=CLT, [2..3]=OilTemp (in °C * TEMP_SCALE)
+      int16_t cltRaw = s16le(&buf[0]);
+      int16_t oilRaw = s16le(&buf[2]);
+
+      int16_t cltC = (int16_t)(cltRaw * TEMP_SCALE);
+      int16_t oilC = (int16_t)(oilRaw * TEMP_SCALE);
+
+      // sanity
+      if (cltC < -40) cltC = -40;
+      if (cltC > 215) cltC = 215;
+      if (oilC < -40) oilC = -40;
+      if (oilC > 215) oilC = 215;
+
+      g_clt_c = cltC;
+      g_oil_c = oilC;
+    } break;
+
+    case ID_PRESSURES: {
+      // Example: [0]=oil psi, [1]=fuel psi (already PSI)
+      // If yours is kPa, change PSI_SCALE and conversion.
+      uint16_t oilRaw  = buf[0];
+      uint16_t fuelRaw = buf[1];
+
+      uint16_t oilPsi  = (uint16_t)(oilRaw * PSI_SCALE);
+      uint16_t fuelPsi = (uint16_t)(fuelRaw * PSI_SCALE);
+
+      if (oilPsi  > 255) oilPsi  = 255;
+      if (fuelPsi > 255) fuelPsi = 255;
+
+      g_oil_psi  = (uint8_t)oilPsi;
+      g_fuel_psi = (uint8_t)fuelPsi;
+    } break;
+
+    case ID_SPEED_FUEL: {
+      // Example: [0..1]=speed kph, [2]=fuel %
+      g_speed_kph = u16le(&buf[0]);
+      g_fuel_pct  = buf[2];
+      if (g_fuel_pct > 100) g_fuel_pct = 100;
+    } break;
+
+    case ID_INDICATORS: {
+      // Example: packed bits in buf[0]
+      // bit0=left, bit1=right, bit2=cel, bit3=high, bit4=handbrake
+      uint8_t bits = buf[0];
+      g_leftTurn  = (bits & (1 << 0)) ? 1 : 0;
+      g_rightTurn = (bits & (1 << 1)) ? 1 : 0;
+      g_cel       = (bits & (1 << 2)) ? 1 : 0;
+      g_highBeam  = (bits & (1 << 3)) ? 1 : 0;
+      g_handbrake = (bits & (1 << 4)) ? 1 : 0;
+    } break;
+
+    default:
+      break;
+  }
+}
+
+// ===================== BUILD THE 87-BYTE OCH BLOCK =====================
+static void buildOchBlock() {
+  // Clear everything (anything not defined in your INI stays 0)
+  memset(och, 0, sizeof(och));
+
+  // Match INI offsets exactly :contentReference[oaicite:4]{index=4}
+  // rpm: U16 @ 0
+  writeU16LE(&och[0], g_rpm);
+
+  // oilanalograw: U08 @ 3  (°C + 40)
+  och[3] = tempC_to_iniRaw(g_oil_c);
+
+  // mapraw: U16 @ 4 (kPa abs)
+  writeU16LE(&och[4], g_map_kpa);
+
+  // coolantanalograw: U08 @ 7 (°C + 40)
+  och[7] = tempC_to_iniRaw(g_clt_c);
+
+  // oilPressure: U08 @ 10 (PSI)
+  och[10] = g_oil_psi;
+
+  // fuelPressure: U08 @ 11 (PSI)
+  och[11] = g_fuel_psi;
+
+  // fuellevel: U08 @ 15 (%)
+  och[15] = g_fuel_pct;
+
+  // vss: U16 @ 19 (kph)
+  writeU16LE(&och[19], g_speed_kph);
+
+  // indicators: U08 @ 40..44
+  och[40] = g_leftTurn;
+  och[41] = g_rightTurn;
+  och[42] = g_cel;
+  och[43] = g_highBeam;
+  och[44] = g_handbrake;
+}
+
+// ===================== TS SERIAL COMMAND HANDLING =====================
+// TS will send:
+//  'Q' -> expects signature string :contentReference[oaicite:5]{index=5}
+//  'S' -> expects version string :contentReference[oaicite:6]{index=6}
+//  'r' -> expects ochBlockSize bytes :contentReference[oaicite:7]{index=7}
+//
+// Important: Do NOT print debug text while TS is connected.
+static void handleSerialByte(uint8_t c) {
+  if (c == 'Q') {
+    Serial.print(SIGNATURE);
+    return;
+  }
+  if (c == 'S') {
+    Serial.print(VERSION);
+    return;
+  }
+  if (c == 'r') {
+    buildOchBlock();
+    Serial.write(och, OCH_BLOCK_SIZE);
+    return;
+  }
+  // ignore anything else (keeps TS happy)
+}
+
+// ===================== SETUP =====================
+void setup() {
+  Serial.begin(BAUD_RATE);
+
+  pinMode(CAN_INT_PIN, INPUT);
+
+  if (CAN.begin(MCP_ANY, CAN_SPEED, CAN_CLOCK) != CAN_OK) {
+    // No Serial prints here if you want TS to connect cleanly later.
+    // If you need debug, temporarily uncomment this:
+    // Serial.println("CAN INIT FAILED");
+    while (1) {;}
+  }
+
+  CAN.setMode(MCP_NORMAL);
+  lastCanRxMs = millis();
+}
+
+// ===================== LOOP =====================
+void loop() {
+  // --- CAN service ---
+  if (!digitalRead(CAN_INT_PIN)) {
+    long unsigned int rxId32;
+    unsigned char len = 0;
+    unsigned char buf[8];
+
+    if (CAN.readMsgBuf(&rxId32, &len, buf) == CAN_OK) {
+      uint16_t id = (uint16_t)(rxId32 & 0x7FF); // 11-bit
+      handleCanFrame(id, buf, len);
+    }
+  }
+
+  // --- Optional: CAN timeout fallback (prevent stale numbers) ---
+  if (millis() - lastCanRxMs > 1000) {
+    g_rpm = 0;
+    g_speed_kph = 0;
+    // keep temps/map last-known; you can zero them too if you prefer
+  }
+
+  // --- Serial service ---
+  while (Serial.available()) {
+    handleSerialByte((uint8_t)Serial.read());
+  }
+}