src/barchart.cpp

  src/barscaledraw.cpp

  src/numberformat.cpp

  src/updatechecker.cpp

  src/versionnumber.cpp

  src/updatecheckdialog.cpp

  src/samplepack.cpp

  src/source.cpp

  src/sink.cpp

  src/samplecounter.cpp

  src/ledwidget.cpp

  src/datatextview.cpp

  misc/windows_icon.rc

  ${UI_FILES}

  ${RES_FILES}

  )

# Use the Widgets module from Qt 5.

target_link_libraries(${PROGRAM_NAME}

  ${QWT_LIBRARY}

  )

qt5_use_modules(${PROGRAM_NAME} Widgets SerialPort Network)

if (BUILD_QWT)

    src/binarystreamreader.cpp \

    src/binarystreamreadersettings.cpp \

    src/asciireadersettings.cpp \

    src/asciireader.cpp \

    src/demoreader.cpp \

    src/framedreader.cpp \

    src/plotmanager.cpp \

    src/numberformat.cpp \

    src/recordpanel.cpp \

    src/updatechecker.cpp \

    src/updatecheckdialog.cpp \

    src/demoreadersettings.cpp \

HEADERS += \

    src/mainwindow.h \

    src/utils.h \

    src/portcontrol.h \

    src/floatswap.h \

    src/plot.h \

    src/zoomer.h \

    src/hidabletabwidget.h \

    src/framebuffer.h \

    src/scalepicker.h \

    src/scalezoomer.h \

    src/binarystreamreadersettings.h \

    src/asciireadersettings.h \

    src/asciireader.h \

    src/demoreader.h \

    src/framedreader.h \

    src/plotmanager.h \

    src/setting_defines.h \

    src/numberformat.h \

    src/recordpanel.h \

    src/updatechecker.h \

    src/updatecheckdialog.h \

    src/demoreadersettings.h \

FORMS += \

    src/mainwindow.ui \

    src/about_dialog.ui \

    src/portcontrol.ui \

    src/snapshotview.ui \

    src/commandpanel.ui \

    src/commandwidget.ui \

    src/dataformatpanel.ui \

    src/plotcontrolpanel.ui \

    src/numberformatbox.ui \

    src/endiannessbox.ui \

/*

  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, QObject* parent) :

    QObject(parent)

{

    _device = device;

}

void AbstractReader::pause(bool enabled)

{

    paused = enabled;

}

void AbstractReader::enable(bool enabled)

{

    if (enabled)

    {

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

                         this, &AbstractReader::onDataReady);

    }

    else

    {

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

        disconnectSinks();

    }

}

/*

  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.

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

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

/*

  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.

unsigned AsciiReader::numChannels() const

{

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

    // do not allow '0'

    return _numChannels == 0 ? 1 : _numChannels;

}

void AsciiReader::enable(bool enabled)

{

    if (enabled)

    {

        firstReadAfterEnable = true;

    }

}

{

    while(_device->canReadLine())

    {

        // discard only once when we just started reading

        if (firstReadAfterEnable)

        {

            firstReadAfterEnable = false;

            continue;

        }

        // discard data if paused

        if (paused)

        {

            continue;

                    // TODO: is `numOfChannelsChanged` signal still used?

                    emit numOfChannelsChanged(nc);

                }

            }

            Q_ASSERT(samples->numChannels() == _numChannels);

            // commit data

            feedOut(*samples);

            delete samples;

        }

    }

}

SamplePack* AsciiReader::parseLine(const QString& line) const

{

    auto separatedValues = line.split(delimiter, QString::SkipEmptyParts);

    unsigned numComingChannels = separatedValues.length();

    // check number of channels (skipped if auto num channels is enabled)

    if ((!numComingChannels) || (!autoNumOfChannels && numComingChannels != _numChannels))

    {

        qWarning() << "Line parsing error: invalid number of channels!";

        qWarning() << "Read line: " << line;

/*

  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.

    /// Loads settings from a `QSettings`.

    void loadSettings(QSettings* settings);

private:

    AsciiReaderSettings _settingsWidget;

    unsigned _numChannels;

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

    unsigned autoNumOfChannels;

    QChar delimiter; ///< selected column delimiter

    bool firstReadAfterEnable = false;

private slots:

    /**

     * Parses given line and returns sample pack.

     *

     * Returns `nullptr` in case of error.

     */

    SamplePack* parseLine(const QString& line) const;

};

#endif // ASCIIREADER_H

