dbcc
1.0.0
Este programa transforma um arquivo DBC em vários formatos diferentes.
O CAN-FD atualmente não é suportado .
Por favor, considere doar para o projeto se achar útil. Este projeto exige que seu apoio continue. Se você precisar de suporte pago, entre em contato com o e -mail: [email protected].
Como você pode ver pela grande nota acima, o Can-FD atualmente não é suportado e provavelmente não (por um tempo). O problema é que o CAN-FD permite mensagens acima de 64 bits de comprimento e este projeto e o código gerado a partir dele assumem que é tudo pretendido que uma mensagem pode ter nele.
O DBCC é um programa para converter um arquivo DBC principalmente em código C que pode serializar e desserializar mensagens podem em estruturas que representam essas mensagens e sinais. Também é possível imprimir as informações contidas em uma estrutura.
Consulte o arquivo de licença para obter detalhes da licença para este programa, ele é liberado sob a licença do MIT. As dependências, se vinculadas, podem ter sua própria licença e seu próprio conjunto de restrições, se construídas.
O arquivo de fontes mpc.c e mpc.h são originários de um combinador de analisador escrito em C chamado MPC e são licenciados sob a Licença BSD de 3 cláusula.
Para construir, você só precisa de um compilador C (C99) e fazer (provavelmente o GNU faz, não faço nenhum esforço para apoiar outras implementações de fazer). O próprio programa DBCC foi escrito no que deve ser portátil C, com a única dependência externa sendo sua biblioteca C Plataformas.
Você deve ser capaz de digitar:
make
Para construir, um executável chamado 'DBCC' é produzido. Para testar os testes, o XMLLINT é necessário.
-n pode ser usada para especificar a versão de saída que pode dar acesso ao comportamento anterior se a compatibilidade com versões anteriores tiver sido implementada. Você pode especificar a versão a ser usada em uma linha de comando com a opção -n . A versão mais recente será usada por padrão.
Versão 1:
Legado/comportamento original. Observe que isso ainda não fornecerá uma saída estável, mas terá uma chance melhor de não ter mudanças de quebra.
Versão 2:
Versão mais recente
Os nomes de enum são qualificados com o nome da mensagem CAN
Os nomes de funções de codificação/decodificação também são qualificados com o nome da mensagem
O gerador de código pode criar código para descompactar uma mensagem (transforme alguns bytes em uma estrutura de dados), decodificar uma mensagem (aplique um mínimo e os valores máximos de escala/deslocamento nos valores nos valores em uma estrutura de dados) e o inverso pode ser feito (pacote/codificação).
Você pode observar o código gerado a partir dos arquivos DBC no projeto para entender como ele deve funcionar.
Se você deseja processar uma mensagem pode que você recebeu, precisará chamar o 'Unppack_Message'. O código gerado é agnóstico à ordem de byte CPUS, é necessário um valor 'uint64_t' que contém um único pacote pode (junto com o ID CAN e o DLC para o pacote) e descompacta -o em uma estrutura que ele gera. O primeiro byte do pacote CAN deve ser colocado no byte menos significativo do 'uint64_t'.
Você pode usar as seguintes funções para converter para/a partir de uma mensagem 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;
}
O gerador de código fará uma estrutura com base no nome do arquivo do arquivo DBC; portanto, para o exemplo do arquivo dbc 'ex1.dbc', uma estrutura de dados chamada 'can_obj_ex1_h_t' é feita. Essa estrutura contém todas as estruturas de mensagem CAN, que por sua vez contêm todos os sinais. Ter todas as mensagens/sinais em uma estrutura tem vantagens e desvantagens, uma das coisas que facilita é definir as estruturas de dados necessárias.
/* 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;
}
'Unplack_message' chama a função de descompacção correta para esse ID, como um exemplo para ID '0x020':
case 0x020: return unpack_can_0x020_MagicCanNode1RBootloaderAddress(&o->can_0x020_MagicCanNode1RBootloaderAddress, data, dlc);
A função Unplack preenche o objeto de mensagem na estrutura 'can_obj_ex1_h_t' para esse id. Os sinais individuais podem ser decodificados com as funções apropriadas para esse sinal. Por exemplo:
uint16_t b = 0;
if (decode_can_0x020_MagicNode1R_BLAddy(o, &b)) {
/* error */
}
Para transmitir uma mensagem, cada sinal deve ser codificado, a função da embalagem retornará uma mensagem embalada.
Algumas outras notas:
Para uma especificação, como eu entendo, do formato de arquivo DBC, consulte DBC.MD. Este é um trabalho em andamento.
Há um arquivo de sintaxe do VIM para arquivos DBC no projeto, chamado dbc.vim
Além de C, o XML pode ser gerado, o projeto contém um arquivo XSD e XSLT para o XML gerado.
Um arquivo baseado em XML que pode ser importado para além do Security da Security e usado para testar a infraestrutura de barramento CAN.
Um arquivo CSV plano pode ser gerado, o que é mais fácil de importar para o Excel.
Um arquivo JSON pode ser gerado, que é o que todas as crianças legais usam hoje em dia.
Consulte a página manual para obter mais informações sobre a operação precisa do programa.
Seria possível gerar imagens agradáveis (ASCII ART) que mostram como uma mensagem é estruturada, o que ajuda a entender a mensagem em questão e é útil para fins de documentação, por exemplo, algo 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 ...
Ou algo semelhante. Este seria outro módulo de saída.
<style type = "text/css"> corpo {margem: 40px automático; max-lar-letra: 850px; altura da linha: 1.6; tamanho da fonte: 16px; cor:#444; preenchimento: 0 10px} h1, h2, h3 {line-hight: 1.2} </estilo>
