void AbstractReader::pause(bool enabled)

{

    paused = enabled;

}

unsigned AbstractReader::numChannels() const

{

    // TODO: an alternative is to never set _numChannels to '0'

    // do not allow '0'

    return _numChannels == 0 ? 1 : _numChannels;

}

    Q_OBJECT

public:

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

    /**

     * 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'.

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

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

    unsigned numChannels() const;

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;

    unsigned _numChannels;

};

#endif // ABSTRACTREADER_H

#include <QtDebug>

#include "asciireader.h"

/// If set to this value number of channels is determined from input

#define NUMOFCHANNELS_AUTO   (0)

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

    AbstractReader(device, parent)

{

    paused = false;

    _numChannels = _settingsWidget.numOfChannels();

    autoNumOfChannels = (_numChannels == NUMOFCHANNELS_AUTO);

    delimiter = _settingsWidget.delimiter();

    connect(&_settingsWidget, &AsciiReaderSettings::numOfChannelsChanged,

            [this](unsigned value)

            {

                _numChannels = value;

                updateNumChannels(); // TODO: setting numchannels = 0, should remove all buffers

                                     // do we want this?

                autoNumOfChannels = (_numChannels == NUMOFCHANNELS_AUTO);

                if (!autoNumOfChannels)

                {

                    emit numOfChannelsChanged(value);

                }

            });

    connect(&_settingsWidget, &AsciiReaderSettings::delimiterChanged,

            [this](QChar d)

            {

                delimiter = d;

            });

}

QWidget* AsciiReader::settingsWidget()

{

    return &_settingsWidget;

}

void AsciiReader::onDataReady()

{

    while(_device->canReadLine())

    {

        QString line = QString(_device->readLine());

        // discard only once when we just started reading

        {

            continue;

        }

        // discard data if paused

        if (paused)

        {

            continue;

        }

        // parse data

        line = line.trimmed();

#include <QSettings>

#include "abstractreader.h"

#include "asciireadersettings.h"

class AsciiReader : public AbstractReader

{

    Q_OBJECT

public:

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

    QWidget* settingsWidget();

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

private slots:

};

#endif // ASCIIREADER_H

    connect(&_settingsWidget, &BinaryStreamReaderSettings::skipSampleRequested,

            [this]()

            {

                skipSampleRequested = true;

            });

}

QWidget* BinaryStreamReader::settingsWidget()

{

    return &_settingsWidget;

}

void BinaryStreamReader::onNumberFormatChanged(NumberFormat numberFormat)

{

    switch(numberFormat)

    {

        case NumberFormat_uint8:

            sampleSize = 1;

            readSample = &BinaryStreamReader::readSampleAs<quint8>;

            break;

        case NumberFormat_int8:

            sampleSize = 1;

            readSample = &BinaryStreamReader::readSampleAs<qint8>;

            break;

/**

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

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

    /**

     * Reads 1 sample from the device in given format.

     *

     * @note Device should already have enough bytes present before

     * calling this function.

     */

    template<typename T> double readSampleAs();

private slots:

    void onNumberFormatChanged(NumberFormat numberFormat);

    void onNumOfChannelsChanged(unsigned value);

};

#endif // BINARYSTREAMREADER_H

            // we are calculating the fourier components of square wave

            samples.data(ci)[0] = 4*sin(2*M_PI*double((ci+1)*count)/period)/((2*(ci+1))*M_PI);

        }

        feedOut(samples);

    }

}

void DemoReader::onNumChannelsChanged(unsigned value)

{

    _numChannels = value;

    updateNumChannels();

}

public slots:

    void setNumChannels(unsigned value);

private:

    DemoReaderSettings _settingsWidget;

    QTimer timer;

    int count;

private slots:

    void demoTimerTimeout();

    void onNumChannelsChanged(unsigned value);

};

#endif // DEMOREADER_H

            this, &FramedReader::onFrameSizeChanged);

    connect(&_settingsWidget, &FramedReaderSettings::checksumChanged,

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

    connect(&_settingsWidget, &FramedReaderSettings::debugModeChanged,

            [this](bool enabled){debugModeEnabled = enabled;});

    // init reader state

    reset();

}

QWidget* FramedReader::settingsWidget()

{

    return &_settingsWidget;

}

void FramedReader::onNumberFormatChanged(NumberFormat numberFormat)

{

    switch(numberFormat)

    {

        case NumberFormat_uint8:

            sampleSize = 1;

            readSample = &FramedReader::readSampleAs<quint8>;

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

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

    };

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

private slots:

    void onNumberFormatChanged(NumberFormat numberFormat);

    void onNumOfChannelsChanged(unsigned value);

    void onSyncWordChanged(QByteArray);

    void onFrameSizeChanged(unsigned);

};

#endif // FRAMEDREADER_H