More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    CDD ARXML Consistency

    1

    Cross-check a CANdelaStudio CDD against an AUTOSAR ECU's Dcm/Dem/CanIf config — 25 checks, and it says which side is wrong.

    Free

    Security scanned
    CDD ARXML Consistency

    CDD ARXML Consistency

    Example session with this skill installed

    Validate this CDD against the ECU configuration before we hand it to the test house:
    diagnostic_spec.cdd and ecuconfig.xml

    Tell me what would actually break on the bench, not just what differs.

    • Read your context and instructions
    • Compiled the cdd arxml consistency
    • Generated the data export

    Ran check on both files. 1 error / 2 warn / 3 info.

    Field labels below are Chinese in the real output (the tool's default locale); the numbers are a real run against a synthetic fixture pair.

    DID     CDD 4 / Dcm 4 交集 3
    DTC     CDD 3 / Dem 3 交集 2
    例程    CDD 2 / Dcm 1 交集 1
    会话    CDD 3 / Dcm 2
    安全    CDD 1 / Dcm 1
    summary: 6 error, 4 warn, 3 info
    

    The one that would fail on the bench

    [E] CDX-010  Physical request CAN id mismatch: CDD 0x6A0 / CanIf 0x6A1  [CAN ID]
          CanIf's CanIfRxPduCfg_Phys_Req is 0x6A1 (1697); the CDD's CAN.ReqCanId is
          0x6A0 (1696). They differ by 1. The tester sends what the CDD says, the ECU
          listens on what CanIf says — the request never reaches Dcm.
          The hardware acceptance filter contains 0x6A0 and not 0x6A1, so the
          controller only hands 0x6A0 frames upward.
          Therefore the wrong side is CanIf's CanIfRxPduCfg_Phys_Req (should be
          0x6A0), not the CDD.
    

    Note what that last paragraph is not: it is not "the two files disagree". It is a
    verdict, with the hardware filter as the evidence, naming the parameter to change.

    What the rest of the report looks like

    [E] CDX-001  1 DID in the CDD, not configured in Dcm        (0x4800 Traceability_Code)
    [E] CDX-004  1 DTC in the CDD, not in Dem                   (0x100003)
    [E] CDX-006  1 routine in the CDD, not in Dcm               (0x0303)
    [E] CDX-020  Session 2 P2Server: CDD 50ms / Dcm 60ms
    [E] CDX-030  1 session only in the CDD                      (3 ExtendedSession)
    [W] CDX-002  1 DID in Dcm, not in the CDD                   (0xF187)
    [W] CDX-003  DID 0xF18A present but DcmDspDidUsed=false
    [W] CDX-005  1 DTC in Dem, not in the CDD                   (0x100004)
    [W] CDX-032  Security level 1: Seed(16B) vs Key(8B) differ in length
    

    And the case that used to report nothing

    A CDD saved from a CANdelaStudio template with the CAN page never filled in:

    summary: 5 error, 5 warn, 3 info
    [E] CDX-013  CDD lacks 3 diagnostic CAN addresses; related comparison skipped
    [W] CDX-025  CDD lacks 5 timing parameters; related comparison skipped
    

    CDX-013 spells out that CDX-010/011/012 did not run, so "no CAN id findings"
    cannot be read as "CAN ids are fine". That was a real bug in an earlier build.

    Next steps

    1. Change CanIfRxPduCfg_Phys_Req.CanIfRxPduCanId to 0x6A0, then re-run check
    2. Add the missing DTC to Dem, or delete it from the CDD — decide which side owns it
    3. matrix -o inventory.csv if the supplier needs the per-item list

    inventory.csv

    CSV · data export

    Generated

    Example file from a real run - the skill writes it into your workspace.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Diagnostic configuration fails quietly. Nothing throws. The ECU boots, the tester connects, the session opens — and then a request comes back 0x31 requestOutOfRange, or the DID replies with a payload three bytes shorter than the spec says, or the security level the production line needs simply is not there.

    All of it compiles. None of it logs.

    The two sides are written by different people in different tools:

    • the CDD is the diagnostic specification, written in CANdelaStudio — what the tester is built from
    • the ARXML is the ECU configuration — the Dcm / Dem / CanIf / CanTp containers that actually run on the ECU

    This skill compares them across 25 checks, using one standard-library Python script. No lxml, no cantools, nothing to install, and it never modifies the files you pass in.

    What it does

    • DIDs — in the spec but not configured (the tester sends, the ECU rejects), or configured but absent from the spec (the ECU answers something nobody documents)
    • DTCs — the same, plus a check for the CDD disagreeing with itself about its own fault list
    • Routines — an erase or check-integrity routine the flashing sequence will call into an ECU that never registered it
    • Diagnostic CAN addressing — physical request, functional request, response
    • Timing — P2 / P2* per session, S3, STmin, block size
    • Sessions and security — a session or a security level defined in the spec with no counterpart in Dcm, which means every service protected by it is locked forever

    Three things that are easy to get wrong

    It does not guess which file is wrong — it proves it.

    When a CAN ID disagrees, the obvious report is "CDD says 0x6A0, CanIf says 0x6A1". That is a diff, not a verdict, and it leaves the reader to change whichever file they happen to own — half the time the wrong one. This tool reads the hardware acceptance filters (Can/CanConfigSet/CanHwFilter, Code + Mask) and evaluates:

    accepts(frame_id) := (frame_id & mask) == (code & mask)
    

    If the filter accepts the CDD's id and rejects CanIf's, the controller will never hand those frames upward and CanIf is wrong. The report says so, names the parameter, and gives the value it should be. Real case: in a 51-filter configuration exactly one accepted the CDD's id (mask 0x7FE) and none accepted CanIf's. A second, independent confirmation came from CanTp: its N_SA/N_TA decoded to the low byte of the CDD's id.

    "Not configured" is not "no problem".

    A CDD carries diagnostic addresses in two different places: attribute instances under <ECU> (this ECU's configuration) and attribute definitions under DEFATTS/ECUATTS (the CANdelaStudio template defaults). Save a template as a new project, leave the CAN tab empty, and only the second exists.

    An earlier build of this tool skipped all eight addressing and timing checks in that situation — and the report simply never mentioned CAN ids. Which reads exactly like "CAN ids are fine". A run where every DID, DTC and routine matched looked like a complete review, while the addressing had never been filled in at all.

    The numbers are worse than "missing": the template defaults are 0x700 / 0x600 / 0x750, so exporting ODX from that CDD makes the tester send requests to 0x700 — an address no ECU on that bus is listening on.

    The fix is not "fall back to the template value and compare anyway" — that produces a confident verdict about the wrong number. The gap itself is reported: CDX-013 (error) and CDX-025 (warn), each naming the checks that did not run, and each labelling the DEFATTS numbers as template values.

    Bit-level detail is left to the layers that own it.

    This tool does not claim to verify DID payload structure, the service/session/security dependency matrix, NRC usage per service, or the security algorithm. Those are listed in every report as not covered, so that "25 checks passed" cannot be read as "the diagnostics are correct".

    How it is used

    1. probe — what each side actually contains. Run this first on 5 MB files: it takes a second and tells you whether anything parsed at all
    2. check — the full comparison; exits 1 on errors, so it drops into CI
    3. matrix — per-item inventory CSV with a both / cdd_only / arxml_only / arxml_unused column, for handing to a supplier
    4. selftest — two built-in fixtures so you can confirm it works before pointing it at a real project

    Verification

    25 check codes, asserted in both the Chinese and English documentation against the code that emits them, in both directions: documented but never emitted fails the build, and so does emitted but not written down. Severity mismatches fail too.

    Two self-test fixtures. The first has 11 planted defect classes and asserts both the code set and the finding counts. The second is a CDD with the CAN tab left empty — it asserts that CDX-013/CDX-025 fire and that CDX-010/011/012/020/021/022 do not, because "no comparable attributes" must not be reported as "attributes disagree".

    Checked against two unrelated tier-1 supplier projects. The second one is what found the silent-skip bug: its CDD was a template save with an empty CAN page, and the first report came back looking clean.

    Zero dependencies, MIT licensed, no network calls, no telemetry, read-only. Source and issue tracker: https://github.com/autosar-skills/autosar-agent-skills

    No DID bit-field or structure audit. Ignores security algorithms and NRC triggers. Cannot run with only one file. Requires Python 3.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 11 days ago

    • Free with an Agensi account

    Requires

    Python 3.8+
    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Listed11 days ago

    What's inside

    Frequently Asked Questions

    This skill automatically audits CANdelaStudio (CDD) and AUTOSAR (ARXML) files to identify mismatches in CAN IDs, DIDs, DTCs, and timing parameters before you flash an ECU. It solves the common issue of diagnostic communication failures or 'Request Out of Range' errors caused by misaligned specification and configuration files.

    The skill is designed for AUTOSAR Classic stacks and requires a standard Vector CANdelaStudio CDD file and a valid AUTOSAR ARXML file. It supports various encodings including UTF-8, GB18030, and latin-1, making it compatible with global automotive projects.

    Unlike generic AI models that struggle with large, complex XML schemas, this skill uses a specialized audit engine to accurately parse multi-megabyte files. It provides specific 'CDX-xxx' error codes and remediation steps rather than vague summaries, ensuring hardware-level accuracy.

    Upon purchase, you receive the specialized diagnostic audit engine, access to the automated 25-point consistency check, and the ability to export CSV inventory matrices. The package includes documentation on interpreting the error codes and prioritizing the 'source of truth' during remediation.

    This skill focuses on high-level diagnostic consistency (IDs, DIDs, and service availability) and does not perform bit-level structure comparisons of data lengths or audit security access algorithms. It requires both a CDD and an ARXML file to be present to function correctly.

    New in Code Quality & Review