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

}

void AbstractReader::addData(double* samples, unsigned length)

{

    _channelMan->addData(samples, length);

    sampleCount += length;

}

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

    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;

    /// Should be called with read data

    void addData(double* samples, unsigned length);

private:

    const int SPS_UPDATE_TIMEOUT = 1;  // second

    ChannelManager* _channelMan;

    unsigned sampleCount;

    unsigned samplesPerSecond;

    QTimer spsTimer;

                        // TODO: emit channel color changed

                    }

                    break;

                case Qt::CheckStateRole:

                    if (col == ChannelInfoModel::COLUMN_VISIBILITY)

                    {

                        // TODO: emit visibility

                    }

                    break;

            }

        }

        // emit channelNameChanged(i, channelName(i));

    }

}

void ChannelManager::addData(double* data, unsigned size)

{

    Q_ASSERT(size % _numOfChannels == 0);

    int n = size / _numOfChannels;

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

    {

        channelBuffers[ci]->addSamples(&data[ci*n], n);

    }

}

void ChannelManager::saveSettings(QSettings* settings)

{

    _infoModel.saveSettings(settings);

}

void ChannelManager::loadSettings(QSettings* settings)

{

    _infoModel.loadSettings(settings);

}

{

    Q_OBJECT

public:

    explicit ChannelManager(unsigned numberOfChannels, unsigned numberOfSamples, QObject *parent = 0);

    ~ChannelManager();

    unsigned numOfChannels();

    unsigned numOfSamples();

    FrameBuffer* channelBuffer(unsigned channel);

    // QStringListModel* channelNames();

    QString channelName(unsigned channel);

    /// Stores channel names into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads channel names from a `QSettings`.

    void loadSettings(QSettings* settings);

    /// Returns a model that manages channel information (name, color etc)

    ChannelInfoModel* infoModel();

    /// Returns a list of channel names

    QStringList channelNames();

signals:

    void numOfChannelsChanged(unsigned value);

    void numOfSamplesChanged(unsigned value);

    void channelNameChanged(unsigned channel, QString name);

public slots:

    void setNumOfChannels(unsigned number);

    void setNumOfSamples(unsigned number);

    /**

     * Add data for all channels.

     *

     * All channels data is provided in a single array which contains equal

     * number of samples for all channels. Structure is as shown below:

     *

     * [CH0_SMP0, CH0_SMP1 ... CH0_SMPN, CH1_SMP0, CH1_SMP1, ... , CHN_SMPN]

     *

     * @param data samples for all channels

     * @param size size of `data`, must be multiple of `numOfChannels`

     */

    void addData(double* data, unsigned size);

private:

    unsigned _numOfChannels;

    unsigned _numOfSamples;

    QList<FrameBuffer*> channelBuffers;

    // QStringListModel _channelNames;

    ChannelInfoModel _infoModel;

/*

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

#include "ui_dataformatpanel.h"

#include <QRadioButton>

#include <QtEndian>

#include <QMap>

#include <QtDebug>

#include "setting_defines.h"

#include "floatswap.h"

DataFormatPanel::DataFormatPanel(QSerialPort* port,

                                 ChannelManager* channelMan,

                                 QWidget *parent) :

    QWidget(parent),

    ui(new Ui::DataFormatPanel),

    bsReader(port, channelMan, this),

    asciiReader(port, channelMan, this),

    framedReader(port, channelMan, this),

    demoReader(port, channelMan, this)

{

    ui->setupUi(this);

    serialPort = port;

    _channelMan = channelMan;

    paused = false;

    // initalize default reader

    currentReader = &bsReader;

    bsReader.enable();

    ui->rbBinary->setChecked(true);

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

    connect(&bsReader, SIGNAL(numOfChannelsChanged(unsigned)),

            this, SIGNAL(numOfChannelsChanged(unsigned)));

    connect(&bsReader, SIGNAL(samplesPerSecondChanged(unsigned)),

            this, SIGNAL(samplesPerSecondChanged(unsigned)));

    // initalize reader selection buttons

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

            {

                if (checked) selectReader(&bsReader);

            });

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

            {

                if (checked) selectReader(&asciiReader);

            });

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

            {

                if (checked) selectReader(&framedReader);

            });

    // re-purpose numofchannels settings from actual reader settings to demo reader

    connect(this, &DataFormatPanel::numOfChannelsChanged,

            &demoReader, &DemoReader::setNumOfChannels);

}

DataFormatPanel::~DataFormatPanel()

{

    delete ui;

}

unsigned DataFormatPanel::numOfChannels()

{

    return currentReader->numOfChannels();

}

void DataFormatPanel::pause(bool enabled)

{

    paused = enabled;

    currentReader->pause(enabled);

    demoReader.pause(enabled);

}

void DataFormatPanel::enableDemo(bool enabled)

{

    if (enabled)

    {

        demoReader.enable();

        connect(&demoReader, &DemoReader::samplesPerSecondChanged,

                this, &DataFormatPanel::samplesPerSecondChanged);

    }

    else

    {

        demoReader.enable(false);

        disconnect(&demoReader, 0, this, 0);

    }

}

void DataFormatPanel::selectReader(AbstractReader* reader)

{

    currentReader->enable(false);

    reader->enable();

    // re-connect signals

    disconnect(currentReader, 0, this, 0);

    connect(reader, SIGNAL(numOfChannelsChanged(unsigned)),

            this, SIGNAL(numOfChannelsChanged(unsigned)));

    connect(reader, SIGNAL(samplesPerSecondChanged(unsigned)),

            this, SIGNAL(samplesPerSecondChanged(unsigned)));

    // switch the settings widget

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

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

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

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

    // notify if number of channels is different

    if (currentReader->numOfChannels() != reader->numOfChannels())

    {

        emit numOfChannelsChanged(reader->numOfChannels());

    }

    // pause

    reader->pause(paused);

    currentReader = reader;

}

void DataFormatPanel::saveSettings(QSettings* settings)

/*

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

#include <QSerialPort>

class DataFormatPanel : public QWidget

{

    Q_OBJECT

public:

    explicit DataFormatPanel(QSerialPort* port,

                             ChannelManager* channelMan,

                             QWidget *parent = 0);

    ~DataFormatPanel();

    /// Returns currently selected number of channels

    unsigned numOfChannels();

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

    void numOfChannelsChanged(unsigned);

    void samplesPerSecondChanged(unsigned);

private:

    Ui::DataFormatPanel *ui;

    QSerialPort* serialPort;

    ChannelManager* _channelMan;

    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;

};

#endif // DATAFORMATPANEL_H

    QObject::connect(&portControl, &PortControl::portToggled,

                     this, &MainWindow::onPortToggled);

    connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,

            this, &MainWindow::onNumOfSamplesChanged);

    connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,

            plotMan, &PlotManager::onNumOfSamplesChanged);

    connect(&plotControlPanel, &PlotControlPanel::scaleChanged,

            plotMan, &PlotManager::setAxis);

    QObject::connect(ui->actionClear, SIGNAL(triggered(bool)),

                     this, SLOT(clearPlot()));

    QObject::connect(snapshotMan.takeSnapshotAction(), &QAction::triggered,

                     plotMan, &PlotManager::flashSnapshotOverlay);

    // init port signals

    QObject::connect(&(this->serialPort), SIGNAL(error(QSerialPort::SerialPortError)),

                     this, SLOT(onPortError(QSerialPort::SerialPortError)));

    // TODO: `replot` must be triggered from ChannelManager

    // init data format and reader

                     plotMan, &PlotManager::replot);

    QObject::connect(ui->actionPause, &QAction::triggered,

                     &dataFormatPanel, &DataFormatPanel::pause);

    // init data arrays and plot

    numOfSamples = plotControlPanel.numOfSamples();

    unsigned numOfChannels = dataFormatPanel.numOfChannels();

    channelMan.setNumOfSamples(numOfSamples);

    channelMan.setNumOfChannels(dataFormatPanel.numOfChannels());

    connect(&dataFormatPanel, &DataFormatPanel::numOfChannelsChanged,

            &channelMan, &ChannelManager::setNumOfChannels);

    connect(&channelMan, &ChannelManager::numOfChannelsChanged,

            this, &MainWindow::onNumOfChannelsChanged);

    plotControlPanel.setChannelInfoModel(channelMan.infoModel());

    // init curve list

    for (unsigned int i = 0; i < numOfChannels; i++)

    {

        plotMan->addCurve(channelMan.channelName(i), channelMan.channelBuffer(i));