You should have received a copy of the GNU General Public License

  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <QtDebug>

#include <QtEndian>

#include "floatswap.h"

#include "framedreader.h"

FramedReader::FramedReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :

    AbstractReader(device, channelMan, parent)

{

    paused = false;

    // initial settings

    settingsInvalid = 0;

    _numOfChannels = _settingsWidget.numOfChannels();

    hasSizeByte = _settingsWidget.frameSize() == 0;

    frameSize = _settingsWidget.frameSize();

    syncWord = _settingsWidget.syncWord();

    checksumEnabled = _settingsWidget.isChecksumEnabled();

    onNumberFormatChanged(_settingsWidget.numberFormat());

    checkSettings();

    // init setting connections

    connect(&_settingsWidget, &FramedReaderSettings::numberFormatChanged,

            this, &FramedReader::onNumberFormatChanged);

    connect(&_settingsWidget, &FramedReaderSettings::numOfChannelsChanged,

            this, &FramedReader::onNumOfChannelsChanged);

    connect(&_settingsWidget, &FramedReaderSettings::syncWordChanged,

            this, &FramedReader::onSyncWordChanged);

    connect(&_settingsWidget, &FramedReaderSettings::frameSizeChanged,

            this, &FramedReader::onFrameSizeChanged);

    connect(&_settingsWidget, &FramedReaderSettings::checksumChanged,

            [this](bool enabled){checksumEnabled = enabled; reset();});

    // init reader state

    reset();

}

void FramedReader::enable(bool enabled)

{

    if (enabled)

    {

        connect(_device, &QIODevice::readyRead,

                this, &FramedReader::onDataReady);

    }

    else

    {

        QObject::disconnect(_device, 0, this, 0);

    }

}

QWidget* FramedReader::settingsWidget()

{

    return &_settingsWidget;

}

unsigned FramedReader::numOfChannels()

{

                {

                    gotSync = true;

                }

            }

        }

        else if (hasSizeByte && !gotSize) // skipped if fixed frame size

        {

            frameSize = 0;

            _device->getChar((char*) &frameSize);

            if (frameSize == 0) // check size

            {

                qCritical() << "Frame size is 0!";

                reset();

            }

            else if (frameSize % (_numOfChannels * sampleSize) != 0)

            {

                qCritical() <<

                    QString("Frame size is not multiple of %1 (#channels * sample size)!") \

                    .arg(_numOfChannels * sampleSize);

                reset();

            }

            else

            {

                gotSize = true;

            }

        }

        else // read data bytes

        {

            // have enough data bytes? (+1 for checksum)

            if (bytesAvailable < (checksumEnabled ? frameSize+1 : frameSize))

            {

                break;

            }

            else // read data bytes and checksum

            {

                readFrameDataAndCheck();

                reset();

            }

        }

    }

}

void FramedReader::reset()

{

    sync_i = 0;

    gotSync = false;

    gotSize = false;

    unsigned numOfChannels();

    void enable(bool enabled = true);

public slots:

    void pause(bool);

private:

    /// bit wise fields for `settingsValid` member

    enum SettingInvalidFlag

    {

        SYNCWORD_INVALID = 1,

        FRAMESIZE_INVALID = 2

    };

    // settings related members

    FramedReaderSettings _settingsWidget;

    unsigned _numOfChannels;

    unsigned sampleSize;

    bool paused;

    unsigned settingsInvalid;   /// settings are all valid if this is 0, if not no reading is done

    QByteArray syncWord;

    bool checksumEnabled;

    bool hasSizeByte;

    unsigned frameSize;

    /// Checks the validity of syncWord and frameSize then shows an

    /// error message. Also updates `settingsInvalid`. If settings are

    /// valid `settingsInvalid` should be `0`.

    void checkSettings();

    // read state related members

    unsigned sync_i; /// sync byte index to be read next

    bool gotSync;    /// indicates if sync word is captured

    bool gotSize;    /// indicates if size is captured, ignored if size byte is disabled (fixed size)

    unsigned calcChecksum;

    void reset();    /// Resets the reading state. Used in case of error or setting change.

    /// points to the readSampleAs function for currently selected number format

    double (FramedReader::*readSample)();

    template<typename T> double readSampleAs();

    /// reads payload portion of the frame, calculates checksum and commits data

    /// @note should be called only if there are enough bytes on device

    void readFrameDataAndCheck();

    // `data` contains i th channels data

    void addChannelData(unsigned int channel, double* data, unsigned size);

private slots:

    void onDataReady();

    void onNumberFormatChanged(NumberFormat numberFormat);

    void onNumOfChannelsChanged(unsigned value);

    void onSyncWordChanged(QByteArray);

    void onFrameSizeChanged(unsigned);

};

