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.

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

/*

  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

#include "abstractreader.h"

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

    QObject(parent)

{

    _device = device;

}

void AbstractReader::pause(bool enabled)

{

    paused = enabled;

}

    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

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

    /**

     * 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

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;

            // commit data

            feedOut(*samples);

            delete samples;

        }

    }

}

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

{

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

    unsigned numComingChannels = separatedValues.length();

/*

  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

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

/*

  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

{

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

/*

  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

     *

     * @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

{

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

    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;

/*

  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

  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"

    ~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:

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

};

/*

  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

    {

        timer.start();

    }

    else

    {

        timer.stop();

    }

}

unsigned DemoReader::numChannels() const

{

    return _numChannels;

}

void DemoReader::onNumChannelsChanged(unsigned value)

{

    _numChannels = value;

    updateNumChannels();

}

{

    // intentionally empty, required by AbstractReader

}

/*

  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

    DemoReaderSettings _settingsWidget;

    unsigned _numChannels;

    QTimer timer;

    int count;

private slots:

    void demoTimerTimeout();

    void onNumChannelsChanged(unsigned value);

};

#endif // DEMOREADER_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

        frameSize = value;

    }

    checkSettings();

    reset();

}

{

    // loop until we run out of bytes or more bytes is required

    unsigned bytesAvailable;

    while ((bytesAvailable = _device->bytesAvailable()))

    {

        if (!gotSync) // read sync word

        {

            char c;

            _device->getChar(&c);

            if (c == syncWord[sync_i]) // correct sync byte?

            {

                sync_i++;

                if (sync_i == (unsigned) syncWord.length())

                {

                    gotSync = true;

            }

        }

        else if (hasSizeByte && !gotSize) // skipped if fixed frame size

        {

            frameSize = 0;

            _device->getChar((char*) &frameSize);

            if (frameSize == 0) // check size

            {

                qCritical() << "Frame size is 0!";

                reset();

            }

            {

                break;

            }

            else // read data bytes and checksum

            {

                readFrameDataAndCheck();

                reset();

            }

        }

    }

}

void FramedReader::reset()

{

    sync_i = 0;

    gotSync = false;

// Important: this function assumes device has enough bytes to read a full frames data and checksum

void FramedReader::readFrameDataAndCheck()

{

    // if paused just read and waste data

    if (paused)

    {

        return;

    }

    // a package is 1 set of samples for all channels

    unsigned numOfPackagesToRead = frameSize / (_numChannels * sampleSize);

    SamplePack samples(numOfPackagesToRead, _numChannels);

/*

  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

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

};

    secondaryPlot(NULL),

    snapshotMan(this, &stream),

    commandPanel(&serialPort),

    dataFormatPanel(&serialPort),

    recordPanel(&stream),

    textView(&stream),

{

    ui->setupUi(this);

    plotMan = new PlotManager(ui->plotArea, &plotMenu, &stream);

    ui->tabWidget->insertTab(0, &portControl, "Port");

                      plotControlPanel.yMin(), plotControlPanel.yMax());

    plotMan->setXAxis(plotControlPanel.xAxisAsIndex(),

                      plotControlPanel.xMin(), plotControlPanel.xMax());

    plotMan->setNumOfSamples(numOfSamples);

    plotMan->setPlotWidth(plotControlPanel.plotWidth());

    // Init sps (sample per second) counter

    spsLabel.setText("0sps");

    ui->statusBar->addPermanentWidget(&spsLabel);

    connect(&sampleCounter, &SampleCounter::spsChanged,

            this, &MainWindow::onSpsChanged);

    // init demo

    QObject::connect(ui->actionDemoMode, &QAction::toggled,

                     this, &MainWindow::enableDemo);

    QObject::connect(ui->actionDemoMode, &QAction::toggled,

                     plotMan, &PlotManager::showDemoIndicator);

void MainWindow::onPortToggled(bool open)

{

    // make sure demo mode is disabled

    if (open && isDemoRunning()) enableDemo(false);

    ui->actionDemoMode->setEnabled(!open);

}

void MainWindow::onSourceChanged(Source* source)

{

    source->connectSink(&stream);