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

                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

            {

    };

    // 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

    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)

        return ui->spSize->value();

    }

    else

    {

        return 0; // frame byte is enabled

    }

}

bool FramedReaderSettings::isChecksumEnabled()

{

    return ui->cbChecksum->isChecked();

}

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

   <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>