#endif // FRAMEDREADER_H

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "utils.h"

#include "framedreadersettings.h"

#include "ui_framedreadersettings.h"

FramedReaderSettings::FramedReaderSettings(QWidget *parent) :

    QWidget(parent),

    ui(new Ui::FramedReaderSettings)

{

    ui->setupUi(this);

    ui->leSyncWord->setMode(false); // hex mode

    connect(ui->cbChecksum, &QCheckBox::toggled,

            [this](bool enabled)

            {

                emit checksumChanged(enabled);

            });

    connect(ui->rbFixedSize, &QRadioButton::toggled,

            ui->spSize, &QWidget::setEnabled);

    connect(ui->rbFixedSize, &QRadioButton::toggled,

            [this](bool checked)

            {

                emit frameSizeChanged(frameSize());

            });

    // Note: if directly connected we get a runtime warning on incompatible signal arguments

    connect(ui->spSize, SELECT<int>::OVERLOAD_OF(&QSpinBox::valueChanged),

            [this](int value)

            {

                emit frameSizeChanged(value);

            });

    connect(ui->spNumOfChannels, SELECT<int>::OVERLOAD_OF(&QSpinBox::valueChanged),

            [this](int value)

            {

                emit numOfChannelsChanged(value);

            });

    connect(ui->leSyncWord, &QLineEdit::textChanged,

            this, &FramedReaderSettings::onSyncWordEdited);

}

void FramedReaderSettings::onSyncWordEdited()

{

    // TODO: emit with a delay so that error message doesn't flash!

    emit syncWordChanged(syncWord());

}

unsigned FramedReaderSettings::frameSize()

{

    if (ui->rbFixedSize->isChecked())

    {

        return ui->spSize->value();

    }

    else

    {

        return 0; // frame byte is enabled

    }

}

bool FramedReaderSettings::isChecksumEnabled()

{

    return ui->cbChecksum->isChecked();

}

#include "numberformatbox.h"

#include "endiannessbox.h"

namespace Ui {

class FramedReaderSettings;

}

class FramedReaderSettings : public QWidget

{

    Q_OBJECT

public:

    explicit FramedReaderSettings(QWidget *parent = 0);

    ~FramedReaderSettings();

    void showMessage(QString message, bool error = false);

    unsigned numOfChannels();

    NumberFormat numberFormat();

    Endianness endianness();

    QByteArray syncWord();

    unsigned frameSize(); /// If frame bye is enabled `0` is returned

    bool isChecksumEnabled();

signals:

    /// If sync word is invalid (empty or 1 nibble missing at the end)

    /// signaled with an empty array

    void syncWordChanged(QByteArray);

    /// `0` indicates frame size byte is enabled

    void frameSizeChanged(unsigned);

    void checksumChanged(bool);

    void numOfChannelsChanged(unsigned);

    void numberFormatChanged(NumberFormat);

private:

    Ui::FramedReaderSettings *ui;

private slots:

    void onSyncWordEdited();

};

#endif // FRAMEDREADERSETTINGS_H

     <widget class="QSpinBox" name="spNumOfChannels">

      <property name="minimum">

       <number>1</number>

      </property>

      <property name="maximum">

       <number>32</number>

      </property>

     </widget>

    </item>

   </layout>

  </widget>

  <widget class="QLabel" name="lMessage">

   <property name="geometry">

    <rect>

     <x>0</x>

     <y>180</y>

     <width>471</width>

     <height>17</height>

    </rect>

   </property>

   <property name="text">

    <string>All is well.</string>

   </property>

  </widget>

  <widget class="QGroupBox" name="groupBox">

   <property name="geometry">

    <rect>

     <x>1</x>

     <y>39</y>

     <width>204</width>

     <height>93</height>

    </rect>

   </property>

   <property name="title">

    <string>Frame Size:</string>

   </property>

   <layout class="QVBoxLayout" name="verticalLayout">

    <item>

     <layout class="QHBoxLayout" name="horizontalLayout">

      <item>

       <widget class="QRadioButton" name="rbFixedSize">

        <property name="text">

         <string>Fixed Size:</string>

        </property>

       </widget>

      </item>

      <item>

       <widget class="QSpinBox" name="spSize">