dbcc
1.0.0
Este programa convierte un archivo DBC en varios formatos diferentes.
Can-FD actualmente no es compatible .
Considere donar al proyecto si lo encuentra útil. Este proyecto requiere que su apoyo continúe. Si necesita soporte pagado, comuníquese con Mailto: [email protected].
Como puede ver con la gran nota anterior, Can-FD actualmente no es compatible y probablemente no lo hará (por un tiempo). El problema es que Can-FD permite mensajes de más de 64 bits de longitud y este proyecto y el código generado a partir de él hace que se suponga que 8 bits tiene que tener un mensaje que puede tener en él.
DBCC es un programa para convertir un archivo DBC principalmente en un código C que puede serializar y deserializar los mensajes CAN en estructuras que representan esos mensajes y señales. También es posible imprimir la información contenida en una estructura.
Consulte el archivo de licencia para obtener detalles de la licencia para este programa, se publica bajo la licencia MIT. Las dependencias, si están vinculadas, pueden tener su propia licencia y su propio conjunto de restricciones si se construyen.
El archivo de fuentes MPC.C y MPC.H se originan a partir de un combinador analizador escrito en C llamado MPC y tienen licencia bajo la licencia BSD de 3 cláusulas.
Para construir, solo necesita un compilador C (C99) y hacer (probablemente GNU Make, no hago ningún esfuerzo para apoyar otras implementaciones de fabricación). El programa DBCC mismo escrito en lo que debería ser portátil C con la única dependencia externa es su biblioteca de plataformas C.
Deberías poder escribir:
make
Para construir, se produce un ejecutable llamado 'DBCC'. Para probar las pruebas, se requiere xmllint.
-n se puede usar para especificar la versión de salida que podría darle acceso a un comportamiento anterior si se ha implementado la compatibilidad hacia atrás. Puede especificar la versión para usar en una línea de comando con la opción -n . La última versión se utilizará de forma predeterminada.
Versión 1:
Legacy/Comportamiento original. Tenga en cuenta que esto todavía no proporcionará una salida estable, pero tendrá una mejor oportunidad de no tener cambios de ruptura.
Versión 2:
Última versión
Los nombres de Enum están calificados con el nombre del mensaje de lata
Los nombres de funciones de codificación/decodificación también están calificados con el nombre del mensaje
El generador de código puede hacer que el código desempaqueta un mensaje (convierta algunos bytes en una estructura de datos), decodifique un mensaje (aplique un mínimo de escala/desplazamiento y valores máximos a los valores en una estructura de datos), y el inverso se puede hacer (empacar/codificar).
Puede ver el código generado a partir de los archivos DBC dentro del proyecto para comprender cómo debería funcionar.
Si desea procesar un mensaje de lata que ha recibido, deberá llamar al 'Desempack_Message'. El código generado es agnóstico para el orden de bytes de CPU, se necesita un valor 'uint64_t' que contenga un solo paquete de lata (junto con la ID de lata y el DLC para el paquete ese) y desactive la que genera una estructura que genera. El primer byte del paquete CAN debe colocarse en el byte menos significativo del 'uint64_t'.
Puede usar las siguientes funciones para convertir a/desde un mensaje de lata:
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;
}
El generador de código hará una estructura basada en el nombre del archivo del archivo DBC, por lo que para el archivo DBC DBC 'ex1.dbc' se hace una estructura de datos llamada 'CAN_OBJ_EX1_H_T'. Esta estructura contiene todas las estructuras de mensajes de lata, que a su vez contienen todas las señales. Tener todos los mensajes/señales en una estructura tiene ventajas y desventajas, una de las cosas que hace más fácil es definir las estructuras de datos necesarias.
/* 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;
}
'impack_message' llama a la función de desactivación correcta para esa identificación, como ejemplo para ID '0x020':
case 0x020: return unpack_can_0x020_MagicCanNode1RBootloaderAddress(&o->can_0x020_MagicCanNode1RBootloaderAddress, data, dlc);
La función de desacreditación poca el objeto de mensaje en la estructura 'can_obj_ex1_h_t' para esa ID. Las señales individuales se pueden decodificar con las funciones apropiadas para esa señal. Por ejemplo:
uint16_t b = 0;
if (decode_can_0x020_MagicNode1R_BLAddy(o, &b)) {
/* error */
}
Para transmitir un mensaje, cada señal debe codificarse, entonces la función de paquete devolverá un mensaje empaquetado.
Algunas otras notas:
Para una especificación, según lo entiendo, del formato de archivo DBC, consulte DBC.MD. Este es un trabajo en progreso.
Hay un archivo de sintaxis VIM para archivos DBC en el proyecto, llamado DBC.VIM
Además de C, se puede generar XML, el proyecto contiene un archivo XSD y XSLT para el XML generado.
Un archivo basado en XML que se puede importar más allá de la mejor forma de seguridad y utilizar para probar la infraestructura de bus de bus.
Se puede generar un archivo CSV plano, que es más fácil de importar a Excel.
Se puede generar un archivo JSON, que es lo que todos los niños geniales usan hoy en día.
Consulte la página Manual para obtener más información sobre la operación precisa del programa.
Sería posible generar imágenes agradables (arte ASCII) que muestren cómo se estructura un mensaje, lo que ayuda a comprender el mensaje en cuestión y es útil para fines de documentación, por ejemplo, algo así como:
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 ...
O algo similar. Este sería otro módulo de salida.
<style type = "text/css"> body {margen: 40px Auto; max-width: 850px; line-height: 1.6; font-size: 16px; color:#444; padding: 0 10px} h1, h2, h3 {line-age: 1.2} </yle>
