jfmartel/YULTek
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
YULTek/Otarcik_CAN/Sources/CANDatabase/CANDatabase.cpp
jfmartel daa887d67b Développement cloud.
2023-02-19 17:03:43 -05:00

361 lines
12 KiB
C++
Raw Blame History

#include "defines.h"
#include "CANDatabase.h"
#include "GeneralMessagesLogDispatcher.h"
const char* sigEncToStr(KvaDbSignalEncoding sigEnc);
const char* sigRepToStr(KvaDbSignalType sigType);
CCANDatabase::CCANDatabase(QObject *parent) : QObject(parent)
{
mDatabaseFileLoaded = false;
}
CCANDatabase::~CCANDatabase()
{
}
int CCANDatabase::Init(QString DatabaseFileName)
{
mDatabaseFileName = DatabaseFileName;
return LoadDatabaseFile(DatabaseFileName);
}
int CCANDatabase::LoadDatabaseFile(QString Filename)
{
KvaDbStatus status;
unsigned int flags = 0;
mDatabaseFileLoaded = false;
// Open a database handle
status = kvaDbOpen(&mDatabaseDriverHandle);
if (status != kvaDbOK)
{
CGeneralMessagesLogDispatcher::instance()->AddLogMessage(QString("Impossible d'initialiser la base de données (création du handle impossble"),true,CGeneralMessagesLogDispatcher::GEN_MSG_TXT_ERROR_STATUS);
qDebug("Could not create a database handle: %d\n", status);
return RET_GENERAL_ERROR;
}
// Load the database file
CGeneralMessagesLogDispatcher::instance()->AddLogMessage(QString("Chargement de la base de données %1").arg(Filename),true);
status = kvaDbReadFile(mDatabaseDriverHandle, Filename.toLocal8Bit().data());
if (status != kvaDbOK)
{
CGeneralMessagesLogDispatcher::instance()->AddLogMessage(QString("Erreur de base de données: impossible de charger le fichier %1").arg(Filename),true,CGeneralMessagesLogDispatcher::GEN_MSG_TXT_ERROR_STATUS);
qDebug("Could not load '%s': %d\n", Filename.toLocal8Bit().data(), status);
return RET_GENERAL_ERROR;
}
status = kvaDbGetFlags(mDatabaseDriverHandle, &flags);
if (status != kvaDbOK)
{
CGeneralMessagesLogDispatcher::instance()->AddLogMessage(QString("Erreur de base de données: impossible de charger les flags"),true,CGeneralMessagesLogDispatcher::GEN_MSG_TXT_ERROR_STATUS);
qDebug("kvaDbGetFlags failed: %d\n", status);
return RET_GENERAL_ERROR;
}
CGeneralMessagesLogDispatcher::instance()->AddLogMessage(QString("Base de données chargée avec succès. Flags: 0x%1").arg(flags),true,CGeneralMessagesLogDispatcher::GEN_MSG_TXT_SUCCESS_STATUS);
qDebug(" Database: flags=0x%x\n", flags);
mDatabaseFileLoaded = true;
return RET_OK;
}
int CCANDatabase::BuildMessageList(QList<CCANMessage *> *MsgListPtr)
{
if(mDatabaseFileLoaded == false)
{
qDebug("CCANDatabase error: Trying to build an unloaded database");
return RET_GENERAL_ERROR;
}
if(MsgListPtr == 0)
{
qDebug("CCANDatabase error: Trying to load database in an invalid list pointer...");
return RET_GENERAL_ERROR;
}
KvaDbStatus status;
KvaDbMessageHnd mh = 0;
KvaDbSignalHnd sh = 0;
unsigned int flags = 0;
// Get the first message in the database
status = kvaDbGetFirstMsg (mDatabaseDriverHandle, &mh);
if (status != kvaDbOK)
{
CGeneralMessagesLogDispatcher::instance()->AddLogMessage(QString("Erreur de base de données: impossible de charger le premier message"),true,CGeneralMessagesLogDispatcher::GEN_MSG_TXT_ERROR_STATUS);
qDebug ("kvaDbGetFirstMsg failed: %d\n", status);
return RET_GENERAL_ERROR;
}
// Go through all messages in the database
while (status == kvaDbOK)
{
CCANMessage *NewMsg = new CCANMessage;
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)
{
qDebug ("kvaDbGetMsgName failed: %d\n", status);
// return RET_GENERAL_ERROR;
}
NewMsg->mCANMsgName = QString(msg_name);
// status = kvaDbGetMsgQualifiedName (mh, msg_qname, sizeof (msg_qname));
// if (status != kvaDbOK)
// {
// qDebug ("kvaDbGetMsgQualifiedName failed: %d\n", status);
// return RET_GENERAL_ERROR;
// }
status = kvaDbGetMsgComment (mh, msg_comment, sizeof (msg_comment));
if (status != kvaDbOK)
{
qDebug ("kvaDbGetMsgComment failed: %d\n", status);
// return RET_GENERAL_ERROR;
}
NewMsg->mCANMsgComment = QString(msg_comment);
status = kvaDbGetMsgId (mh, &id, &flags);
if (status != kvaDbOK)
{
qDebug ("kvaDbGetMsgId failed: %d\n", status);
// return RET_GENERAL_ERROR;
}
NewMsg->mCANMsgID = id;
NewMsg->mCANMsgFlags = flags;
status = kvaDbGetMsgDlc (mh, &dlc);
if (status != kvaDbOK)
{
qDebug ("kvaDbGetMsgDlc failed: %d\n", status);
// return RET_GENERAL_ERROR;
}
NewMsg->mCANMsgLength = dlc;
// // Print the properties for each message
// qDebug (" Msg: name='%s'\n", msg_name);
// qDebug (" qname='%s', comment='%s'\n", msg_qname, msg_comment);
// qDebug (" id=%x, dlc=%d, flags=%x\n", id, dlc, flags);
// Go through all signals for this message
status = kvaDbGetFirstSignal (mh, &sh);
while (status == kvaDbOK)
{
CCANSignal *NewSignal = new CCANSignal;
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)
{
qDebug ("kvaDbGetSignalName failed: %d\n", status);
// return status;
}
NewSignal->mSignalName = QString(signal_name);
// status = kvaDbGetSignalQualifiedName (sh, signal_qname, sizeof (signal_qname));
// if (status != kvaDbOK)
// {
// qDebug ("kvaDbGetSignalQualifiedName failed: %d\n", status);
//// return status;
// }
status = kvaDbGetSignalComment (sh, signal_comment, sizeof (signal_comment));
if (status != kvaDbOK)
{
qDebug ("kvaDbGetSignalComment failed: %d\n", status);
// return status;
}
NewSignal->mSignalComment = QString(signal_comment);
status = kvaDbGetSignalUnit (sh, signal_unit, sizeof (signal_unit));
if (status != kvaDbOK)
{
qDebug ("kvaDbGetSignalUnit failed: %d\n", status);
// return status;
}
NewSignal->mSignalUnit = QString(signal_unit);
status = kvaDbGetSignalEncoding (sh, &sigEnc);
if (status != kvaDbOK)
{
qDebug ("kvaDbGetSignalEncoding failed: %d\n", status);
// return status;
}
if(sigEnc == kvaDb_Intel)
{
NewSignal->mEncoding = CCANSignal::CAN_SIGNAL_ENCODING_INTEL;
}
else if(sigEnc == kvaDb_Motorola)
{
NewSignal->mEncoding = CCANSignal::CAN_SIGNAL_ENCODING_MOTOROLA;
}
else
{
NewSignal->mEncoding = CCANSignal::CAN_SIGNAL_ENCODING_INVALID;
qDebug ("kvaDbGetSignalEncoding returned an invalid encoding type: %d\n", sigEnc);
}
status = kvaDbGetSignalRepresentationType(sh, &sigType);
if (status != kvaDbOK)
{
qDebug ("kvaDbGetSignalRepresentationType failed: %d\n", status);
// return status;
}
switch(sigType)
{
case kvaDb_Signed: ///< Signed integer
{
NewSignal->mValueType = CCANSignal::CAN_SIGNAL_TYPE_SIGNED_INT;
break;
}
case kvaDb_Unsigned: ///< Unsigned integer
{
NewSignal->mValueType = CCANSignal::CAN_SIGNAL_TYPE_UNSIGNED_INT;
break;
}
case kvaDb_Float: ///< Float, strictly 32 bit long
{
NewSignal->mValueType = CCANSignal::CAN_SIGNAL_TYPE_32_BIT_FLOAT;
break;
}
case kvaDb_Double:
{
NewSignal->mValueType = CCANSignal::CAN_SIGNAL_TYPE_64_BIT_DOUBLE;
break;
}
case kvaDb_Invalid: ///< Invalid representation
default:
{
qDebug ("kvaDbGetSignalRepresentationType returned invalid type: %d\n", sigType);
NewSignal->mValueType = CCANSignal::CAN_SIGNAL_TYPE_INVALID;
break;
}
}
status = kvaDbGetSignalValueLimits(sh, &minval, &maxval);
if (status != kvaDbOK)
{
qDebug ("kvaDbGetSignalValueLimits failed: %d\n", status);
// return status;
}
NewSignal->mMinValue = minval;
NewSignal->mMaxValue = maxval;
status = kvaDbGetSignalValueScaling(sh, &factor, &offset);
if (status != kvaDbOK)
{
qDebug ("kvaDbGetSignalValueScaling failed: %d\n", status);
// return status;
}
NewSignal->mValueFactor = factor;
NewSignal->mValueOffset = offset;
status = kvaDbGetSignalValueSize(sh, &startbit, &length);
if (status != kvaDbOK)
{
qDebug ("kvaDbGetSignalValueSize failed: %d\n", status);
// return status;
}
NewSignal->mStartBit = startbit;
NewSignal->mSignalSize = length;
// qDebug(" Signal: name='%s', unit='%s'\n", signal_name, signal_unit);
// qDebug(" qname='%s'\n", signal_qname);
// qDebug(" comment='%s'\n", signal_comment);
// qDebug(" encoding='%s'\n", sigEncToStr(sigEnc));
// qDebug(" representation='%s'\n", sigRepToStr(sigType));
// qDebug(" value min=%.02f, value max=%.02f\n", minval, maxval);
// qDebug(" scale faktor=%.02f, offset=%.02f\n", factor, offset);
// qDebug(" startbit=%d, length=%d\n", startbit, length);
NewMsg->AddSignal(NewSignal);
status = kvaDbGetNextSignal (mh, &sh);
}
MsgListPtr->append(NewMsg);
status = kvaDbGetNextMsg (mDatabaseDriverHandle, &mh);
}
status = kvaDbClose (mDatabaseDriverHandle);
if (status != kvaDbOK)
{
qDebug ("kvaDbClose failed: %d\n", status);
return status;
}
qDebug("\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";
}
}
Reference in New Issue View Git Blame Copy Permalink