Automatisation et intégration continue

La ligne de commande arnodiqa utilise le même moteur et les mêmes fichiers de projet que l'application de bureau. Elle est destinée aux bancs de test sans écran, aux exécutions nocturnes et aux pipelines d'intégration continue (CI). Chaque commande renvoie un code de sortie documenté et, avec --json, un rapport exploitable par d'autres outils.

CLUF et licence sur les agents de build

À la première utilisation, Arnodiqa demande d'accepter le contrat de licence utilisateur final (CLUF). Sur un agent de build sans interaction, utilisez --accept-eula ou la variable d'environnement ARNODIQA_ACCEPT_EULA=yes ; l'acceptation est enregistrée une seule fois en local. Pour une installation silencieuse, transmettez ARNODIQA_ACCEPT_EULA=yes à msiexec /qn ou à setup.exe /S ; l'acceptation vaut alors pour toute la machine. arnodiqa license eula affiche le texte hors ligne.

Déposez le fichier de licence dans le dossier de licences de la machine ou indiquez-le avec ARNODIQA_LICENSE_FILE, par exemple sous forme de montage en lecture seule dans un conteneur.

CI agent

export ARNODIQA_ACCEPT_EULA=yes
export ARNODIQA_LICENSE_FILE=/licences/site.arnlic
arnodiqa license show --json

Exécuter un projet

L'application de bureau est livrée sous forme d'installateur Windows, qui s'installe et fonctionne sans connexion Internet. Les exemples ne nécessitent aucun matériel. Sans fichier de licence, Arnodiqa fonctionne 30 jours avec toutes les fonctions.

1. Valider un projet

arnodiqa validate

$ arnodiqa validate examples/demo/demo.yaml
ok

2. Exécuter une mesure

Le projet de démonstration comporte deux réseaux CAN virtuels (PowerTrain en CAN FD, Comfort en CAN). La couche d'interaction simule tous les nœuds des deux fichiers DBC. La mesure s'exécute sur le bus simulé, donc aussi vite que le processeur le permet.

arnodiqa run

$ arnodiqa run examples/demo/demo.yaml --duration 2s
measurement #3: 2.000000 s, 990 events, stop: Duration

channel  frames      rx      tx  err  fps(last s)  load%   peak%  state
CAN1        920       0     920    0          460   14.2    14.2  ErrorActive
CAN2         70       0      70    0           35    0.8     0.8  ErrorActive

channel  id            count  cycle avg/min/max [ms]
CAN1    400             400  4.998/4.002/5.998
CAN1    100             200  9.999/9.496/10.504
CAN1    210             200  10.000/9.500/10.500
CAN1    1A0             100  19.989/18.865/20.252
CAN2    320              40  50.000/49.536/50.464
CAN1    300              20  99.987/99.750/100.000
CAN2    321              20  99.987/99.708/100.292
CAN2    18FF1E01x        10  199.953/199.580/200.000

logging:
  Logging: 990 events, 0 lost
    examples\demo\logs\Demo_3.blf
  HighRpmLog: 94 events, 0 lost
    examples\demo\logs\high_rpm_003.asc

L'index de mesure (#3) est conservé hors du projet, dans demo.state.yaml. Le fichier de projet ne change donc pas à chaque exécution et le dépôt git reste propre.

3. En CI : rapport JSON

Avec --json, le rapport complet est écrit sur stdout sous la forme d'un seul objet JSON (mis en forme ici pour la lecture). Les temps sont exprimés en nanosecondes.

arnodiqa run --json

