YULTek/Otarcik_CAN/Sources/CANDatabase.cpp

#include "defines.h"
#include "CANDatabase.h"
#include "kvaDbLib.h"

const char* sigEncToStr(KvaDbSignalEncoding sigEnc);
const char* sigRepToStr(KvaDbSignalType sigType);


CCANDatabase::CCANDatabase(QObject *parent) : QObject(parent)
{

}

CCANDatabase::~CCANDatabase()
{

}

int CCANDatabase::Init()
{
    return RET_OK;
}

int CCANDatabase::LoadDatabaseFile(QString Filename)
{

#define printf qDebug

   KvaDbStatus status;
   KvaDbHnd dh = 0;
   KvaDbMessageHnd mh = 0;
   KvaDbSignalHnd sh = 0;
   unsigned int flags = 0;
   char filename[] = "IVT-S_all-variations_12082020.dbc";


   // Open a database handle
   status = kvaDbOpen (&dh);
   if (status != kvaDbOK) {
     printf("Could not create a database handle: %d\n", status);
     return status;
   }

   // Load the database file
   status = kvaDbReadFile (dh, filename);
   if (status != kvaDbOK) {
     printf("Could not load '%s': %d\n", filename, status);
     return status;
   }

   status = kvaDbGetFlags(dh, &flags);
   if (status != kvaDbOK) {
     printf ("kvaDbGetFlags failed: %d\n", status);
     return status;
   }
   printf ("  Database: flags=0x%x\n", flags);


   // Get the first message in the database
   status = kvaDbGetFirstMsg (dh, &mh);
   if (status != kvaDbOK) {
     printf ("kvaDbGetFirstMsg failed: %d\n", status);
     return status;
   }

   // Go through all messages in the database
   while (status == kvaDbOK) {
     char msg_name[100];
     char msg_qname[200];
     char msg_comment[200];
     int  dlc = 0;
     unsigned int id = 0;

     // Clear the strings
     memset(msg_name,    0, sizeof(msg_name));
     memset(msg_qname,   0, sizeof(msg_qname));
     memset(msg_comment, 0, sizeof(msg_comment));

     // Get the properties for each message
     status = kvaDbGetMsgName (mh, msg_name, sizeof (msg_name));
     if (status != kvaDbOK) {
       printf ("kvaDbGetMsgName failed: %d\n", status);
       return status;
     }

     status = kvaDbGetMsgQualifiedName (mh, msg_qname, sizeof (msg_qname));
     if (status != kvaDbOK) {
       printf ("kvaDbGetMsgQualifiedName failed: %d\n", status);
       return status;
     }

     status = kvaDbGetMsgComment (mh, msg_comment, sizeof (msg_comment));
     if (status != kvaDbOK) {
       printf ("kvaDbGetMsgComment failed: %d\n", status);
       return status;
     }

     status = kvaDbGetMsgId (mh, &id, &flags);
     if (status != kvaDbOK) {
       printf ("kvaDbGetMsgId failed: %d\n", status);
       return status;
     }

     status = kvaDbGetMsgDlc (mh, &dlc);
     if (status != kvaDbOK) {
       printf ("kvaDbGetMsgDlc failed: %d\n", status);
       return status;
     }

     // Print the properties for each message
     printf ("    Msg: name='%s'\n", msg_name);
     printf ("         qname='%s', comment='%s'\n", msg_qname, msg_comment);
     printf ("         id=%x, dlc=%d, flags=%x\n", id, dlc, flags);


     // Go through all signals for this message
     status = kvaDbGetFirstSignal (mh, &sh);
     while (status == kvaDbOK) {
       char signal_name[100];
       char signal_qname[200];
       char signal_comment[200];
       char signal_unit[100];
       KvaDbSignalEncoding sigEnc;
       KvaDbSignalType sigType;
       int startbit = 0;
       int length = 0;
       double minval = 0;
       double maxval = 0;
       double factor = 0;
       double offset = 0;

       // Reset the strings
       memset(signal_name,    0, sizeof(signal_name));
       memset(signal_qname,   0, sizeof(signal_qname));
       memset(signal_comment, 0, sizeof(signal_comment));
       memset(signal_unit,    0, sizeof(signal_unit));

       // Get the properties for each signal.
       status = kvaDbGetSignalName (sh, signal_name, sizeof (signal_name));
       if (status != kvaDbOK) {
         printf ("kvaDbGetSignalName failed: %d\n", status);
         return status;
       }

       status = kvaDbGetSignalQualifiedName (sh, signal_qname, sizeof (signal_qname));
       if (status != kvaDbOK) {
         printf ("kvaDbGetSignalQualifiedName failed: %d\n", status);
         return status;
       }

       status = kvaDbGetSignalComment (sh, signal_comment, sizeof (signal_comment));
       if (status != kvaDbOK) {
         printf ("kvaDbGetSignalComment failed: %d\n", status);
         return status;
       }

       status = kvaDbGetSignalUnit (sh, signal_unit, sizeof (signal_unit));
       if (status != kvaDbOK) {
         printf ("kvaDbGetSignalUnit failed: %d\n", status);
         return status;
       }

       status = kvaDbGetSignalEncoding (sh, &sigEnc);
       if (status != kvaDbOK) {
         printf ("kvaDbGetSignalEncoding failed: %d\n", status);
         return status;
       }

       status = kvaDbGetSignalRepresentationType(sh, &sigType);
       if (status != kvaDbOK) {
         printf ("kvaDbGetSignalRepresentationType failed: %d\n", status);
         return status;
       }

       status = kvaDbGetSignalValueLimits(sh, &minval, &maxval);
       if (status != kvaDbOK) {
         printf ("kvaDbGetSignalValueLimits failed: %d\n", status);
         return status;
       }

       status = kvaDbGetSignalValueScaling(sh, &factor, &offset);
       if (status != kvaDbOK) {
         printf ("kvaDbGetSignalValueScaling failed: %d\n", status);
         return status;
       }

       status = kvaDbGetSignalValueSize(sh, &startbit, &length);
       if (status != kvaDbOK) {
         printf ("kvaDbGetSignalValueSize failed: %d\n", status);
         return status;
       }

       printf("      Signal: name='%s', unit='%s'\n", signal_name, signal_unit);
       printf("              qname='%s'\n", signal_qname);
       printf("              comment='%s'\n", signal_comment);
       printf("              encoding='%s'\n", sigEncToStr(sigEnc));
       printf("              representation='%s'\n", sigRepToStr(sigType));
       printf("              value min=%.02f, value max=%.02f\n", minval, maxval);
       printf("              scale faktor=%.02f, offset=%.02f\n", factor, offset);
       printf("              startbit=%d, length=%d\n", startbit, length);
       status = kvaDbGetNextSignal (mh, &sh);
     }

     status = kvaDbGetNextMsg (dh, &mh);
   }

   status = kvaDbClose (dh);
   if (status != kvaDbOK) {
       printf ("kvaDbClose failed: %d\n", status);
       return status;
   }
   printf("\n\n");

   return RET_OK;
}


const char* sigEncToStr(KvaDbSignalEncoding sigEnc)
{
  if (sigEnc == kvaDb_Intel) {
    return "Intel";
  } else if (sigEnc == kvaDb_Motorola) {
    return "Motorola";
  } else {
    return "Undefined";
  }
}

// -----------------------------------------------------------------------
// Convert signal representation to a string
// -----------------------------------------------------------------------
const char* sigRepToStr(KvaDbSignalType sigType)
{
  if (sigType == kvaDb_Invalid) {
    return "Invalid";
  } else if (sigType == kvaDb_Signed) {
    return "Signed";
  } else if (sigType == kvaDb_Unsigned) {
    return "Unsigned";
  } else if (sigType == kvaDb_Float) {
    return "Float";
  } else if (sigType == kvaDb_Double) {
    return "Double";
  } else {
    return "Undefined";
  }
}