Index: sources/canbus/caninterface.cpp =================================================================== diff -u -rde2f87e15fa05b1c45581cfedd8f1af0c47c2b48 -rc933552983a659ca4cc351ff4d43d07319adab1e --- sources/canbus/caninterface.cpp (.../caninterface.cpp) (revision de2f87e15fa05b1c45581cfedd8f1af0c47c2b48) +++ sources/canbus/caninterface.cpp (.../caninterface.cpp) (revision c933552983a659ca4cc351ff4d43d07319adab1e) @@ -17,7 +17,7 @@ #include // Project -#include "messagehandler.h" +#include "frameinterface.h" // namespace using namespace Can; @@ -29,8 +29,13 @@ * \brief Caninterface Constructor * \param parent object */ -CanInterface::CanInterface(QObject *parent) : QObject(parent) {} +CanInterface::CanInterface(QObject *parent) : QObject(parent) { } +/*! + * \brief CanInterface Initialization + * \details Initializes the CANBUS and checks if can be connected + * \return true if connected, false otherwise + */ bool CanInterface::init() { QString mError; @@ -42,7 +47,7 @@ _numberFramesWritten = 0; - connection(); + initConnections(); if (!_canDevice->connectDevice()) { status(tr("Error: Connection")); @@ -54,26 +59,44 @@ return true; } +/*! + * \brief CanInterface status + * \details CanInterface status description + * \return The current stores status + */ QString CanInterface::status() const { return _canStatus; } -void CanInterface::connection() +/*! + * \brief CanInterface connections definition + * \details Initializes the required signal/slot connection between this class and other objects + * to be able to communicate. + */ +void CanInterface::initConnections() { - if (_canDevice) { - connect(_canDevice, SIGNAL(framesReceived()), - this , SLOT ( onRead())); - connect(_canDevice, SIGNAL(errorOccurred(QCanBusDevice::CanBusError)), - this , SLOT ( onError(QCanBusDevice::CanBusError))); + connect(_canDevice, SIGNAL( framesReceived()), + this , SLOT (onFrameReceive ())); + + connect(_canDevice, SIGNAL( errorOccurred(QCanBusDevice::CanBusError)), + this , SLOT (onFrameError (QCanBusDevice::CanBusError))); + + connect(_canDevice, SIGNAL( framesWritten(qint64)), + this , SLOT (onFrameWrittern(qint64))); + } - connect(_MessageHandler, SIGNAL(didActionPerform(QCanBusFrame)), - this , SLOT( onActionPerform(QCanBusFrame))); - connect(_MessageHandler, SIGNAL(didActionRequest(QCanBusFrame)), - this , SLOT( onActionRequest(QCanBusFrame))); + connect(_FrameInterface, SIGNAL(didFrameTransmit(QCanBusFrame)), + this , SLOT( onFrameTransmit(QCanBusFrame))); } +/*! + * \brief CanInterface status + * \details Sets the Can interface status description + * \param vDescription - Description about the CANBUS Interface errors + * \param vError - Qt CANBUS Interface Error + */ void CanInterface::status(const QString &vDescription, QString vError) { QString mError=""; @@ -89,16 +112,49 @@ .arg(_canInterface) .arg(mError) ; - // qDebug() << _canStatus; + qDebug() << _canStatus; } -void CanInterface::send(const QCanBusFrame &vFrame) +/*! + * \brief CanInterface send + * \details send a frame over the CANBUS + * \param vFrame - CANBUS message frame + */ +bool CanInterface::transmit(const QCanBusFrame &vFrame) { if( !_canDevice ) - return; - _canDevice->writeFrame(vFrame); + return false; + return _canDevice->writeFrame(vFrame); } +/*! + * \brief CanInterface console Output messaging + * \details Sends out formatted CANBUS message to the console + * for debugging purposes. + * \param vFrame - The CANBUS frame to be sent out + */ +void CanInterface::consoleOut(const QCanBusFrame &vFrame) +{ + if ( ! _enableConsoleOut ) return; + + const QString time = QString::fromLatin1("%1.%2 ") + .arg(vFrame.timeStamp().seconds(), 10, 10, QLatin1Char(' ')) + .arg(vFrame.timeStamp().microSeconds() / 100, 4, 10, QLatin1Char('0')); + const QString flags = frameFlags(vFrame); + QString view; + if (vFrame.frameType() == QCanBusFrame::ErrorFrame) { + view = _canDevice->interpretErrorFrame(vFrame); + } + else { + view = vFrame.payload().toHex('.').replace(QByteArray("a5"),QByteArray("\033[1;33mA5\033[0m")); + } + fprintf(stderr, "%s %s %i %s\n", time.toLatin1().constData(), flags.toLatin1().constData(), vFrame.frameId(), view.toLatin1().constData()); +} + +/*! + * \brief CanInterface quit + * \details Quit the CANBUS Interface by disconnecting the bus and device. + */ void CanInterface::quit() { if (!_canDevice) @@ -111,21 +167,32 @@ status(tr("Disconnected")); } -static QString frameFlags(const QCanBusFrame &frame) +/*! + * \brief frameFlags + * \details CANBUS message frame type as flags + * \param vFrame - CANBUS message frame + * \return Frame flag as QString + */ +QString CanInterface::frameFlags(const QCanBusFrame &vFrame) { QString result = QLatin1String(" --- "); - if (frame.hasBitrateSwitch()) + if (vFrame.hasBitrateSwitch()) result[1] = QLatin1Char('B'); - if (frame.hasErrorStateIndicator()) + if (vFrame.hasErrorStateIndicator()) result[2] = QLatin1Char('E'); - if (frame.hasLocalEcho()) + if (vFrame.hasLocalEcho()) result[3] = QLatin1Char('L'); return result; } -void CanInterface::onError(QCanBusDevice::CanBusError vError) +/*! + * \brief CanInterface onError + * \details Can Bus error handler which sets the can status description + * \param vError - CANBUS error + */ +void CanInterface::onFrameError(QCanBusDevice::CanBusError vError) { switch (vError) { case QCanBusDevice::ReadError: @@ -138,47 +205,48 @@ default: break; } - emit didError(_canStatus); + emit didFrameError(_canStatus); } -void CanInterface::onRead() +/*! + * \brief CanInterface::onFrameWrittern + * \details This is the slot connected to the signal + * which is emitted every time a payload of frames + * has been written to the CANBUS bus. + * \param vFramesCount - The framesCount argument is set to the number of frames + * that were written in this payload. + */ +void CanInterface::onFrameWrittern(qint64 /*vFramesCount*/) { + //_numberFramesWritten = vFramesCount; + //qDebug() << "onFrameWrittern::FramesCount : " << vFramesCount; +} + +/*! + * \brief CanInterface onFrameReceived + * \details CANBUS message read handler + */ +void CanInterface::onFrameReceive () +{ if (!_canDevice) return; while (_canDevice->framesAvailable()) { const QCanBusFrame frame = _canDevice->readFrame(); - - QString view; - if (frame.frameType() == QCanBusFrame::ErrorFrame) { - view = _canDevice->interpretErrorFrame(frame); - } - else { - view = frame.toString(); - } - - const QString time = QString::fromLatin1("%1.%2 ") - .arg(frame.timeStamp().seconds(), 10, 10, QLatin1Char(' ')) - .arg(frame.timeStamp().microSeconds() / 100, 4, 10, QLatin1Char('0')); - - const QString flags = frameFlags(frame); - - // qDebug() << time + flags + view; - // TODO : Needs to be investigated on how the messages on canBus will be received. - // may require to be moved at the end of the function, to not to be called for each message. - emit didRead(frame); + consoleOut(frame); + emit didFrameReceive(frame); } } -void CanInterface::onActionPerform(const QCanBusFrame &vFrame) +/*! + * \brief CanInterface onActionPerform + * \details sends a CANBUS message frame of the CANBUS message of the performed action + * This is a response from application UI to HD device + * \param vFrame - CANBUS message frame + */ +void CanInterface::onFrameTransmit(const QCanBusFrame &vFrame) { - // TODO : Process Frame - send(vFrame); + bool ok = transmit(vFrame); + consoleOut(vFrame); + emit didFrameTransmit(ok); } - -void CanInterface::onActionRequest(const QCanBusFrame &vFrame) -{ - // TODO : Process Frame - send(vFrame); -} -