/*

  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.

            Q_ASSERT(1); // never

            break;

    }

}

void BinaryStreamReader::onNumOfChannelsChanged(unsigned value)

{

    _numChannels = value;

    updateNumChannels();

    emit numOfChannelsChanged(value);

}

{

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

    // skip 1 byte if requested

    if (skipByteRequested && bytesAvailable > 0)

    {

        _device->read(1);

        skipByteRequested = false;

        bytesAvailable--;

    }

    // skip 1 sample (channel) if requested

    {

        _device->read(sampleSize);

        skipSampleRequested = false;

        bytesAvailable -= sampleSize;

    }

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

    if (paused)

    {

        // read and discard data

    }

    // actual reading

    SamplePack samples(numOfPackagesToRead, _numChannels);

    {

        {

            samples.data(ci)[i] = (this->*readSample)();

        }

    }

    feedOut(samples);

}

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

{

    T data;

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

    if (_settingsWidget.endianness() == LittleEndian)

    {

        data = qFromLittleEndian(data);

    }

/*

  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.

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

private slots:

    void onNumberFormatChanged(NumberFormat numberFormat);

    void onNumOfChannelsChanged(unsigned value);

};

#endif // BINARYSTREAMREADER_H

/*

  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.

    QWidget(parent),

    ui(new Ui::DataFormatPanel),

    bsReader(port, this),

    asciiReader(port, this),

    framedReader(port, this),

    demoReader(port, this)

{

    ui->setupUi(this);

    serialPort = port;

    paused = false;

    readerBeforeDemo = nullptr;

    // initalize default reader

    currentReader = &bsReader;

    bsReader.enable();

    ui->rbBinary->setChecked(true);

    ui->horizontalLayout->addWidget(bsReader.settingsWidget(), 1);

    // initalize reader selection buttons

    connect(ui->rbBinary, &QRadioButton::toggled, [this](bool checked)

            {

                if (checked) selectReader(&bsReader);

            });

    // switch the settings widget

    ui->horizontalLayout->removeWidget(currentReader->settingsWidget());

    currentReader->settingsWidget()->hide();

    ui->horizontalLayout->addWidget(reader->settingsWidget(), 1);

    reader->settingsWidget()->show();

    reader->pause(paused);

    currentReader = reader;

    emit sourceChanged(currentReader);

}

void DataFormatPanel::saveSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_DataFormat);

    // save selected data format (current reader)

    QString format;

    AbstractReader* selectedReader = isDemoEnabled() ? readerBeforeDemo : currentReader;

    if (selectedReader == &bsReader)

    {

        format = "binary";

    }

    else if (selectedReader == &asciiReader)

/*

  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 DATAFORMATPANEL_H

#define DATAFORMATPANEL_H

#include <QWidget>

#include <QButtonGroup>

#include <QSerialPort>

#include <QList>

#include <QSettings>

#include <QtGlobal>

#include "binarystreamreader.h"

#include "asciireader.h"

#include "demoreader.h"

#include "framedreader.h"

#include "datarecorder.h"

namespace Ui {

class DataFormatPanel : public QWidget

{

    Q_OBJECT

public:

    explicit DataFormatPanel(QSerialPort* port, QWidget* parent = 0);

    ~DataFormatPanel();

    /// Returns currently selected number of channels

    unsigned numChannels() const;

    /// Returns active source (reader)

    Source* activeSource();

    /// Stores data format panel settings into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads data format panel settings from a `QSettings`.

    void loadSettings(QSettings* settings);

public slots:

    void pause(bool);

    void enableDemo(bool); // demo shouldn't be enabled when port is open

signals:

    /// Active (selected) reader has changed.

    void sourceChanged(Source* source);

    QSerialPort* serialPort;

    BinaryStreamReader bsReader;

    AsciiReader asciiReader;

    FramedReader framedReader;

    /// Currently selected reader

    AbstractReader* currentReader;

    /// Disable current reader and enable a another one

    void selectReader(AbstractReader* reader);

    bool paused;

    DemoReader demoReader;

    AbstractReader* readerBeforeDemo;

    bool isDemoEnabled() const;

};

#endif // DATAFORMATPANEL_H

/*

  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.

    return &_settingsWidget;

}

void DemoReader::enable(bool enabled)

{

    if (enabled)

    {

        timer.start();

    }

    else

    {

        timer.stop();

    }

}

unsigned DemoReader::numChannels() const

{

    return _numChannels;

}

void DemoReader::setNumChannels(unsigned value)

{

    _settingsWidget.setNumChannels(value);

}

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