src/numberformatbox.ui

  src/endiannessbox.ui

  src/binarystreamreadersettings.ui

  src/asciireadersettings.ui

  src/numberformatbox.cpp

  src/endiannessbox.cpp

  src/abstractreader.cpp

  src/binarystreamreader.cpp

  src/binarystreamreadersettings.cpp

  src/asciireader.cpp

  src/asciireadersettings.cpp

/*

  Copyright © 2016 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  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 "abstractreader.h"

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

    QObject(parent)

{

    _device = device;

    _channelMan = channelMan;

}

/*

  Copyright © 2016 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

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

*/

#ifndef ABSTRACTREADER_H

#define ABSTRACTREADER_H

#include <QObject>

#include <QIODevice>

#include <QWidget>

#include "channelmanager.h"

/**

 * All reader classes must inherit this class.

 */

class AbstractReader : public QObject

{

    Q_OBJECT

public:

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

    /**

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

     * is selected.

     */

    virtual QWidget* settingsWidget() = 0;

    /**

     * Number of channels being read.

     *

     * This number may be user selected or automatically determined

     * from incoming stream.

     */

    virtual unsigned numOfChannels() = 0;

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

    /// 'disabled'.

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

signals:

    void numOfChannelsChanged(unsigned);

    // TODO: this must be signaled by 'channel man' for better abstraction

    void dataAdded(); ///< emitted when data added to channel man.

    // TODO: this should be a part of 'channel man'

    void samplesPerSecondChanged(unsigned);

public slots:

    /**

     * Pauses the reading.

     *

     * Reader should actually continue reading to keep the

     * synchronization but shouldn't commit data.

     */

    virtual void pause(bool) = 0;

protected:

    QIODevice* _device;

    ChannelManager* _channelMan;

};

#endif // ABSTRACTREADER_H

/*

  Copyright © 2016 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

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

#include "asciireader.h"

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

    AbstractReader(device, channelMan, parent)

{

    paused = false;

    sampleCount = 0;

    // TODO: sps counter

    _numOfChannels = _settingsWidget.numOfChannels();

    connect(&_settingsWidget, &AsciiReaderSettings::numOfChannelsChanged,

            this, &AsciiReader::numOfChannelsChanged);

    connect(&_settingsWidget, &AsciiReaderSettings::numOfChannelsChanged,

            [this](unsigned value){_numOfChannels = value;});

}

QWidget* AsciiReader::settingsWidget()

{

    return &_settingsWidget;

}

unsigned AsciiReader::numOfChannels()

{

    return _numOfChannels;

}

// TODO: this could be a part of AbstractReader

void AsciiReader::enable(bool enabled)

{

    if (enabled)

    {

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

                         this, &AsciiReader::onDataReady);

    }

    else

    {

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

    }

}

void AsciiReader::pause(bool enabled)

{

    paused = enabled;

}

void AsciiReader::onDataReady()

{

    while(_device->canReadLine())

    {

        QByteArray line = _device->readLine();

        // discard data if paused

        if (paused)

        {

            return;

        }

        line = line.trimmed();

        auto separatedValues = line.split(',');

        int numReadChannels; // effective number of channels to read

        if (separatedValues.length() >= int(_numOfChannels))

        {

            numReadChannels = _numOfChannels;

        }

        else // there is missing channel data

        {

            numReadChannels = separatedValues.length();

            qWarning() << "Incoming data is missing data for some channels!";

        }

        // parse read line

        for (int ci = 0; ci < numReadChannels; ci++)

        {

            bool ok;

            double channelSample = separatedValues[ci].toDouble(&ok);

            if (ok)

            {

                _channelMan->addChannelData(ci, &channelSample, 1);

                sampleCount++;

            }

            else

            {

                qWarning() << "Data parsing error for channel: " << ci;

            }

        }

        emit dataAdded();

    }

}

/*

  Copyright © 2016 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

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

*/

#ifndef ASCIIREADER_H

#define ASCIIREADER_H

#include "abstractreader.h"

#include "asciireadersettings.h"

class AsciiReader : public AbstractReader

{

    Q_OBJECT

public:

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

    QWidget* settingsWidget();

    unsigned numOfChannels();

    void enable(bool enabled = true);

public slots:

    void pause(bool);

private:

    AsciiReaderSettings _settingsWidget;

    unsigned _numOfChannels;

    bool paused;

    unsigned sampleCount; ///< used for sps counter

private slots:

    void onDataReady();

};

#endif // ASCIIREADER_H

/*

  Copyright © 2016 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  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 "asciireadersettings.h"

#include "ui_asciireadersettings.h"

AsciiReaderSettings::AsciiReaderSettings(QWidget *parent) :

    QWidget(parent),

    ui(new Ui::AsciiReaderSettings)

{

    ui->setupUi(this);

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

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

            [this](int value)

            {

                emit numOfChannelsChanged(value);

            });

}

AsciiReaderSettings::~AsciiReaderSettings()

{

    delete ui;

}

unsigned AsciiReaderSettings::numOfChannels()

{

    return ui->spNumOfChannels->value();

}

/*

  Copyright © 2016 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

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

*/

