dbcc
1.0.0
Ce programme transforme un fichier DBC en un certain nombre de formats différents.
CAN-FD n'est actuellement pas pris en charge .
Veuillez envisager de faire un don au projet si vous le trouvez utile. Ce projet nécessite que votre soutien se poursuive. Si vous avez besoin d'un support payant, veuillez contacter MailTo: [email protected].
Comme vous pouvez le voir par la grande note ci-dessus, Can-FD n'est actuellement pas pris en charge et ne le fera probablement pas (pendant un certain temps). Le problème est que CAN-FD permet des messages supérieurs à 64 bits et ce projet et le code généré à partir de celui-ci font l'hypothèse que 8 bits est tout censé avoir un message peut avoir.
DBCC est un programme de conversion d'un fichier DBC principalement en code C qui peut sérialiser et désérialiser les messages en structures qui représentent ces messages et signaux. Il est également possible d'imprimer les informations contenues dans une structure.
Voir le fichier de licence pour plus de détails sur la licence pour ce programme, il est publié sous la licence MIT. Les dépendances, si elles sont liées, peuvent avoir leur propre licence et leur propre ensemble de restrictions si elles sont construites contre.
Le fichier de sources MPC.C et MPC.H provient d'un combinateur d'analyse écrit en C appelé MPC et sont concédés sous licence de 3 clause BSD.
Pour construire, vous n'avez besoin que d'un compilateur C (C99) et de faire (probablement GNU faire, je ne fais aucun effort pour soutenir d'autres implémentations). Le programme DBCC lui-même a écrit dans ce qui devrait être portable C avec la seule dépendance externe étant votre bibliothèque C Plateforme C.
Vous devriez pouvoir taper:
make
Pour construire, un exécutable appelé «DBCC» est produit. Pour tester les tests, Xmllint est requis.
-n peut être utilisée pour spécifier la version de sortie qui pourrait vous donner accès au comportement précédent si la compatibilité en arrière a été implémentée. Vous pouvez spécifier la version à utiliser sur une ligne de commande avec l'option -n . La dernière version sera utilisée par défaut.
Version 1:
Héritage / comportement original. Notez que cela ne fournira toujours pas une sortie stable, mais aura de meilleures chances de ne pas avoir de changements de rupture.
Version 2:
Dernière version
Les noms d'énumération sont qualifiés avec le nom du message CAN
Les noms de fonction Encode / Decode sont également qualifiés avec le nom du message
Le générateur de code peut faire du code pour déballer un message (transformer certains octets en structure de données), décoder un message (appliquer une mise à l'échelle / offset des valeurs minimales et maximales aux valeurs d'une structure de données), et l'inverse peut être effectué (pack / encode).
Vous pouvez consulter le code généré à partir des fichiers DBC dans le projet pour comprendre comment il devrait fonctionner.
Si vous souhaitez traiter un message CAN que vous avez reçu, vous devrez appeler le «Unpack_Message». Le code Génération est agnostique à l'ordre des octets CPU, il faut une valeur 'uint64_t' contenant un seul paquet CAN (avec l'ID CAN et le DLC pour le paquet de ce paquet) et décortient cela dans une structure qu'il génère. Le premier octet du paquet CAN doit être placé dans l'octet le moins significatif du «Uint64_t».
Vous pouvez utiliser les fonctions suivantes pour vous convertir vers / à partir d'un message CAN:
static uint64_t u64_from_can_msg(const uint8_t m[8]) {
return ((uint64_t)m[7] << 56) | ((uint64_t)m[6] << 48) | ((uint64_t)m[5] << 40) | ((uint64_t)m[4] << 32)
| ((uint64_t)m[3] << 24) | ((uint64_t)m[2] << 16) | ((uint64_t)m[1] << 8) | ((uint64_t)m[0] << 0);
}
static void u64_to_can_msg(const uint64_t u, uint8_t m[8]) {
m[7] = u >> 56;
m[6] = u >> 48;
m[5] = u >> 40;
m[4] = u >> 32;
m[3] = u >> 24;
m[2] = u >> 16;
m[1] = u >> 8;
m[0] = u >> 0;
}
Le générateur de code fera une structure basée sur le nom de fichier du fichier DBC, donc pour l'exemple de fichier DBC 'ex1.dbc' Une structure de données appelée 'can_obj_ex1_h_t' est réalisée. Cette structure contient toutes les structures de message CAN, qui à leur tour contiennent tous les signaux. Avoir tous les messages / signaux dans une seule structure a des avantages et des inconvénients, l'une des choses que cela facilite est de définir les structures de données nécessaires.
/* reminder of the 'unpack_message' prototype */
int unpack_message(can_obj_ex1_h_t *o, const unsigned long id, uint64_t data, uint8_t dlc);
static can_obj_ex1_h_t ex1;
uint8_t can_message_raw[8];
unsigned long id = 0;
uint8_t dlc = 0;
your_function_to_receive_a_can_message(can_message_raw, &id, &dlc);
if (unpack_message(&ex1, id, can_message_u64, dlc) < 0) {
// Error Condition; something went wrong
return -1;
}
«Detepack_Message» appelle la fonction de déballage correcte pour cet ID, comme exemple pour l'ID «0x020»:
case 0x020: return unpack_can_0x020_MagicCanNode1RBootloaderAddress(&o->can_0x020_MagicCanNode1RBootloaderAddress, data, dlc);
La fonction de déballage remplit l'objet de message dans la structure 'can_obj_ex1_h_t' pour cet ID. Les signaux individuels peuvent ensuite être décodés avec les fonctions appropriées pour ce signal. Par exemple:
uint16_t b = 0;
if (decode_can_0x020_MagicNode1R_BLAddy(o, &b)) {
/* error */
}
Pour transmettre un message, chaque signal doit être codé, puis la fonction du pack renverra un message emballé.
Quelques autres notes:
Pour une spécification, si je le comprends, du format de fichier DBC, voir dbc.md. Ceci est un travail en cours.
Il existe un fichier de syntaxe VIM pour les fichiers DBC dans le projet, appelé dbc.vim
En plus de C, XML peut être généré, le projet contient un fichier XSD et XSLT pour le XML généré.
Un fichier basé sur XML qui peut être importé dans Beyond Security's Bestorm et utilisé pour tester l'infrastructure BUS.
Un fichier CSV plat peut être généré, ce qui est plus facile à importer dans Excel.
Un fichier JSON peut être généré, ce que tous les enfants cool utilisent de nos jours.
Consultez la page manuelle pour plus d'informations sur le fonctionnement précis du programme.
Il serait possible de générer de belles images (ASCII Art) qui montrent comment un message est structuré, ce qui aide à comprendre le message en question, et est utile à des fins de documentation, par exemple, quelque chose comme:
Message Name: Example-1
Message ID: 0x10, 16
DLC: 1 (8-bits)
+-----+-----.-----.-----.-----+-----.-----+-----+
| | | | |
| | | | |
+-----+-----.-----.-----.-----+-----.-----+-----+
0 1 2 3 4 5 6 7
Bit 0: Signal-Name-1, 1 bit signal, scalar 1.0, offset 0
Bits 1-2: Signal-Name-2, 4 bit signal, signed, Motorola, ...
... etcetera ...
Ou quelque chose de similaire. Ce serait un autre module de sortie.
<style type = "Text / CSS"> Body {margin: 40px auto; max-width: 850px; line-height: 1.6; Font-Size: 16px; couleur: # 444; padding: 0 10px} h1, h2, h3 {line-height: 1,2} </ / /
