src/numberformatbox.ui

  src/endiannessbox.ui

  src/binarystreamreadersettings.ui

  src/asciireadersettings.ui

  src/framedreadersettings.ui

  src/numberformatbox.cpp

  src/endiannessbox.cpp

  src/abstractreader.cpp

  src/binarystreamreader.cpp

  src/binarystreamreadersettings.cpp

  src/asciireader.cpp

  src/asciireadersettings.cpp

  src/demoreader.cpp

  src/framedreader.cpp

  src/framedreadersettings.cpp

def frame_test(port, fixed_size=False, hasChecksum=True):

    """Sends binary data in framed format."""

    SYNCWORD = [0xAA, 0xBB]

    NUMSAMPLES = 10

    SIZE = NUMSAMPLES * 4 # integer

    if fixed_size:

        HEADER = bytes(SYNCWORD)

    else:

        HEADER = bytes(SYNCWORD + [SIZE])

    i = 0

    checksum = 0

    bytesent = 0

    while True:

        if i > 100: i = 0

        if bytesent == 0: # beginning of a frame?

            os.write(port, HEADER)

        os.write(port, struct.pack('<I', i))

        bytesent += 4

        checksum += i

        i += 1

        if bytesent == SIZE: # end of a frame

            if hasChecksum:

                data = struct.pack('<I', checksum)[:1]

                os.write(port, data)

            checksum = 0

            bytesent = 0

        time.sleep(0.1)

        # float_sine(master)

        frame_test(master)

        # ascii_test(master)

    src/plotcontrolpanel.cpp \

    src/numberformatbox.cpp \

    src/endiannessbox.cpp \

    src/framedreadersettings.cpp \

    src/abstractreader.cpp \

    src/binarystreamreader.cpp \

    src/binarystreamreadersettings.cpp \

    src/asciireadersettings.cpp \

    src/asciireader.cpp \

    src/demoreader.cpp \

    src/framedreader.cpp

    src/plotcontrolpanel.h \

    src/numberformatbox.h \

    src/endiannessbox.h \

    src/framedreadersettings.h \

    src/abstractreader.h \

    src/binarystreamreader.h \

    src/binarystreamreadersettings.h \

    src/asciireadersettings.h \

    src/asciireader.h \

    src/demoreader.h \

    src/framedreader.h

    src/plotcontrolpanel.ui \

    src/numberformatbox.ui \

    src/endiannessbox.ui \

    src/framedreadersettings.ui \

    src/binarystreamreadersettings.ui \

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

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

    QObject(parent)

{

    _device = device;

    _channelMan = channelMan;

    // initialize sps counter

    sampleCount = 0;

    samplesPerSecond = 0;

    QObject::connect(&spsTimer, &QTimer::timeout,

                     this, &AbstractReader::spsTimerTimeout);

    // TODO: start sps timer when reader is enabled

    spsTimer.start(SPS_UPDATE_TIMEOUT * 1000);

}

void AbstractReader::spsTimerTimeout()

{

    unsigned currentSps = samplesPerSecond;

    samplesPerSecond = (sampleCount/numOfChannels())/SPS_UPDATE_TIMEOUT;

    if (currentSps != samplesPerSecond)

    {

        emit samplesPerSecondChanged(samplesPerSecond);

    }

    sampleCount = 0;

}

/*

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

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

    /// Implementing class should simply increase this count as samples are read

    unsigned sampleCount;

private:

    const int SPS_UPDATE_TIMEOUT = 1;  // second

    unsigned samplesPerSecond;

    QTimer spsTimer;

private slots:

    void spsTimerTimeout();

};

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

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>

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

   <property name="leftMargin">

    <number>0</number>

   </property>

   <property name="topMargin">

    <number>0</number>

   </property>

   <property name="rightMargin">

    <number>0</number>

   </property>

   <property name="bottomMargin">

    <number>0</number>

   </property>

   <item>

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

     <item>

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

       <property name="text">

        <string>Number Of Channels:</string>

       </property>

      </widget>

     </item>

     <item>

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

       <property name="minimumSize">

        <size>

         <width>60</width>

         <height>0</height>

        </size>

       </property>

       <property name="toolTip">

        <string>Select number of channels</string>

       </property>

       <property name="keyboardTracking">

        <bool>false</bool>

       </property>

       <property name="minimum">

        <number>1</number>

       </property>

       <property name="maximum">

        <number>32</number>

       </property>

      </widget>

     </item>

     <item>

      <spacer name="horizontalSpacer">

       <property name="orientation">

        <enum>Qt::Horizontal</enum>

       </property>

       <property name="sizeHint" stdset="0">

        <size>

         <width>1</width>

         <height>20</height>

        </size>

       </property>

      </spacer>

     </item>

    </layout>

   </item>

   <item>

    <spacer name="verticalSpacer">

     <property name="orientation">

      <enum>Qt::Vertical</enum>

     </property>

     <property name="sizeHint" stdset="0">

      <size>

       <width>20</width>

       <height>1</height>

      </size>

     </property>

    </spacer>

   </item>

  </layout>

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

            });

}

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.