$ arnodiqa run examples/demo/demo.yaml --duration 2s --json | jq .
{
  "exitCode": 0,
  "report": {
    "duration": 2000000000,
    "events": 990,
    "lateEvents": 0,
    "logging": [
      {
        "error": null,
        "eventsWritten": 990,
        "files": [
          "examples\\demo\\logs\\Demo_4.blf"
        ],
        "id": "Logging",
        "lost": 0,
        "preTriggerOverflow": 0,
        "sysvarsWritten": 0
      },
      {
        "error": null,
        "eventsWritten": 94,
        "files": [
          "examples\\demo\\logs\\high_rpm_004.asc"
        ],
        "id": "HighRpmLog",
        "lost": 0,
        "preTriggerOverflow": 0,
        "sysvarsWritten": 0
      }
    ],
    "mainQueueDropped": 0,
    "measurementIndex": 4,
    "messages": [],
    "statistics": {
      "channels": [
        {
          "busloadMeasured": true,
          "busloadPeakPercent": 14.1834,
          "busloadPercent": 14.1832,
          "channel": 1,
          "chipState": "errorActive",
          "errorFrames": 0,
          "errorFramesPerSec": 0.0,
          "extData": 0,
          "extRemote": 0,
          "fdFrames": 400,
          "frames": 920,
          "framesPerSec": 460.0,
          "rec": 0,
          "recPeak": 0,
          "rx": 0,
          "rxOverruns": 0,
          "stdData": 920,
          "stdRemote": 0,
          "tec": 0,
          "tecPeak": 0,
          "tx": 920,
          "txQueueOverflows": 0,
          "txRequests": 0
        },
        {
          "busloadMeasured": true,
          "busloadPeakPercent": 0.814,
          "busloadPercent": 0.814,
          "channel": 2,
          "chipState": "errorActive",
          "errorFrames": 0,
          "errorFramesPerSec": 0.0,
          "extData": 10,
          "extRemote": 0,
          "fdFrames": 0,
          "frames": 70,
          "framesPerSec": 35.0,
          "rec": 0,
          "recPeak": 0,
          "rx": 0,
          "rxOverruns": 0,
          "stdData": 60,
          "stdRemote": 0,
          "tec": 0,
          "tecPeak": 0,
          "tx": 70,
          "txQueueOverflows": 0,
          "txRequests": 0
        }
      ],
      "eventsTotal": 990,
      "ids": [
        {
          "channel": 1,
          "count": 200,
          "cycleAvg": 9998723.618090453,
          "cycleLast": 9748000,
          "cycleMax": 10504000,
          "cycleMin": 9496000,
          "dlc": 8,
          "id": "0x100",
          "lastTime": 1990488000,
          "minSendDistance": 9258000
        },
        {
          "channel": 1,
          "count": 100,
          "cycleAvg": 19988535.353535354,
          "cycleLast": 20000000,
          "cycleMax": 20252000,
          "cycleMin": 18865000,
          "dlc": 8,
          "id": "0x1A0",
          "lastTime": 1980242000,
          "minSendDistance": 18623000
        },
        {
          "channel": 1,
          "count": 200,
          "cycleAvg": 10000000.0,
          "cycleLast": 9752000,
          "cycleMax": 10500000,
          "cycleMin": 9500000,
          "dlc": 8,
          "id": "0x210",
          "lastTime": 1990244000,
          "minSendDistance": 9256000
        },
        {
          "channel": 1,
          "count": 20,
          "cycleAvg": 99986842.10526316,
          "cycleLast": 100000000,
          "cycleMax": 100000000,
          "cycleMin": 99750000,
          "dlc": 8,
          "id": "0x300",
          "lastTime": 1900246000,
          "minSendDistance": 99504000
        },
        {
          "channel": 1,
          "count": 400,
          "cycleAvg": 4998125.313283208,
          "cycleLast": 4506000,
          "cycleMax": 5998000,
          "cycleMin": 4002000,
          "dlc": 15,
          "id": "0x400",
          "lastTime": 1995381000,
          "minSendDistance": 3621000
        },
        {
          "channel": 2,
          "count": 40,
          "cycleAvg": 50000000.0,
          "cycleLast": 49828000,
          "cycleMax": 50464000,
          "cycleMin": 49536000,
          "dlc": 8,
          "id": "0x320",
          "lastTime": 1950242000,
          "minSendDistance": 49294000
        },
        {
          "channel": 2,
          "count": 20,
          "cycleAvg": 99986947.36842105,
          "cycleLast": 99708000,
          "cycleMax": 100292000,
          "cycleMin": 99708000,
          "dlc": 4,
          "id": "0x321",
          "lastTime": 1900166000,
          "minSendDistance": 99542000
        },
        {
          "channel": 2,
          "count": 10,
          "cycleAvg": 199953333.33333334,
          "cycleLast": 200000000,
          "cycleMax": 200000000,
          "cycleMin": 199580000,
          "dlc": 8,
          "id": "0x18FF1E01x",
          "lastTime": 1800286000,
          "minSendDistance": 199294000
        }
      ],
      "time": 2000000000
    },
    "stopReason": "duration",
    "txFailed": 0
  }
}

4. Hors ligne : analyser à nouveau un fichier journal

shell

arnodiqa run examples/demo/demo.yaml --offline examples/demo/logs/Demo_1.blf

Les fichiers journaux remplacent les sources du projet. Les filtres, les déclencheurs et les blocs de journalisation se comportent exactement comme en ligne.

