#include "abstractreader.h"

AbstractReader::AbstractReader(QIODevice* device, QObject* parent) :

    QObject(parent)

{

    _device = device;

}

void AbstractReader::pause(bool enabled)

{

    paused = enabled;

}

     * Returns a widget to be shown in data format panel when reader

     * is selected.

     */

    virtual QWidget* settingsWidget() = 0;

    /// Reader should only read when enabled. Default state should be

    /// 'disabled'.

    virtual void enable(bool enabled = true) = 0;

    /// None of the current readers support X channel at the moment

    bool hasX() const final { return false; };

signals:

    // TODO: should we keep this?

    void numOfChannelsChanged(unsigned);

public slots:

    /**

     * Pauses the reading.

     *

     * Reader should actually continue reading to keep the

     * synchronization but shouldn't commit data.

     */

    void pause(bool enabled);

protected:

    QIODevice* _device;

    bool paused;

};

#endif // ABSTRACTREADER_H

            {

                delimiter = d;

            });

    connect(device, &QIODevice::aboutToClose, [this](){discardFirstLine=true;});

}

QWidget* AsciiReader::settingsWidget()

{

    return &_settingsWidget;

}

// TODO: this could be a part of AbstractReader

void AsciiReader::enable(bool enabled)

{

    if (enabled)

    {

        discardFirstLine = true;

        QObject::connect(_device, &QIODevice::readyRead,

                         this, &AsciiReader::onDataReady);

    }

    else

    {

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

#include <QSettings>

#include "abstractreader.h"

#include "asciireadersettings.h"

class AsciiReader : public AbstractReader

{

    Q_OBJECT

public:

    explicit AsciiReader(QIODevice* device, QObject *parent = 0);

    QWidget* settingsWidget();

    void enable(bool enabled = true);

    /// Stores settings into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads settings from a `QSettings`.

    void loadSettings(QSettings* settings);

private:

    AsciiReaderSettings _settingsWidget;

    /// number of channels will be determined from incoming data

    unsigned autoNumOfChannels;

    QChar delimiter; ///< selected column delimiter

    // We may have (usually true) started reading in the middle of a

    // line, so its a better idea to just discard first line.

    bool discardFirstLine;

private slots:

    void onDataReady();

};

    connect(&_settingsWidget, &BinaryStreamReaderSettings::skipSampleRequested,

            [this]()

            {

                skipSampleRequested = true;

            });

}

QWidget* BinaryStreamReader::settingsWidget()

{

    return &_settingsWidget;

}

void BinaryStreamReader::enable(bool enabled)

{

    if (enabled)

    {

        QObject::connect(_device, &QIODevice::readyRead,

                         this, &BinaryStreamReader::onDataReady);

    }

    else

    {

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

        disconnectSinks();

    }

/**

 * Reads a simple stream of samples in binary form from the

 * device. There is no means of synchronization other than a button

 * that should be manually triggered by user.

 */

class BinaryStreamReader : public AbstractReader

{

    Q_OBJECT

public:

    explicit BinaryStreamReader(QIODevice* device, QObject *parent = 0);

    QWidget* settingsWidget();

    void enable(bool enabled = true);

    /// Stores settings into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads settings from a `QSettings`.

    void loadSettings(QSettings* settings);

private:

    BinaryStreamReaderSettings _settingsWidget;

    unsigned sampleSize;

    bool skipByteRequested;

    bool skipSampleRequested;

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

    double (BinaryStreamReader::*readSample)();

    /**

     * Reads 1 sample from the device in given format.

     *

     * @note Device should already have enough bytes present before

     * calling this function.

{

    if (enabled)

    {

        timer.start();

    }

    else

    {

        timer.stop();

        disconnectSinks();

    }

}

void DemoReader::setNumChannels(unsigned value)

{

    _settingsWidget.setNumChannels(value);

}

void DemoReader::demoTimerTimeout()

{

    const double period = 100;

    count++;

    if (count >= 100) count = 0;

    if (!paused)

 * currently selected actual readers settings widget.

 *

 * This reader should not be enabled when port is open!

 */

class DemoReader : public AbstractReader

{

    Q_OBJECT

public:

    explicit DemoReader(QIODevice* device, QObject* parent = 0);

    QWidget* settingsWidget();

    void enable(bool enabled = true);

public slots:

    void setNumChannels(unsigned value);

private:

    DemoReaderSettings _settingsWidget;

    QTimer timer;

    int count;

private slots:

    void demoTimerTimeout();

    void onNumChannelsChanged(unsigned value);

};

#endif // DEMOREADER_H

    else

    {

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

        disconnectSinks();

    }

}

QWidget* FramedReader::settingsWidget()

{

    return &_settingsWidget;

}

void FramedReader::onNumberFormatChanged(NumberFormat numberFormat)

{

    switch(numberFormat)

    {

        case NumberFormat_uint8:

            sampleSize = 1;

            readSample = &FramedReader::readSampleAs<quint8>;

            break;

        case NumberFormat_int8:

            sampleSize = 1;

            readSample = &FramedReader::readSampleAs<qint8>;

            break;

#include "framedreadersettings.h"

/**

 * Reads data in a customizable framed format.

 */

class FramedReader : public AbstractReader

{

    Q_OBJECT

public:

    explicit FramedReader(QIODevice* device, QObject *parent = 0);

    QWidget* settingsWidget();

    void enable(bool enabled = true);

    /// Stores settings into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads settings from a `QSettings`.

    void loadSettings(QSettings* settings);

private:

    /// bit wise fields for `settingsValid` member

    enum SettingInvalidFlag

    {

        SYNCWORD_INVALID = 1,

        FRAMESIZE_INVALID = 2

    };

    // settings related members

    FramedReaderSettings _settingsWidget;

    unsigned sampleSize;

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

    QByteArray syncWord;

    bool checksumEnabled;

    bool hasSizeByte;

    unsigned frameSize;

    bool debugModeEnabled;

    /// 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();