automotive-diagnostics

Automotive Diagnostics

Diagnostic Tooling

Diagnostic Tooling - CANoe, CAPL, ODXStudio

Overview

Professional automotive diagnostic tools include CANoe/CANalyzer for testing, CAPL for scripting, ODXStudio for database creation, and open-source alternatives. This skill covers tooling ecosystems and DIY diagnostic development.

Vector CANoe/CANalyzer

CANoe Features

• Network simulation and testing
• ECU testing and validation
• Diagnostic protocol support (UDS, OBD-II, DoIP)
• CAPL scripting for automation
• Test automation frameworks

CAPL (Communication Access Programming Language)

CAPL Script Example - Automated Diagnostic Test:

/*
 * CAPL Script: Automated UDS Diagnostic Test
 * Tests: Session control, DTC reading, parameter reading
 */

includes
{
  #include "DiagnosticLibrary.cin"
}

variables
{
  int gTestsPassed = 0;
  int gTestsFailed = 0;
  int gTestTimeout = 2000;  // ms

  // Diagnostic addresses
  const dword kTesterAddress = 0x7E0;
  const dword kECUAddress = 0x7E8;

  // Test results
  char gTestReport[1000];
}

/* Initialize test environment */
on start
{
  write("========================================");
  write("UDS Diagnostic Test Suite");
  write("========================================");

  // Initialize diagnostic session
  DiagInit(kTesterAddress, kECUAddress);

  // Start test sequence
  setTimer(tmrStartTests, 100);
}

/* Test 1: Extended Diagnostic Session */
on timer tmrStartTests
{
  write("\n[Test 1] Extended Diagnostic Session");

  // Build UDS request: 0x10 0x03
  byte request[2];
  request[0] = 0x10;  // DiagnosticSessionControl
  request[1] = 0x03;  // Extended session

  // Send diagnostic request
  DiagSendRequest(request, 2);

  // Wait for response
  setTimer(tmrTest1Response, gTestTimeout);
}

/* Handle Test 1 Response */
on timer tmrTest1Response
{
  byte response[100];
  int length;

  if (DiagReceiveResponse(response, length))
  {
    if (response[0] == 0x50 && response[1] == 0x03)
    {
      write("  [PASS] Extended session activated");
      gTestsPassed++;

      // Start next test
      setTimer(tmrTest2, 100);
    }
    else if (response[0] == 0x7F)
    {
      write("  [FAIL] Negative response: 0x%02X", response[2]);
      gTestsFailed++;
      TestFailed();
    }
    else
    {
      write("  [FAIL] Invalid response format");
      gTestsFailed++;
      TestFailed();
    }
  }
  else
  {
    write("  [FAIL] Timeout waiting for response");
    gTestsFailed++;
    TestFailed();
  }
}

/* Test 2: Read DTCs */
on timer tmrTest2
{
  write("\n[Test 2] Read Diagnostic Trouble Codes");

  // Build UDS request: 0x19 0x02 0xFF
  byte request[3];
  request[0] = 0x19;  // ReadDTCInformation
  request[1] = 0x02;  // reportDTCByStatusMask
  request[2] = 0xFF;  // All status masks

  DiagSendRequest(request, 3);
  setTimer(tmrTest2Response, gTestTimeout);
}

/* Handle Test 2 Response */
on timer tmrTest2Response
{
  byte response[100];
  int length;
  int i, dtcCount;

  if (DiagReceiveResponse(response, length))
  {
    if (response[0] == 0x59 && response[1] == 0x02)
    {
      // Parse DTC count (after status availability mask)
      dtcCount = (length - 4) / 4;

      write("  [PASS] Read %d DTCs", dtcCount);

      // Parse and display DTCs
      for (i = 0; i < dtcCount; i++)
      {
        int offset = 4 + i * 4;
        char dtc[10];
        ParseDTC(response[offset], response[offset+1], response[offset+2], dtc);
        byte status = response[offset+3];

        write("    DTC: %s, Status: 0x%02X", dtc, status);
      }

      gTestsPassed++;
      setTimer(tmrTest3, 100);
    }
    else if (response[0] == 0x7F)
    {
      write("  [FAIL] Negative response: 0x%02X", response[2]);
      gTestsFailed++;
      TestFailed();
    }
  }
  else
  {
    write("  [FAIL] Timeout");
    gTestsFailed++;
    TestFailed();
  }
}