Commandes

arnodiqa --help

arnodiqa headless measurement runner

Usage: arnodiqa.exe <COMMAND>

Commands:
  run       Run a measurement and print statistics
  validate  Check a project for errors
  schema    Print the JSON Schema of project files
  capl      CAPL tools
  convert   Convert a log file between ASC, BLF, MF4 and PCAPNG (formats from the extensions)
  export    Decode a log file with databases and export the signals as CSV, MATLAB (.mat) or Parquet
  stats     Print the contents of a log file: duration, counts per channel and identifier
  hw        Hardware interfaces
  db        Database tools for DBC, LDF and ARXML: lint, diff, convert, info
  test      Run the test units (`*.vtestunit.yaml`) or CAPL test modules of a project in the simulated bus and write reports. Exit code by verdict
  flash     Flash an ECU with its flash program (`diagnostics.ecus[].flash`): Intel HEX, S-record, binary or ODX-F/PDX. Exit code and JSON report for CI and the production line
  support   Support: bundle with logs and system information, system info, log folder
  license   Licence: status, install a licence file, machine fingerprint, EULA
  help      Print this message or the help of the given subcommand(s)

Options:
      --accept-eula  Accept the EULA on behalf of your company (recorded once; for CI also ARNODIQA_ACCEPT_EULA=yes). Read it with `arnodiqa license eula`
  -h, --help         Print help
  -V, --version      Print version

Commande	Rôle
`run`	Exécuter une mesure (en ligne, hors ligne ou simulée), statistiques et fichiers journaux
`validate`, `schema`	Contrôler un projet ; schéma JSON des fichiers de projet
`test`	Exécuter les unités de test et les modules de test CAPL, écrire les rapports
`capl check`, `capl lsp`	Compiler un programme CAPL et afficher les diagnostics ; serveur de langage pour éditeurs
`hw list`, `hw selftest`	Back-ends de pilotes, état et canaux connectés ; autotest d'une interface
`flash`	Flasher un calculateur via UDS, avec rapport JSON
`license`	État de la licence, installation d'un fichier de licence, empreinte machine, CLUF
`support`	Paquet de support, informations système et dossier des journaux
`stats`, `convert`	Résumer un fichier journal ; convertir entre ASC, BLF, MF4 et PCAPNG
`export`	Exporter des signaux en CSV, MATLAB ou Parquet
`db`	Contrôler, comparer, convertir et résumer des bases de données (DBC, LDF, ARXML)

`arnodiqa run <PROJECT>`