#ifndef ASCIIREADERSETTINGS_H

#define ASCIIREADERSETTINGS_H

#include <QWidget>

namespace Ui {

class AsciiReaderSettings;

}

class AsciiReaderSettings : public QWidget

{

    Q_OBJECT

public:

    explicit AsciiReaderSettings(QWidget *parent = 0);

    ~AsciiReaderSettings();

    unsigned numOfChannels();

signals:

    void numOfChannelsChanged(unsigned);

private:

    Ui::AsciiReaderSettings *ui;

};

#endif // ASCIIREADERSETTINGS_H

<?xml version="1.0" encoding="UTF-8"?>

<ui version="4.0">

 <class>AsciiReaderSettings</class>

 <widget class="QWidget" name="AsciiReaderSettings">

  <property name="geometry">

   <rect>

    <x>0</x>

    <y>0</y>

    <width>414</width>

    <height>171</height>

   </rect>

  </property>

  <property name="windowTitle">

   <string>Form</string>

  </property>

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

   <property name="geometry">

    <rect>

     <x>153</x>

     <y>10</y>

     <width>60</width>

     <height>27</height>

    </rect>

   </property>

   <property name="minimumSize">

    <size>

     <width>60</width>

     <height>0</height>

    </size>

   </property>

   <property name="keyboardTracking">

    <bool>false</bool>

   </property>

   <property name="minimum">

    <number>1</number>

   </property>

   <property name="maximum">

    <number>32</number>

   </property>

  </widget>

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

   <property name="geometry">

    <rect>

     <x>20</x>

     <y>10</y>

     <width>127</width>

     <height>27</height>

    </rect>

   </property>

   <property name="text">

    <string>Number Of Channels:</string>

   </property>

  </widget>

 </widget>

 <resources/>

 <connections/>

</ui>

/*

  Copyright © 2016 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

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

#include <QtDebug>

#include "binarystreamreader.h"

#include "floatswap.h"

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

    AbstractReader(device, channelMan, parent)

{

    paused = false;

    skipByteRequested = false;

    sampleCount = 0;

    _numOfChannels = _settingsWidget.numOfChannels();

    connect(&_settingsWidget, &BinaryStreamReaderSettings::numOfChannelsChanged,

            this, &BinaryStreamReader::numOfChannelsChanged);

    connect(&_settingsWidget, &BinaryStreamReaderSettings::numOfChannelsChanged,

            this, &BinaryStreamReader::onNumOfChannelsChanged);

    // initial number format selection

    onNumberFormatChanged(_settingsWidget.numberFormat());

    connect(&_settingsWidget, &BinaryStreamReaderSettings::numberFormatChanged,

            this, &BinaryStreamReader::onNumberFormatChanged);

    // enable skip byte button

    connect(&_settingsWidget, &BinaryStreamReaderSettings::skipByteRequested,

            [this]()

            {

                skipByteRequested = true;

            });

    // TODO sps counter

}

QWidget* BinaryStreamReader::settingsWidget()

{

    return &_settingsWidget;

}

unsigned BinaryStreamReader::numOfChannels()

{

    return _numOfChannels;

}

void BinaryStreamReader::enable(bool enabled)

{

    if (enabled)

    {

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

                         this, &BinaryStreamReader::onDataReady);

    }

    else

    {

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

    }

}

void BinaryStreamReader::pause(bool enabled)

{

    paused = enabled;

}

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;

        case NumberFormat_uint16:

            sampleSize = 2;

            readSample = &BinaryStreamReader::readSampleAs<quint16>;

            break;

        case NumberFormat_int16:

            sampleSize = 2;

            readSample = &BinaryStreamReader::readSampleAs<qint16>;

            break;

        case NumberFormat_uint32:

            sampleSize = 4;

            readSample = &BinaryStreamReader::readSampleAs<quint32>;

            break;

        case NumberFormat_int32:

            sampleSize = 4;

            readSample = &BinaryStreamReader::readSampleAs<qint32>;

            break;

        case NumberFormat_float:

            sampleSize = 4;

            readSample = &BinaryStreamReader::readSampleAs<float>;

            break;

    }

}

void BinaryStreamReader::onNumOfChannelsChanged(unsigned value)

{

    _numOfChannels = value;

}

void BinaryStreamReader::onDataReady()

{

    // a package is a set of channel data like {CHAN0_SAMPLE, CHAN1_SAMPLE...}

    int packageSize = sampleSize * _numOfChannels;

    int bytesAvailable = _device->bytesAvailable();

    int numOfPackagesToRead =

        (bytesAvailable - (bytesAvailable % packageSize)) / packageSize;

    if (paused)

    {

        // read and discard data

        _device->read(numOfPackagesToRead*packageSize);

        return;

    }

    if (bytesAvailable > 0 && skipByteRequested)

    {

        _device->read(1);

        skipByteRequested = false;

        bytesAvailable--;

    }

    if (bytesAvailable < packageSize) return;

    double* channelSamples = new double[numOfPackagesToRead*_numOfChannels];

    for (int i = 0; i < numOfPackagesToRead; i++)

    {

        for (unsigned int ci = 0; ci < _numOfChannels; ci++)

        {

            // channelSamples[ci].replace(i, (this->*readSample)());

            channelSamples[ci*numOfPackagesToRead+i] = (this->*readSample)();

        }

    }

    for (unsigned int ci = 0; ci < _numOfChannels; ci++)

    {

        addChannelData(ci,

                       channelSamples + ci*numOfPackagesToRead,

                       numOfPackagesToRead);

    }

    emit dataAdded();

    delete channelSamples;

}

template<typename T> double BinaryStreamReader::readSampleAs()

{

    T data;

    _device->read((char*) &data, sizeof(data));

    if (_settingsWidget.endianness() == LittleEndian)

    {

        data = qFromLittleEndian(data);

    }

    else

    {

        data = qFromBigEndian(data);

    }

    return double(data);

}

void BinaryStreamReader::addChannelData(unsigned int channel,

                                        double* data, unsigned size)

{

    _channelMan->addChannelData(channel, data, size);

    sampleCount += size;

}

/*

  Copyright © 2016 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

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

*/