/* Test 3: Read Data by Identifier (VIN) */
on timer tmrTest3
{
  write("\n[Test 3] Read VIN (DID 0xF190)");

  byte request[3];
  request[0] = 0x22;  // ReadDataByIdentifier
  request[1] = 0xF1;  // DID high byte
  request[2] = 0x90;  // DID low byte

  DiagSendRequest(request, 3);
  setTimer(tmrTest3Response, gTestTimeout);
}

/* Handle Test 3 Response */
on timer tmrTest3Response
{
  byte response[100];
  int length;
  char vin[18];

  if (DiagReceiveResponse(response, length))
  {
    if (response[0] == 0x62 && response[1] == 0xF1 && response[2] == 0x90)
    {
      // Extract VIN (17 characters)
      int i;
      for (i = 0; i < 17; i++)
      {
        vin[i] = response[3 + i];
      }
      vin[17] = 0;  // Null terminate

      write("  [PASS] VIN: %s", vin);
      gTestsPassed++;

      // Complete test suite
      setTimer(tmrTestComplete, 100);
    }
    else if (response[0] == 0x7F)
    {
      write("  [FAIL] Negative response: 0x%02X", response[2]);
      gTestsFailed++;
      TestFailed();
    }
  }
  else
  {
    write("  [FAIL] Timeout");
    gTestsFailed++;
    TestFailed();
  }
}

/* Test Suite Complete */
on timer tmrTestComplete
{
  write("\n========================================");
  write("Test Suite Complete");
  write("  Tests Passed: %d", gTestsPassed);
  write("  Tests Failed: %d", gTestsFailed);
  write("========================================");

  if (gTestsFailed == 0)
  {
    write("RESULT: ALL TESTS PASSED");
  }
  else
  {
    write("RESULT: SOME TESTS FAILED");
  }
}

/* Handle test failure */
void TestFailed()
{
  setTimer(tmrTestComplete, 100);
}

/* Parse DTC bytes to string format */
void ParseDTC(byte high, byte mid, byte low, char dtc[10])
{
  byte system = (high >> 6) & 0x03;
  byte digit1 = (high >> 4) & 0x03;
  byte digit2 = high & 0x0F;
  byte digit3 = (mid >> 4) & 0x0F;
  byte digit4 = mid & 0x0F;

  char systemChar;
  switch (system)
  {
    case 0: systemChar = 'P'; break;
    case 1: systemChar = 'C'; break;
    case 2: systemChar = 'B'; break;
    case 3: systemChar = 'U'; break;
  }

  snprintf(dtc, 10, "%c%d%X%X%X", systemChar, digit1, digit2, digit3, digit4);
}

/* Diagnostic helper functions */
void DiagInit(dword tester, dword ecu)
{
  // Initialize diagnostic addressing
  write("Initializing diagnostic session");
  write("  Tester: 0x%03X", tester);
  write("  ECU:    0x%03X", ecu);
}

void DiagSendRequest(byte request[], int length)
{
  // Send diagnostic request via CAN
  message * msg;
  int i;

  msg = {CAN, kTesterAddress, 0, 8};

  // Build ISO-TP single frame or multi-frame message
  if (length <= 7)
  {
    // Single frame
    msg.byte(0) = 0x00 | length;
    for (i = 0; i < length; i++)
    {
      msg.byte(i + 1) = request[i];
    }
    output(msg);
  }
  else
  {
    // Multi-frame (simplified - full implementation needed)
    write("  Sending multi-frame request");
  }
}

int DiagReceiveResponse(byte response[], int &length)
{
  // Simplified - actual implementation needs ISO-TP handling
  // This would be called from on message handler
  return 0;
}