Option	Signification
`--duration <SPAN>`	Arrêt après cette durée de mesure (par exemple `10s`, `500ms`, `2min`). Sans cette option, une mesure en ligne tourne jusqu'à Ctrl+C.
`--offline <FILE>`	Mode hors ligne avec ces fichiers journaux (répétable) ; remplace les sources du projet.
`--simulated`	Bus simulé (sans matériel).
`--real-bus`	Bus réel (matériel ou réseaux virtuels cadencés sur l'horloge réelle).
`--without-logging`	Démarrage avec tous les blocs de journalisation désactivés.
`--timeout <SPAN>`	Limite de sécurité en temps réel pour toute l'exécution ; si elle est atteinte, le code de sortie est 6.
`--start-time <ISO8601>`	Heure de début fixe pour les en-têtes des fichiers journaux et `{MeasurementStart}`, afin d'obtenir des fichiers reproductibles.
`--top-ids <N>`	Nombre d'identifiants affichés dans les statistiques (20 par défaut).
`-q, --quiet`	Uniquement les erreurs et la ligne de synthèse.
`--json`	Rapport JSON sur stdout : `{"exitCode": n, "report": {…}}` ou `{"exitCode": n, "error": "…"}`.

Un projet avec des nœuds CAPL s'exécute de la même manière. Les messages des nœuds s'affichent avec leur temps de mesure avant le rapport.

arnodiqa run

$ arnodiqa run examples/demo/capl_demo.yaml --duration 2s
[    0.000000] info: CaplGateway: gateway PowerTrain -> Comfort active
[    0.000000] info: ParkAssist: park assist started
[    1.000000] info: CaplGateway: 100 frames routed, last speed 800 rpm
[    2.000000] info: CaplGateway: id 0x100 seen 200 times
[    2.000000] info: CaplGateway: id 0x210 seen 200 times
measurement #3: 2.000000 s, 1209 events, stop: Duration

channel  frames      rx      tx  err  fps(last s)  load%   peak%  state
CAN1        939       0     939    0          470   14.4    14.4  ErrorActive
CAN2        270       0     270    0          135    2.5     2.5  ErrorActive
…

`arnodiqa validate <PROJECT>` · `arnodiqa schema`

validate contrôle le modèle YAML, charge ensuite les bases de données et les références de blocs via le moteur, puis affiche ok ou la liste des problèmes. schema affiche le schéma JSON des fichiers de projet.

Codes de sortie de `run`

Code	Signification
0	La mesure s'est exécutée et s'est arrêtée normalement
1	La mesure s'est exécutée, mais un bloc de journalisation a signalé une erreur
2	Ligne de commande invalide
3	Projet impossible à charger ou incohérent
4	La mesure n'a pas pu démarrer ou a échoué en cours d'exécution
5	La mesure s'est exécutée, mais des événements ont été perdus (surcharge ou file de journalisation pleine)
6	`--timeout` atteint ; le rapport et les fichiers journaux sont complets jusqu'à ce moment
130	Arrêt par Ctrl+C (après un arrêt propre, avec rapport et journaux fermés) ; un second Ctrl+C quitte immédiatement

`arnodiqa test <PROJECT>`

Exécute les unités de test (*.vtestunit.yaml) ou les modules de test CAPL d'un projet sur le bus simulé. Chaque unité tourne dans sa propre mesure, avec les nœuds de simulation, le bus résiduel et un nœud de test. Le temps simulé avance aussi vite que le PC le permet : une attente de 1 s dure moins d'une seconde réelle, et deux exécutions produisent des rapports identiques.

arnodiqa test

$ arnodiqa test examples/demo/capl_demo.yaml --html report.html --junit junit.xml --report report.json
running Demo ...
Demo [test unit] PASS
  PASS         T-1 EngineData cycle time
  PASS         T-2 Cycle time 256 in [9, 11] ms
  PASS         T-2 Cycle time 416 in [18, 22] ms
  PASS         T-2 Cycle time 528 in [9, 11] ms
  PASS         T-3 Park assist / Mode request 1
  PASS         T-3 Park assist / Mode request 2
  PASS         T-4 Park assist / Mode Off stops the status frame
  PASS         T-5 Speed limit ramp (stimulus)
verdict PASS: 1 test unit(s), 8 test case(s): 8 passed, 0 failed, 0 inconclusive, 0 error, 0 skipped
$ echo $?
0

Option	Signification
`--unit <UNIT>`	Unité par nom, fichier `.vtestunit.yaml` ou module de test CAPL (`.can`) ; répétable. Par défaut : toutes les unités du projet.
`--variant <NAME=VALUE>`	Valeur d'une propriété de variante (répétable).
`--report`, `--junit`, `--html <FILE>`	Rapport au format JSON, JUnit XML ou HTML. Le rapport HTML est une page autonome unique, sans scripts.
`--max-time <SPAN>`	Durée de mesure maximale par unité (1 heure de temps simulé par défaut).
`--real-bus`	Utilise le mode de fonctionnement (working mode) du projet au lieu du bus simulé.
`--json`, `-q`	Rapport JSON sur stdout ; synthèse uniquement.

Code de sortie	Signification
0	Tous les cas de test exécutés ont réussi
1	Au moins un cas de test a échoué
2	Ligne de commande invalide
3	Projet, unité de test ou arborescence de tests impossible à charger, ou aucune unité trouvée
4	Erreur dans le système de test (erreur de compilation, erreur d'exécution, unité non terminée)
5	Pire verdict : inconclusive
8	Aucun cas de test exécuté

`arnodiqa capl check <FILE>`

Compile un programme CAPL et affiche les diagnostics au format fichier:ligne:colonne: gravité code: message. Avec --project, le compilateur utilise les bases de données et les variables système du projet ; sans projet, les messages et les variables système sont inconnus. --json fournit les diagnostics en JSON pour les éditeurs. Le code de sortie est 0 sans erreur, 1 en cas d'erreurs et 3 si le projet ne peut pas être chargé.

arnodiqa capl check

$ arnodiqa capl check examples/demo/capl/gateway.can --project examples/demo/capl_demo.yaml
examples/demo/capl/gateway.can: 0 error(s), 0 warning(s)
$ arnodiqa capl check examples/demo/capl/gateway.can
examples/demo/capl/gateway.can:21:12: error E1012: unknown message 'EngineData'
examples/demo/capl/gateway.can:31:12: error E1012: unknown message 'WheelSpeeds'
examples/demo/capl/gateway.can:36:1: error E1013: unknown system variable 'Demo::Mode'
examples/demo/capl/gateway.can: 3 error(s), 0 warning(s)
$ echo $?
1

Autres options : --db (fichiers DBC supplémentaires), -I (chemins d'inclusion), --node (valeur de %NODE_NAME%), --allow-undeclared-sysvars.

`arnodiqa hw list`

Indique, pour chaque back-end de pilote, si la bibliothèque du fabricant a été trouvée et quels périphériques et canaux sont connectés. Une bibliothèque absente n'est pas une erreur ; le back-end est alors signalé comme « not found ». L'option --json produit une sortie pour les scripts.

arnodiqa hw list

$ arnodiqa hw list
virtual    Virtual CAN bus (in-process) found, 8 channels
             Virtual CAN Bus (serial VIRTUAL, 8 channels)
pcan       not found: PCANBasic.dll is missing (LoadLibraryExW failed)
vector-xl  not found: vxlapi64.dll is missing (LoadLibraryExW failed)
kvaser     not found: canlib32.dll is missing (LoadLibraryExW failed)
socketcan  not available on this operating system
slcan      SLCAN (serial) found, 2 channels
             COM4 (serial COM4, 1 channel)
             COM5 (serial COM5, 1 channel)
gs_usb     gs_usb / candleLight found, 0 channels

Sortie sur un PC Windows sans pilotes PEAK, Vector ni Kvaser installés. Affectation des canaux dans le projet : hardware: {pcan: {channel: PCAN_USBBUS1}}, {vector: {app: arnodiqa, channel: 1}}, {kvaser: {serial: …, channel: 0}}, {socketcan: {interface: can0}}, {slcan: {port: COM5}}, {gs_usb: {channel: 0}}.

arnodiqa hw selftest teste une nouvelle interface avec deux canaux sur un même bus (--pair), un canal en boucle interne (--channel) ou deux canaux LIN (--lin-pair), et produit un rapport JSON ou HTML.

`arnodiqa flash <PROJECT> --ecu <ECU>`

Flashe un calculateur (ECU) avec le programme de flashage défini dans le projet (diagnostics.ecus[].flash). Le firmware peut être fourni en Intel HEX, Motorola S-record, fichier binaire (avec --base) ou ODX-F/PDX (--odx-session). Sans étapes personnalisées, la séquence standard s'applique : session étendue, désactivation du DTC setting et de la communication, session de programmation, security access, empreinte (fingerprint), puis effacement, téléchargement et vérification par segment, et enfin reset de l'ECU. En cas d'erreur ou d'annulation, un reset de l'ECU est effectué.

arnodiqa flash

arnodiqa flash project.yaml --ecu DoorECU --file door_v2.hex --report flash.json
arnodiqa flash project.yaml --ecu DoorECU --file door.bin --base 0x80000 --var fingerprint=261015000000000001
arnodiqa flash project.yaml --ecu DoorECU --file door.pdx --odx-session APP --simulated --json

Autres options : --format ihex|srec|bin|odx, --timeout (code de sortie 6 en cas de dépassement), --real-bus, -q. Avec --simulated, c'est la simulation d'ECU du projet qui répond ; un programme de flashage peut ainsi être vérifié sans matériel.

`arnodiqa support bundle | info | logs`

Crée un paquet de support (zip) contenant les informations système, la version et les paramètres, la liste du matériel, les journaux récents et les rapports de plantage. Les noms d'utilisateur, le nom d'hôte et les numéros de série sont anonymisés. Les clés, les données de bus et les sources CAPL n'y figurent jamais. Rien n'est envoyé. --dry-run affiche au préalable le contenu du paquet.

arnodiqa support

arnodiqa support bundle --since 7d --out support.zip
arnodiqa support bundle --include-project project.yaml --dry-run
arnodiqa support info
arnodiqa support logs

Sous Windows, les journaux se trouvent dans %LOCALAPPDATA%\Arnodiqa\logs ; sous Linux, dans ~/.local/state/arnodiqa/logs. Le niveau de journalisation se règle avec ARNODIQA_LOG ou dans diagnostics.json, et dans l'application via Help.

`arnodiqa export --db <[CH:]FILE> <INPUT> <OUTPUT>`

Décode un fichier journal (ASC, BLF, MF4 ou PCAPNG) avec des bases de données DBC ou LDF et exporte les signaux en CSV, MATLAB (.mat) ou Parquet. Avec le préfixe CANAL:, une base de données ne s'applique qu'à ce canal. La disposition wide (par défaut) produit une table par message ; long produit une seule table avec une ligne par valeur de signal (temps, canal, message, signal, valeur, unité, texte).

arnodiqa export

$ arnodiqa export --db 1:powertrain.dbc --db 2:comfort.dbc --format csv Demo_1.blf signals
1485 frames decoded (0 without database entry) of 1485 events, 12638 signal values in 8 table(s), 0.041 s
  EngineData                              300 rows  signals\EngineData.csv
  BCM_Lights                               60 rows  signals\BCM_Lights.csv
  DCM_DoorState                            30 rows  signals\DCM_DoorState.csv
  TransmissionData                        150 rows  signals\TransmissionData.csv
  Seat_Climate                             15 rows  signals\Seat_Climate.csv
  WheelSpeeds                             300 rows  signals\WheelSpeeds.csv
  BCM_MuxInfo                              30 rows  signals\BCM_MuxInfo.csv
  PT_FD_Status                            600 rows  signals\PT_FD_Status.csv
$ head -3 signals/EngineData.csv
time,channel,EngineSpeed,CoolantTemp,OilTemp,ThrottlePos,EngineState,EngineTorque,AliveCounter,Checksum
0.000242,1,768,20,0,0,0,0,0,0
0.01024,1,768.25,20,0,0,0,0,0,0
$ arnodiqa export --db 1:powertrain.dbc --db 2:comfort.dbc --format parquet --layout long Demo_1.blf signals.parquet
1485 frames decoded (0 without database entry) of 1485 events, 12638 signal values in 1 table(s), 0.066 s
  signals                               12638 rows  signals.parquet

Format	wide	long	Remarques
`csv`	dossier avec `<Message>.csv`	`signals.csv`	Virgule comme séparateur, point comme séparateur décimal
`mat`	struct par message	colonnes et noms de signaux	MATLAB Level 5
`parquet`	dossier avec `<Message>.parquet`	`signals.parquet`	Compression Snappy, unités en métadonnées ; pour pandas, Polars, Spark et DuckDB

time est exprimé en secondes depuis le début de la mesure ; l'heure de début absolue figure dans les métadonnées. CSV et Parquet sont écrits pendant la lecture et conviennent donc aux très gros journaux. Codes de sortie : 0 succès, 2 erreur d'utilisation, 3 base de données impossible à charger, 4 erreur de lecture ou d'écriture.

`arnodiqa db lint | diff | convert | info`

Outils de bases de données pour DBC, LDF et ARXML. Pour un fichier ARXML contenant plusieurs clusters, choisissez-en un avec --cluster ; sans cette option, lint et info traitent chaque cluster séparément.

arnodiqa db info

$ arnodiqa db info system.arxml
system.arxml#PT_CAN (CAN (AUTOSAR))
  frames:        5
  signals:       24
  nodes:         3 (ECM, GW, TCM)
  value tables:  0
  bus load:      3.6 % .. 4.3 % at 500 / 2000 kbit/s (cycle times; 3 frames, 160 frames/s; bit rate from database)

system.arxml#Body_CANFD (CAN FD (AUTOSAR))
  frames:        4
  signals:       15
  nodes:         2 (BCM, GW)
  value tables:  0
  bus load:      4.2 % .. 7.5 % at 500 / 2000 kbit/s (cycle times; 3 frames, 152 frames/s; bit rate from database)

system.arxml#Door_LIN (LIN)
  frames:        6
  signals:       9
  nodes:         3 (BCM, DDM, PDM)
  value tables:  2
  schedules:     Normal, Collision_Resolve, Config
  bus load:      33.3 % .. 46.7 % at 19.2 kbit/s (schedule table Normal; 4 frames, 100 frames/s; bit rate from database)
$ arnodiqa db convert system.arxml pt_can.dbc --cluster PT_CAN
pt_can.dbc written (dbc: 5 frames, 24 signals)
$ arnodiqa db diff system.arxml pt_can.dbc --cluster-a PT_CAN
--- system.arxml#PT_CAN
+++ pt_can.dbc
no differences

arnodiqa db lint

$ arnodiqa db lint body.ldf
body.ldf:20: warning[parse-warning] frame 'F2' reuses id 0x10
body.ldf:19: warning[parse-warning] frame 'F1': signal 'B' overlaps another signal
body.ldf: error[duplicate-id] F1: identifier 0x10 used by F1, F2
body.ldf: warning[unused-signal] Orphan: signal Orphan is in no frame
body.ldf: warning[unused-value-table] encoding type Unused is not used by any signal
body.ldf: error[zero-factor] encoding TooBig: scale 0
body.ldf: warning[value-description-out-of-range] Small: encoding TooBig uses raw 9..9, signal has 2 bits
body.ldf: warning[value-description-out-of-range] Small: encoding TooBig uses raw 0..10, signal has 2 bits
body.ldf: warning[suspicious-cycle-time] schedule table Main: delay 7 ms is no multiple of the time base 5 ms
2 error(s), 7 warning(s), 2 info(s)
$ arnodiqa db lint --format github body.ldf
::warning file=body.ldf,line=20,title=parse-warning::frame 'F2' reuses id 0x10
::warning file=body.ldf,line=19,title=parse-warning::frame 'F1': signal 'B' overlaps another signal
::error file=body.ldf,title=duplicate-id::F1: identifier 0x10 used by F1, F2
…

Commande	Rôle et options	Code de sortie
`db lint <FILES>…`	Erreurs et avertissements (signaux qui se chevauchent, identifiants en double, plages, temps de cycle, tables de valeurs inutilisées, etc.). Plusieurs fichiers sont traités comme un seul réseau et sont aussi contrôlés pour les conflits d'identifiants. `--level`, `--strict`, `--format text\|json\|github`.	0 sans erreur, 1 avec erreurs (avec `--strict`, aussi en cas d'avertissements), 4 fichier impossible à charger
`db diff <A> <B>`	Différences de contenu dans les trames, les signaux et les nœuds, y compris entre formats (ARXML face à DBC).	0 identiques, 1 différences, 4 fichier impossible à charger
`db convert <IN> <OUT>`	ARXML vers DBC (cluster CAN) ou LDF (cluster LIN), ou normalisation d'un DBC/LDF. `--check` n'écrit rien et vérifie en CI qu'un fichier est normalisé ; `--cp1252` pour un DBC en Windows-1252.	avec `--check` : 1 si le fichier changerait
`db info <FILE>`	Nombre de trames, de signaux, de nœuds et de tables de valeurs, avec une estimation de la charge de bus. `--frames`, `--bitrate`.	0

`arnodiqa license show | install | fingerprint | eula | accept`

Les licences sont des fichiers signés (*.arnlic), vérifiés localement, sans connexion réseau.

Commande	Rôle
`license show`	État : type, client, fin de maintenance, évaluation (`--json`)
`license install <FILE>`	Installe un fichier de licence après vérification de sa signature ; `--system` pour tous les utilisateurs de l'ordinateur
`license fingerprint`	Empreinte de cet ordinateur, pour une licence liée à la machine
`license eula`	Affiche le CLUF (`--lang nl\|en`)
`license accept`	Accepte le CLUF au nom de l'entreprise ; `--system` pour tous les utilisateurs

`arnodiqa capl lsp` et VS Code

Le serveur de langage CAPL implémente le Language Server Protocol sur stdin/stdout et utilise le même compilateur que capl check et le démarrage de la mesure. Il fournit les diagnostics pendant la saisie, la complétion (y compris les messages, signaux et variables système du projet), le survol (hover), l'accès à la définition, le plan (outline), l'aide à la signature et les jetons sémantiques. Le serveur trouve le projet grâce au paramètre arnodiqa.project ou, à défaut, retient le projet le plus proche au-dessus du fichier.

L'extension VS Code comprend la coloration syntaxique, des snippets, le client LSP et la commande Arnodiqa: run test. Elle est livrée sous forme de fichier .vsix et s'installe sans connexion Internet :

shell

$ code --install-extension arnodiqa-capl.vsix

Les autres éditeurs utilisent arnodiqa capl lsp (ou arnodiqa-capl-lsp) comme serveur de langage ; une grammaire TextMate est disponible pour la coloration syntaxique.

Exemple : étape CI

.gitlab-ci.yml / GitHub Actions (esquisse)

export ARNODIQA_ACCEPT_EULA=yes
arnodiqa db lint --format github db/*.dbc db/*.ldf
arnodiqa validate project.yaml
arnodiqa test project.yaml --junit junit.xml --html report.html
code=$?      # 0 = pass, 1 = fail, 4 = error in test system, 8 = no test case ...
arnodiqa run project.yaml --simulated --duration 30s --json > run.json
exit $code

Formats de fichiers, `stats` et `convert`

Format	Lecture	Écriture	Détails
BLF	Oui	Oui	Objets CAN_MESSAGE(2), CAN_FD_MESSAGE(_64), trames d'erreur, erreurs de pilote et état du contrôleur, objets LIN ; conteneurs zlib ; lecture en flux à mémoire bornée ; resynchronisation sur les objets corrompus ; récupération des objets complets d'un fichier tronqué.
ASC	Oui	Oui	Variantes de CANoe 7 à 13, date EN/DE, temps absolu ou relatif, lignes CAN FD avec longueur et nombre de bits, lignes LIN, variables système (`SV:`), 6 ou 9 décimales.
DBC	Oui	Oui	UTF-8 et Windows-1252 ; mux et mux étendu, VAL_, SIG_VALTYPE_, attributs, J1939.
LDF	Oui	Oui	LIN 1.3, 2.0, 2.1, 2.2A, ISO 17987-3, SAE J2602-3.
ODX / PDX	Oui	Non	Descriptions de diagnostic (ASAM MCD-2D) pour le diagnostic symbolique et la simulation d'ECU.
MF4	Oui	Oui	ASAM MDF 4.1, journalisation de bus pour CAN, CAN FD et LIN ; compression deflate.
PCAPNG	Oui	Oui	CAN et CAN FD (type de lien SocketCAN), lisible dans Wireshark. Le LIN est ignoré et comptabilisé.
ARXML	Oui	vers DBC/LDF	AUTOSAR Classic 4.x et 3.x : CAN, CAN FD, PDU conteneurs, clusters LIN ; les propriétés E2E et SecOC sont lues. Plusieurs fichiers sont fusionnés.
CSV, MATLAB, Parquet	Non	Oui	Export de signaux, voir `arnodiqa export`.

`arnodiqa stats <FILE>`

arnodiqa stats

$ arnodiqa stats examples/demo/logs/Demo_1.blf
file:        examples/demo/logs/Demo_1.blf
format:      BLF
start:       2026-10-14 17:51:22.976
stop:        2026-10-14 17:51:25.971
objects (header): 1485
events:      1485
time span:   0.000242 .. 2.995380 s (duration 2.995138 s)
skipped:     0

channel  classic   remote       fd   errors
      1      780        0      600        0
      2      105        0        0        0

channel  id            count
      1  100             300
      1  1A0             150
      1  210             300
      1  300              30
      1  400             600
      2  320              60
      2  321              30
      2  18FF1E01x        15

read in 0.004 s (395715 events/s)

Pour un petit fichier, le temps de démarrage détermine le débit ; voir Performances pour les gros fichiers.

`arnodiqa convert <INPUT> <OUTPUT>`

arnodiqa convert

$ arnodiqa convert Demo_1.blf Demo_1.mf4
1485 events written to Demo_1.mf4 in 0.018 s (81291 events/s); 0 skipped, 0 unparsable, 0 not representable
$ arnodiqa convert Demo_1.mf4 Demo_1.pcapng
1485 events written to Demo_1.pcapng in 0.013 s (112468 events/s); 0 skipped, 0 unparsable, 0 not representable

Convertit entre ASC, BLF, MF4 et PCAPNG ; le format découle des extensions. L'heure de début et les noms des canaux sont conservés. Les événements que le format cible ne peut pas stocker (par exemple le LIN en PCAPNG) sont ignorés et comptabilisés. Avec --db, la sortie peut aussi être un fichier de signaux (.csv, .parquet, .mat). --level 0-9 règle la compression pour BLF et MF4 (6 par défaut, qui donne le plus petit fichier ; les mesures journalisent au niveau 1). --json renvoie le résultat en JSON. bf-logtool est un alias offrant les mêmes fonctions.

Automatisation et intégration continue

CLUF et licence sur les agents de build

Exécuter un projet

1. Valider un projet

2. Exécuter une mesure

3. En CI : rapport JSON

4. Hors ligne : analyser à nouveau un fichier journal

Commandes

arnodiqa run <PROJECT>

arnodiqa validate <PROJECT> · arnodiqa schema

Codes de sortie de run

arnodiqa test <PROJECT>

arnodiqa capl check <FILE>

arnodiqa hw list

arnodiqa flash <PROJECT> --ecu <ECU>

arnodiqa support bundle | info | logs

arnodiqa export --db <[CH:]FILE> <INPUT> <OUTPUT>

arnodiqa db lint | diff | convert | info

arnodiqa license show | install | fingerprint | eula | accept

arnodiqa capl lsp et VS Code