#ifndef BINARYSTREAMREADER_H

#define BINARYSTREAMREADER_H

#include "abstractreader.h"

#include "binarystreamreadersettings.h"

/**

 * 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, ChannelManager* channelMan, QObject *parent = 0);

    QWidget* settingsWidget();

    unsigned numOfChannels();

    void enable(bool enabled = true);

public slots:

    void pause(bool);

private:

    BinaryStreamReaderSettings _settingsWidget;

    unsigned _numOfChannels;

    unsigned sampleSize;

    bool paused;

    bool skipByteRequested;

    unsigned sampleCount; ///< used for sps counter

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

     */

    template<typename T> double readSampleAs();

    // `data` contains i th channels data

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

private slots:

    void onNumberFormatChanged(NumberFormat numberFormat);

    void onNumOfChannelsChanged(unsigned value);

    void onDataReady();

};

#endif // BINARYSTREAMREADER_H

/*

  Copyright © 2016 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  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 "binarystreamreadersettings.h"

#include "ui_binarystreamreadersettings.h"

#include "utils.h"

BinaryStreamReaderSettings::BinaryStreamReaderSettings(QWidget *parent) :

    QWidget(parent),

    ui(new Ui::BinaryStreamReaderSettings)

{

    ui->setupUi(this);

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

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

            [this](int value)

            {

                emit numOfChannelsChanged(value);

            });

    connect(ui->nfBox, SIGNAL(selectionChanged(NumberFormat)),

            this, SIGNAL(numberFormatChanged(NumberFormat)));

    connect(ui->pbSkipByte, SIGNAL(clicked()), this, SIGNAL(skipByteRequested()));

}

BinaryStreamReaderSettings::~BinaryStreamReaderSettings()

{

    delete ui;

}

unsigned BinaryStreamReaderSettings::numOfChannels()

{

    return ui->spNumOfChannels->value();

}

NumberFormat BinaryStreamReaderSettings::numberFormat()

{

    return ui->nfBox->currentSelection();

}

Endianness BinaryStreamReaderSettings::endianness()

{

    return ui->endiBox->currentSelection();

}

/*

  Copyright © 2016 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

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

*/

#ifndef BINARYSTREAMREADERSETTINGS_H

#define BINARYSTREAMREADERSETTINGS_H

#include <QWidget>

#include "numberformatbox.h"

#include "endiannessbox.h"

namespace Ui {

class BinaryStreamReaderSettings;

}

class BinaryStreamReaderSettings : public QWidget

{

    Q_OBJECT

public:

    explicit BinaryStreamReaderSettings(QWidget *parent = 0);

    ~BinaryStreamReaderSettings();

    unsigned numOfChannels();

    NumberFormat numberFormat();

    Endianness endianness();

signals:

    void numOfChannelsChanged(unsigned);

    void numberFormatChanged(NumberFormat);

    void skipByteRequested();

private:

    Ui::BinaryStreamReaderSettings *ui;

};

#endif // BINARYSTREAMREADERSETTINGS_H

<?xml version="1.0" encoding="UTF-8"?>

<ui version="4.0">

 <class>BinaryStreamReaderSettings</class>

 <widget class="QWidget" name="BinaryStreamReaderSettings">