tempo-plotter Changeset - e0c6c43cbcf5 · protofusion repositories

Changeset - e0c6c43cbcf5

Parent rev.

Child rev.

[Not reviewed]

recording

0 18 0

Hasan Yavuz ÖZDERYA - 9 years ago 2017-02-14 08:21:16
hy@ozderya.net

data recording mostly integrated and working

18 files changed with 166 insertions and 40 deletions:

src/abstractreader.cpp

src/abstractreader.h

src/asciireader.cpp

src/asciireader.h

src/binarystreamreader.cpp

src/binarystreamreader.h

src/channelmanager.cpp

src/channelmanager.h

src/dataformatpanel.cpp

src/dataformatpanel.h

src/demoreader.cpp

src/demoreader.h

src/framedreader.cpp

src/framedreader.h

src/mainwindow.cpp

src/mainwindow.h

src/recordpanel.cpp

src/recordpanel.h

0 comments (0 inline, 0 general)

src/abstractreader.cpp

➞

Show inline comments

 /*
   Copyright © 2017 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) :
 #include <QtDebug>
 AbstractReader::AbstractReader(QIODevice* device, ChannelManager* channelMan,
                                DataRecorder* recorder, QObject* parent) :
     QObject(parent)
+{
     _device = device;
     _channelMan = channelMan;
     _recorder = recorder;
     recording = false;
     // 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);
     if (recording)
+    {
         _recorder->addData(samples, length, numOfChannels());
         qDebug() << "adding data";
+    }
     sampleCount += length;
+}

src/abstractreader.h

➞

Show inline comments

 /*
   Copyright © 2017 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"
 #include "datarecorder.h"
 /**
  * All reader classes must inherit this class.
  */
 class AbstractReader : public QObject
+{
     Q_OBJECT
 public:
     explicit AbstractReader(QIODevice* device, ChannelManager* channelMan, QObject *parent = 0);
     explicit AbstractReader(QIODevice* device, ChannelManager* channelMan,
                             DataRecorder* recorder, QObject* parent = 0);
     bool recording;                 /// is recording started
     /**
      * 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;
     /**
      * @brief Starts sending data to recorder.
+     *
      * @note recorder must have been started!
      */
     void startRecording();
     /// Stops recording.
     void stopRecording();
 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;
     ChannelManager* _channelMan;
     DataRecorder* _recorder;
     QTimer spsTimer;
 private slots:
     void spsTimerTimeout();
 };
 #endif // ABSTRACTREADER_H

src/asciireader.cpp

➞

Show inline comments

 /*
   Copyright © 2017 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"
 /// If set to this value number of channels is determined from input
 #define NUMOFCHANNELS_AUTO   (0)
 AsciiReader::AsciiReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :
     AbstractReader(device, channelMan, parent)
 AsciiReader::AsciiReader(QIODevice* device, ChannelManager* channelMan,
                          DataRecorder* recorder, QObject* parent) :
     AbstractReader(device, channelMan, recorder, parent)
+{
     paused = false;
     discardFirstLine = true;
     _numOfChannels = _settingsWidget.numOfChannels();
     autoNumOfChannels = (_numOfChannels == NUMOFCHANNELS_AUTO);
     connect(&_settingsWidget, &AsciiReaderSettings::numOfChannelsChanged,
             [this](unsigned value)
+            {
                 _numOfChannels = value;
                 autoNumOfChannels = (_numOfChannels == NUMOFCHANNELS_AUTO);
                 if (!autoNumOfChannels)
+                {
                     emit numOfChannelsChanged(value);
+                }
             });
     connect(device, &QIODevice::aboutToClose, [this](){discardFirstLine=true;});
+}
 QWidget* AsciiReader::settingsWidget()
+{
     return &_settingsWidget;
+}
 unsigned AsciiReader::numOfChannels()
+{
     // do not allow '0'
     if (_numOfChannels == 0)
+    {
         return 1;
+    }
     else
+    {
         return _numOfChannels;
+    }
+}
 // TODO: this could be a part of AbstractReader
 void AsciiReader::enable(bool enabled)
+{
     if (enabled)
+    {
         discardFirstLine = true;
         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 only once when we just started reading
         if (discardFirstLine)
+        {
             discardFirstLine = false;
             continue;
+        }
         // discard data if paused
         if (paused)
+        {
             continue;
+        }
         // parse data
         line = line.trimmed();
         // Note: When data coming from pseudo terminal is buffered by
         // system CR is converted to LF for some reason. This causes
         // empty lines in the input when the port is just opened.
         if (line.isEmpty())
+        {
             continue;
+        }
         auto separatedValues = line.split(',');
         unsigned numReadChannels; // effective number of channels to read
         unsigned numComingChannels = separatedValues.length();
         if (autoNumOfChannels)
+        {
             // did number of channels changed?
             if (numComingChannels != _numOfChannels)
+            {
                 _numOfChannels = numComingChannels;
                 emit numOfChannelsChanged(numComingChannels);
+            }
             numReadChannels = numComingChannels;
+        }
         else if (numComingChannels >= _numOfChannels)
+        {
             numReadChannels = _numOfChannels;
+        }
         else // there is missing channel data
+        {
             numReadChannels = separatedValues.length();
             qWarning() << "Incoming data is missing data for some channels!";
+        }
         // parse read line
         double* channelSamples = new double[_numOfChannels]();
         for (unsigned ci = 0; ci < numReadChannels; ci++)
+        {
             bool ok;
             channelSamples[ci] = separatedValues[ci].toDouble(&ok);
             if (!ok)
+            {
                 qWarning() << "Data parsing error for channel: " << ci;
                 channelSamples[ci] = 0;
+            }
+        }
         // commit data
         addData(channelSamples, _numOfChannels);
         delete[] channelSamples;
+    }
+}
 void AsciiReader::saveSettings(QSettings* settings)
+{
     _settingsWidget.saveSettings(settings);
+}
 void AsciiReader::loadSettings(QSettings* settings)
+{
     _settingsWidget.loadSettings(settings);
+}

src/asciireader.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  Copyright © 2017 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 <QSettings>
 #include "abstractreader.h"
 #include "asciireadersettings.h"
 class AsciiReader : public AbstractReader
+{
     Q_OBJECT
 public:
     explicit AsciiReader(QIODevice* device, ChannelManager* channelMan, QObject *parent = 0);
     explicit AsciiReader(QIODevice* device, ChannelManager* channelMan,
                          DataRecorder* recorder, QObject *parent = 0);
     QWidget* settingsWidget();
     unsigned numOfChannels();
     void enable(bool enabled = true);
     /// Stores settings into a `QSettings`
     void saveSettings(QSettings* settings);
     /// Loads settings from a `QSettings`.
     void loadSettings(QSettings* settings);
 public slots:
     void pause(bool);
 private:
     AsciiReaderSettings _settingsWidget;
     unsigned _numOfChannels;
     /// number of channels will be determined from incoming data
     unsigned autoNumOfChannels;
     bool paused;
     // We may have (usually true) started reading in the middle of a
     // line, so its a better idea to just discard first line.
     bool discardFirstLine;
 private slots:
     void onDataReady();
 };
 #endif // ASCIIREADER_H

src/binarystreamreader.cpp

➞

Show inline comments

 /*
   Copyright © 2017 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)
 BinaryStreamReader::BinaryStreamReader(QIODevice* device, ChannelManager* channelMan,
                                        DataRecorder* recorder, QObject* parent) :
     AbstractReader(device, channelMan, recorder, parent)
+{
     paused = false;
     skipByteRequested = false;
     skipSampleRequested = false;
     _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 and sample buttons
     connect(&_settingsWidget, &BinaryStreamReaderSettings::skipByteRequested,
             [this]()
+            {
                 skipByteRequested = true;
             });
     connect(&_settingsWidget, &BinaryStreamReaderSettings::skipSampleRequested,
             [this]()
+            {
                 skipSampleRequested = 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;
         case NumberFormat_INVALID:
             Q_ASSERT(1); // never
             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();
     // skip 1 byte if requested
     if (bytesAvailable > 0 && skipByteRequested)
+    {
         _device->read(1);
         skipByteRequested = false;
         bytesAvailable--;
+    }
     // skip 1 sample (channel) if requested
     if (bytesAvailable >= (int) sampleSize && skipSampleRequested)
+    {
         _device->read(sampleSize);
         skipSampleRequested = false;
         bytesAvailable--;
+    }
     if (bytesAvailable < packageSize) return;
     int numOfPackagesToRead =
         (bytesAvailable - (bytesAvailable % packageSize)) / packageSize;
     if (paused)
+    {
         // read and discard data
         _device->read(numOfPackagesToRead*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)();
+        }
+    }
     addData(channelSamples, numOfPackagesToRead*_numOfChannels);
     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::saveSettings(QSettings* settings)
+{
     _settingsWidget.saveSettings(settings);
+}
 void BinaryStreamReader::loadSettings(QSettings* settings)
+{
     _settingsWidget.loadSettings(settings);
+}

src/binarystreamreader.h

➞

Show inline comments

 /*
   Copyright © 2017 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 <QSettings>
 #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);
     explicit BinaryStreamReader(QIODevice* device, ChannelManager* channelMan,
                                 DataRecorder* recorder, QObject *parent = 0);
     QWidget* settingsWidget();
     unsigned numOfChannels();
     void enable(bool enabled = true);
     /// Stores settings into a `QSettings`
     void saveSettings(QSettings* settings);
     /// Loads settings from a `QSettings`.
     void loadSettings(QSettings* settings);
 public slots:
     void pause(bool);
 private:
     BinaryStreamReaderSettings _settingsWidget;
     unsigned _numOfChannels;
     unsigned sampleSize;
     bool paused;
     bool skipByteRequested;
     bool skipSampleRequested;
     /// 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);
     void onDataReady();
 };
 #endif // BINARYSTREAMREADER_H

src/channelmanager.cpp

➞

Show inline comments

 /*
   Copyright © 2017 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 <QModelIndex>
 #include <QtDebug>
 #include "channelmanager.h"
 #include "setting_defines.h"
 ChannelManager::ChannelManager(unsigned numberOfChannels, unsigned numberOfSamples, QObject *parent) :
     QObject(parent),
     _infoModel(numberOfChannels)
+{
     _numOfChannels = numberOfChannels;
     _numOfSamples = numberOfSamples;
     _paused = false;
     for (unsigned int i = 0; i < numberOfChannels; i++)
+    {
         channelBuffers.append(new FrameBuffer(numberOfSamples));
+    }
     connect(&_infoModel, &ChannelInfoModel::dataChanged,
             this, &ChannelManager::onChannelInfoChanged);
+}
 ChannelManager::~ChannelManager()
+{
     for (auto buffer : channelBuffers)
+    {
         delete buffer;
+    }
+}
 unsigned ChannelManager::numOfChannels()
+{
     return channelBuffers.size();
+}
 unsigned ChannelManager::numOfSamples()
+{
     return _numOfSamples;
+}
 void ChannelManager::setNumOfChannels(unsigned number)
+{
     unsigned int oldNum = channelBuffers.size();
     if (number > oldNum)
+    {
         // add new channels
         for (unsigned int i = 0; i < number - oldNum; i++)
+        {
             channelBuffers.append(new FrameBuffer(_numOfSamples));
+        }
+    }
     else if(number < oldNum)
+    {
         // remove channels
         for (unsigned int i = oldNum-1; i > number-1; i--)
+        {
             delete channelBuffers.takeLast();
+        }
+    }
     _numOfChannels = number;
     _infoModel.setNumOfChannels(number);
     emit numOfChannelsChanged(number);
+}
 void ChannelManager::setNumOfSamples(unsigned number)
+{
     _numOfSamples = number;
     for (int ci = 0; ci < channelBuffers.size(); ci++)
+    {
         channelBuffers[ci]->resize(_numOfSamples);
+    }
     emit numOfSamplesChanged(number);
+}
 void ChannelManager::pause(bool paused)
+{
     _paused = paused;
+}
 FrameBuffer* ChannelManager::channelBuffer(unsigned channel)
+{
     return channelBuffers[channel];
+}
 ChannelInfoModel* ChannelManager::infoModel()
+{
     return &_infoModel;
+}
 QString ChannelManager::channelName(unsigned channel)
+{
     return _infoModel.data(_infoModel.index(channel, ChannelInfoModel::COLUMN_NAME),
                            Qt::DisplayRole).toString();
+}
 QStringList ChannelManager::channelNames()
+{
     QStringList list;
     for (unsigned ci = 0; ci < _numOfChannels; ci++)
+    {
         list << channelName(ci);
+    }
     return list;
+}
 void ChannelManager::onChannelInfoChanged(const QModelIndex & topLeft,
                                           const QModelIndex & bottomRight,
                                           const QVector<int> & roles)
+{
     int start = topLeft.row();
     int end = bottomRight.row();
     int col = topLeft.column();
     for (int ci = start; ci <= end; ci++)
+    {
         for (auto role : roles)
+        {
             switch (role)
+            {
                 case Qt::EditRole:
                     if (col == ChannelInfoModel::COLUMN_NAME)
+                    {
                         emit channelNameChanged(ci, channelName(ci));
+                    }
                     break;
                 case Qt::ForegroundRole:
                     if (col == ChannelInfoModel::COLUMN_NAME)
+                    {
                         // 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);
     if (_paused) return;
     int n = size / _numOfChannels;
     for (unsigned ci = 0; ci < _numOfChannels; ci++)
+    {
         channelBuffers[ci]->addSamples(&data[ci*n], n);
+    }
     emit dataAdded();
+}
 void ChannelManager::saveSettings(QSettings* settings)
+{
     _infoModel.saveSettings(settings);
+}
 void ChannelManager::loadSettings(QSettings* settings)
+{
     _infoModel.loadSettings(settings);
+}

src/channelmanager.h

➞

Show inline comments

 /*
   Copyright © 2017 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 CHANNELMANAGER_H
 #define CHANNELMANAGER_H
 #include <QObject>
 #include <QStringList>
 #include <QModelIndex>
 #include <QVector>
 #include <QSettings>
 #include "framebuffer.h"
 #include "channelinfomodel.h"
 class ChannelManager : public QObject
+{
     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);
     void dataAdded(); ///< emitted when data added to channel man.
 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);
     /// When paused `addData` does nothing.
     void pause(bool paused);
 private:
     unsigned _numOfChannels;
     unsigned _numOfSamples;
     bool _paused;
     QList<FrameBuffer*> channelBuffers;
     // QStringListModel _channelNames;
     ChannelInfoModel _infoModel;
     void addChannelName(QString name); ///< appends a new channel name at the end of list
 private slots:
     void onChannelInfoChanged(const QModelIndex & topLeft,
                               const QModelIndex & bottomRight,
                               const QVector<int> & roles = QVector<int> ());
 };
 #endif // CHANNELMANAGER_H

src/dataformatpanel.cpp

➞

Show inline comments

 /*
   Copyright © 2017 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 "dataformatpanel.h"
 #include "ui_dataformatpanel.h"
 #include <QRadioButton>
 #include <QtEndian>
 #include <QMap>
 #include <QtDebug>
 #include "utils.h"
 #include "setting_defines.h"
 #include "floatswap.h"
 DataFormatPanel::DataFormatPanel(QSerialPort* port,
                                  ChannelManager* channelMan,
                                  DataRecorder* recorder,
                                  QWidget *parent) :
     QWidget(parent),
     ui(new Ui::DataFormatPanel),
     bsReader(port, channelMan, this),
     asciiReader(port, channelMan, this),
     framedReader(port, channelMan, this),
     demoReader(port, channelMan, this)
     bsReader(port, channelMan, recorder, this),
     asciiReader(port, channelMan, recorder, this),
     framedReader(port, channelMan, recorder, this),
     demoReader(port, channelMan, recorder, this)
+{
     ui->setupUi(this);
     serialPort = port;
     _channelMan = channelMan;
     paused = false;
     demoEnabled = 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();
         demoReader.recording = currentReader->recording;
         connect(&demoReader, &DemoReader::samplesPerSecondChanged,
                 this, &DataFormatPanel::samplesPerSecondChanged);
+    }
     else
+    {
         demoReader.enable(false);
         disconnect(&demoReader, 0, this, 0);
+    }
     demoEnabled = enabled;
+}
 void DataFormatPanel::startRecording()
+{
     currentReader->recording = true;
     if (demoEnabled) demoReader.recording = true;
+}
 void DataFormatPanel::stopRecording()
+{
     currentReader->recording = false;
     if (demoEnabled) demoReader.recording = false;
+}
 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);
     reader->recording = currentReader->recording;
     currentReader = reader;
+}
 void DataFormatPanel::saveSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_DataFormat);
     // save selected format
     QString format;
     if (currentReader == &bsReader)
+    {
         format = "binary";
+    }
     else if (currentReader == &asciiReader)
+    {
         format = "ascii";
+    }
     else // framed reader
+    {
         format = "custom";
+    }
     settings->setValue(SG_DataFormat_Format, format);
     settings->endGroup();
     // save reader settings
     bsReader.saveSettings(settings);
     asciiReader.saveSettings(settings);
     framedReader.saveSettings(settings);
+}
 void DataFormatPanel::loadSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_DataFormat);
     // load selected format
     QString format = settings->value(
         SG_DataFormat_Format, QString()).toString();
     if (format == "binary")
+    {
         selectReader(&bsReader);
         ui->rbBinary->setChecked(true);
+    }
     else if (format == "ascii")
+    {
         selectReader(&asciiReader);
         ui->rbAscii->setChecked(true);
+    }
     else if (format == "custom")
+    {
         selectReader(&framedReader);
         ui->rbFramed->setChecked(true);
     } // else current selection stays
     settings->endGroup();
     // load reader settings
     bsReader.loadSettings(settings);
     asciiReader.loadSettings(settings);
     framedReader.loadSettings(settings);
+}

src/dataformatpanel.h

➞

Show inline comments

 /*
   Copyright © 2017 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 DATAFORMATPANEL_H
 #define DATAFORMATPANEL_H
 #include <QWidget>
 #include <QButtonGroup>
 #include <QTimer>
 #include <QSerialPort>
 #include <QList>
 #include <QSettings>
 #include <QtGlobal>
 #include "framebuffer.h"
 #include "channelmanager.h"
 #include "binarystreamreader.h"
 #include "asciireader.h"
 #include "demoreader.h"
 #include "framedreader.h"
 #include "datarecorder.h"
 namespace Ui {
 class DataFormatPanel;
+}
 class DataFormatPanel : public QWidget
+{
     Q_OBJECT
 public:
     explicit DataFormatPanel(QSerialPort* port,
                              ChannelManager* channelMan,
                              DataRecorder* recorder,
                              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
     /**
      * @brief Starts sending data to recorder.
+     *
      * @note recorder must have been started!
      */
     void startRecording();
     /// Stops recording.
     void stopRecording();
 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;
     bool demoEnabled;
     DemoReader demoReader;
 };
 #endif // DATAFORMATPANEL_H

src/demoreader.cpp

➞

Show inline comments

 /*
   Copyright © 2017 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 <math.h>
 #include "demoreader.h"
 #ifndef M_PI
 #define M_PI 3.14159265358979323846
 #endif
 DemoReader::DemoReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :
     AbstractReader(device, channelMan, parent)
 DemoReader::DemoReader(QIODevice* device, ChannelManager* channelMan,
                        DataRecorder* recorder, QObject* parent) :
     AbstractReader(device, channelMan, recorder, parent)
+{
     paused = false;
     _numOfChannels = 1;
     count = 0;
     timer.setInterval(100);
     QObject::connect(&timer, &QTimer::timeout,
                      this, &DemoReader::demoTimerTimeout);
+}
 QWidget* DemoReader::settingsWidget()
+{
     return NULL;
+}
 void DemoReader::enable(bool enabled)
+{
     if (enabled)
+    {
         timer.start();
+    }
     else
+    {
         timer.stop();
+    }
+}
 unsigned DemoReader::numOfChannels()
+{
     return _numOfChannels;
+}
 void DemoReader::setNumOfChannels(unsigned value)
+{
     _numOfChannels = value;
+}
 void DemoReader::pause(bool enabled)
+{
     paused = enabled;
+}
 void DemoReader::demoTimerTimeout()
+{
     const double period = 100;
     count++;
     if (count >= 100) count = 0;
     if (!paused)
+    {
         double* samples = new double[_numOfChannels];
         for (unsigned ci = 0; ci < _numOfChannels; ci++)
+        {
             // we are calculating the fourier components of square wave
             samples[ci] = 4*sin(2*M_PI*double((ci+1)*count)/period)/((2*(ci+1))*M_PI);
+        }
         addData(samples, _numOfChannels);
         delete[] samples;
+    }
+}

src/demoreader.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  Copyright © 2017 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 DEMOREADER_H
 #define DEMOREADER_H
 #include <QTimer>
 #include "abstractreader.h"
 /**
  * This is a special case of reader implementation and should be used
  * with care.
+ *
  * There is no settings widget. Number of channels should be set from
  * currently selected actual readers settings widget.
+ *
  * This reader should not be enabled when port is open!
  */
 class DemoReader : public AbstractReader
+{
     Q_OBJECT
 public:
     explicit DemoReader(QIODevice* device, ChannelManager* channelMan, QObject *parent = 0);
     explicit DemoReader(QIODevice* device, ChannelManager* channelMan,
                         DataRecorder* recorder, QObject* parent = 0);
     /// Demo reader is an exception so this function returns NULL
     QWidget* settingsWidget();
     unsigned numOfChannels();
     void enable(bool enabled = true);
 public slots:
     void pause(bool);
     /// Sets the number of channels, this doesn't trigger a `numOfChannelsChanged` signal.
     void setNumOfChannels(unsigned value);
 private:
     bool paused;
     unsigned _numOfChannels;
     QTimer timer;
     int count;
 private slots:
     void demoTimerTimeout();
 };
 #endif // DEMOREADER_H

src/framedreader.cpp

➞

Show inline comments

 /*
   Copyright © 2017 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 <QtEndian>
 #include "floatswap.h"
 #include "framedreader.h"
 FramedReader::FramedReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :
     AbstractReader(device, channelMan, parent)
 FramedReader::FramedReader(QIODevice* device, ChannelManager* channelMan,
                            DataRecorder* recorder, QObject* parent) :
     AbstractReader(device, channelMan, recorder, parent)
+{
     paused = false;
     // initial settings
     settingsInvalid = 0;
     _numOfChannels = _settingsWidget.numOfChannels();
     hasSizeByte = _settingsWidget.frameSize() == 0;
     frameSize = _settingsWidget.frameSize();
     syncWord = _settingsWidget.syncWord();
     checksumEnabled = _settingsWidget.isChecksumEnabled();
     onNumberFormatChanged(_settingsWidget.numberFormat());
     debugModeEnabled = _settingsWidget.isDebugModeEnabled();
     checkSettings();
     // init setting connections
     connect(&_settingsWidget, &FramedReaderSettings::numberFormatChanged,
             this, &FramedReader::onNumberFormatChanged);
     connect(&_settingsWidget, &FramedReaderSettings::numOfChannelsChanged,
             this, &FramedReader::onNumOfChannelsChanged);
     connect(&_settingsWidget, &FramedReaderSettings::syncWordChanged,
             this, &FramedReader::onSyncWordChanged);
     connect(&_settingsWidget, &FramedReaderSettings::frameSizeChanged,
             this, &FramedReader::onFrameSizeChanged);
     connect(&_settingsWidget, &FramedReaderSettings::checksumChanged,
             [this](bool enabled){checksumEnabled = enabled; reset();});
     connect(&_settingsWidget, &FramedReaderSettings::debugModeChanged,
             [this](bool enabled){debugModeEnabled = enabled;});
     // init reader state
     reset();
+}
 void FramedReader::enable(bool enabled)
+{
     if (enabled)
+    {
         connect(_device, &QIODevice::readyRead,
                 this, &FramedReader::onDataReady);
+    }
     else
+    {
         QObject::disconnect(_device, 0, this, 0);
+    }
+}
 QWidget* FramedReader::settingsWidget()
+{
     return &_settingsWidget;
+}
 unsigned FramedReader::numOfChannels()
+{
     return _numOfChannels;
+}
 void FramedReader::pause(bool enabled)
+{
     paused = enabled;
+}
 void FramedReader::onNumberFormatChanged(NumberFormat numberFormat)
+{
     switch(numberFormat)
+    {
         case NumberFormat_uint8:
             sampleSize = 1;
             readSample = &FramedReader::readSampleAs<quint8>;
             break;
         case NumberFormat_int8:
             sampleSize = 1;
             readSample = &FramedReader::readSampleAs<qint8>;
             break;
         case NumberFormat_uint16:
             sampleSize = 2;
             readSample = &FramedReader::readSampleAs<quint16>;
             break;
         case NumberFormat_int16:
             sampleSize = 2;
             readSample = &FramedReader::readSampleAs<qint16>;
             break;
         case NumberFormat_uint32:
             sampleSize = 4;
             readSample = &FramedReader::readSampleAs<quint32>;
             break;
         case NumberFormat_int32:
             sampleSize = 4;
             readSample = &FramedReader::readSampleAs<qint32>;
             break;
         case NumberFormat_float:
             sampleSize = 4;
             readSample = &FramedReader::readSampleAs<float>;
             break;
         case NumberFormat_INVALID:
             Q_ASSERT(1); // never
             break;
+    }
     checkSettings();
     reset();
+}
 void FramedReader::checkSettings()
+{
     // sync word is invalid (empty or missing a nibble at the end)
     if (!syncWord.size())
+    {
         settingsInvalid |= SYNCWORD_INVALID;
+    }
     else // sync word is valid
+    {
         settingsInvalid &= ~SYNCWORD_INVALID;
+    }
     // check if fixed frame size is multiple of a sample set size
     if (!hasSizeByte && frameSize % (_numOfChannels * sampleSize) != 0)
+    {
         settingsInvalid |= FRAMESIZE_INVALID;
+    }
     else
+    {
         settingsInvalid &= ~FRAMESIZE_INVALID;
+    }
     // show an error message
     if (settingsInvalid & SYNCWORD_INVALID)
+    {
         _settingsWidget.showMessage("Sync word is invalid!", true);
+    }
     else if (settingsInvalid & FRAMESIZE_INVALID)
+    {
         QString errorMessage =
             QString("Frame size must be multiple of %1 (#channels * sample size)!")\
             .arg(_numOfChannels * sampleSize);
         _settingsWidget.showMessage(errorMessage, true);
+    }
     else
+    {
         _settingsWidget.showMessage("All is well!");
+    }
+}
 void FramedReader::onNumOfChannelsChanged(unsigned value)
+{
     _numOfChannels = value;
     checkSettings();
     reset();
     emit numOfChannelsChanged(value);
+}
 void FramedReader::onSyncWordChanged(QByteArray word)
+{
     syncWord = word;
     checkSettings();
     reset();
+}
 void FramedReader::onFrameSizeChanged(unsigned value)
+{
     if (value == 0)
+    {
         hasSizeByte = true;
+    }
     else
+    {
         hasSizeByte = false;
         frameSize = value;
+    }
     checkSettings();
     reset();
+}
 void FramedReader::onDataReady()
+{
     if (settingsInvalid) return;
     // 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 (debugModeEnabled) qCritical() << "Missed " << sync_i+1 << "th sync byte.";
+            }
+        }
         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();
+            }
             else if (frameSize % (_numOfChannels * sampleSize) != 0)
+            {
                 qCritical() <<
                     QString("Frame size is not multiple of %1 (#channels * sample size)!") \
                     .arg(_numOfChannels * sampleSize);
                 reset();
+            }
             else
+            {
                 if (debugModeEnabled) qDebug() << "Frame size:" << frameSize;
                 gotSize = true;
+            }
+        }
         else // read data bytes
+        {
             // have enough data bytes? (+1 for checksum)
             if (bytesAvailable < (checksumEnabled ? frameSize+1 : frameSize))
+            {
                 break;
+            }
             else // read data bytes and checksum
+            {
                 readFrameDataAndCheck();
                 reset();
+            }
+        }
+    }
+}
 void FramedReader::reset()
+{
     sync_i = 0;
     gotSync = false;
     gotSize = false;
     if (hasSizeByte) frameSize = 0;
     calcChecksum = 0;
+}
 // 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)
+    {
         _device->read((checksumEnabled ? frameSize+1 : frameSize));
         return;
+    }
     // a package is 1 set of samples for all channels
     unsigned numOfPackagesToRead = frameSize / (_numOfChannels * sampleSize);
     double* channelSamples = new double[numOfPackagesToRead * _numOfChannels];
     for (unsigned i = 0; i < numOfPackagesToRead; i++)
+    {
         for (unsigned int ci = 0; ci < _numOfChannels; ci++)
+        {
             channelSamples[ci*numOfPackagesToRead+i] = (this->*readSample)();
+        }
+    }
     // read checksum
     unsigned rChecksum = 0;
     bool checksumPassed = false;
     if (checksumEnabled)
+    {
         _device->read((char*) &rChecksum, 1);
         calcChecksum &= 0xFF;
         checksumPassed = (calcChecksum == rChecksum);
+    }
     if (!checksumEnabled || checksumPassed)
+    {
         // commit data
         addData(channelSamples, numOfPackagesToRead*_numOfChannels);
+    }
     else
+    {
         qCritical() << "Checksum failed! Received:" << rChecksum << "Calculated:" << calcChecksum;
+    }
     delete[] channelSamples;
+}
 template<typename T> double FramedReader::readSampleAs()
+{
     T data;
     _device->read((char*) &data, sizeof(data));
     if (checksumEnabled)
+    {
         for (unsigned i = 0; i < sizeof(data); i++)
+        {
             calcChecksum += ((unsigned char*) &data)[i];
+        }
+    }
     if (_settingsWidget.endianness() == LittleEndian)
+    {
         data = qFromLittleEndian(data);
+    }
     else
+    {
         data = qFromBigEndian(data);
+    }
     return double(data);
+}
 void FramedReader::saveSettings(QSettings* settings)
+{
     _settingsWidget.saveSettings(settings);
+}
 void FramedReader::loadSettings(QSettings* settings)
+{
     _settingsWidget.loadSettings(settings);
+}

src/framedreader.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  Copyright © 2017 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 FRAMEDREADER_H
 #define FRAMEDREADER_H
 #include <QSettings>
 #include "abstractreader.h"
 #include "framedreadersettings.h"
 /**
  * Reads data in a customizable framed format.
  */
 class FramedReader : public AbstractReader
+{
     Q_OBJECT
 public:
     explicit FramedReader(QIODevice* device, ChannelManager* channelMan, QObject *parent = 0);
     explicit FramedReader(QIODevice* device, ChannelManager* channelMan,
                           DataRecorder* recorder, QObject *parent = 0);
     QWidget* settingsWidget();
     unsigned numOfChannels();
     void enable(bool enabled = true);
     /// Stores settings into a `QSettings`
     void saveSettings(QSettings* settings);
     /// Loads settings from a `QSettings`.
     void loadSettings(QSettings* settings);
 public slots:
     void pause(bool);
 private:
     /// bit wise fields for `settingsValid` member
     enum SettingInvalidFlag
+    {
         SYNCWORD_INVALID = 1,
         FRAMESIZE_INVALID = 2
     };
     // settings related members
     FramedReaderSettings _settingsWidget;
     unsigned _numOfChannels;
     unsigned sampleSize;
     bool paused;
     unsigned settingsInvalid;   /// settings are all valid if this is 0, if not no reading is done
     QByteArray syncWord;
     bool checksumEnabled;
     bool hasSizeByte;
     unsigned frameSize;
     bool debugModeEnabled;
     /// Checks the validity of syncWord and frameSize then shows an
     /// error message. Also updates `settingsInvalid`. If settings are
     /// valid `settingsInvalid` should be `0`.
     void checkSettings();
     // read state related members
     unsigned sync_i; /// sync byte index to be read next
     bool gotSync;    /// indicates if sync word is captured
     bool gotSize;    /// indicates if size is captured, ignored if size byte is disabled (fixed size)
     unsigned calcChecksum;
     void reset();    /// Resets the reading state. Used in case of error or setting change.
     /// points to the readSampleAs function for currently selected number format
     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 onDataReady();
     void onNumberFormatChanged(NumberFormat numberFormat);
     void onNumOfChannelsChanged(unsigned value);
     void onSyncWordChanged(QByteArray);
     void onFrameSizeChanged(unsigned);
 };
 #endif // FRAMEDREADER_H

src/mainwindow.cpp

➞

Show inline comments

 /*
   Copyright © 2017 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 "mainwindow.h"
 #include "ui_mainwindow.h"
 #include <QByteArray>
 #include <QApplication>
 #include <QFileDialog>
 #include <QMessageBox>
 #include <QFile>
 #include <QTextStream>
 #include <QMenu>
 #include <QDesktopServices>
 #include <QMap>
 #include <QtDebug>
 #include <qwt_plot.h>
 #include <limits.h>
 #include <cmath>
 #include <iostream>
 #include <plot.h>
 #include "framebufferseries.h"
 #include "utils.h"
 #include "defines.h"
 #include "version.h"
 #include "setting_defines.h"
 #if defined(Q_OS_WIN) && defined(QT_STATIC)
 #include <QtPlugin>
 Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin)
 #endif
 const QMap<int, QString> panelSettingMap({
         {0, "Port"},
         {1, "DataFormat"},
         {2, "Plot"},
         {3, "Commands"}
     });
 MainWindow::MainWindow(QWidget *parent) :
     QMainWindow(parent),
     ui(new Ui::MainWindow),
     aboutDialog(this),
     portControl(&serialPort),
     channelMan(1, 1, this),
     snapshotMan(this, &channelMan),
     commandPanel(&serialPort),
     dataFormatPanel(&serialPort, &channelMan),
     recordPanel(this)
     dataFormatPanel(&serialPort, &channelMan, &recorder),
     recordPanel(&recorder)
+{
     ui->setupUi(this);
     plotMan = new PlotManager(ui->plotArea, channelMan.infoModel());
     ui->tabWidget->insertTab(0, &portControl, "Port");
     ui->tabWidget->insertTab(1, &dataFormatPanel, "Data Format");
     ui->tabWidget->insertTab(2, &plotControlPanel, "Plot");
     ui->tabWidget->insertTab(3, &commandPanel, "Commands");
     ui->tabWidget->insertTab(4, &recordPanel, "Record");
     ui->tabWidget->setCurrentIndex(0);
     auto tbPortControl = portControl.toolBar();
     addToolBar(tbPortControl);
     addToolBar(recordPanel.toolbar());
     ui->plotToolBar->addAction(snapshotMan.takeSnapshotAction());
     ui->menuBar->insertMenu(ui->menuHelp->menuAction(), snapshotMan.menu());
     ui->menuBar->insertMenu(ui->menuHelp->menuAction(), commandPanel.menu());
     connect(&commandPanel, &CommandPanel::focusRequested, [this]()
+            {
                 this->ui->tabWidget->setCurrentWidget(&commandPanel);
             });
     tbPortControl->setObjectName("tbPortControl");
     ui->plotToolBar->setObjectName("tbPlot");
     setupAboutDialog();
     // init view menu
     for (auto a : plotMan->menuActions())
+    {
         ui->menuView->addAction(a);
+    }
     ui->menuView->addSeparator();
     QMenu* tbMenu = ui->menuView->addMenu("Toolbars");
     tbMenu->addAction(ui->plotToolBar->toggleViewAction());
     tbMenu->addAction(portControl.toolBar()->toggleViewAction());
     // init UI signals
     // Help menu signals
     QObject::connect(ui->actionHelpAbout, &QAction::triggered,
               &aboutDialog, &QWidget::show);
     QObject::connect(ui->actionReportBug, &QAction::triggered,
                      [](){QDesktopServices::openUrl(QUrl(BUG_REPORT_URL));});
     // File menu signals
     QObject::connect(ui->actionExportCsv, &QAction::triggered,
                      this, &MainWindow::onExportCsv);
     QObject::connect(ui->actionSaveSettings, &QAction::triggered,
                      this, &MainWindow::onSaveSettings);
     QObject::connect(ui->actionLoadSettings, &QAction::triggered,
                      this, &MainWindow::onLoadSettings);
     ui->actionQuit->setShortcutContext(Qt::ApplicationShortcut);
     QObject::connect(ui->actionQuit, &QAction::triggered,
                      this, &MainWindow::close);
     // port control signals
     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
     QObject::connect(&channelMan, &ChannelManager::dataAdded,
                      plotMan, &PlotManager::replot);
     QObject::connect(ui->actionPause, &QAction::triggered,
                      &dataFormatPanel, &DataFormatPanel::pause);
                      &channelMan, &ChannelManager::pause);
     QObject::connect(&recordPanel, &RecordPanel::recordStarted,
                      &dataFormatPanel, &DataFormatPanel::startRecording);
     QObject::connect(&recordPanel, &RecordPanel::recordStopped,
                      &dataFormatPanel, &DataFormatPanel::stopRecording);
     QObject::connect(ui->actionPause, &QAction::triggered,
                      [this](bool enabled)
+                     {
                          if (enabled && !recordPanel.recordPaused())
+                         {
                              dataFormatPanel.pause(true);
+                         }
                          else
+                         {
                              dataFormatPanel.pause(false);
+                         }
                      });
     QObject::connect(&recordPanel, &RecordPanel::recordPausedChanged,
                      [this](bool enabled)
+                     {
                          if (ui->actionPause->isChecked() && enabled)
+                         {
                              dataFormatPanel.pause(false);
+                         }
                      });
     // 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));
+    }
     // init auto scale
     plotMan->setAxis(plotControlPanel.autoScale(),
                      plotControlPanel.yMin(), plotControlPanel.yMax());
     // Init sps (sample per second) counter
     spsLabel.setText("0sps");
     spsLabel.setToolTip("samples per second (per channel)");
     ui->statusBar->addPermanentWidget(&spsLabel);
     QObject::connect(&dataFormatPanel,
                      &DataFormatPanel::samplesPerSecondChanged,
                      this, &MainWindow::onSpsChanged);
     // init demo
     QObject::connect(ui->actionDemoMode, &QAction::toggled,
                      this, &MainWindow::enableDemo);
     QObject::connect(ui->actionDemoMode, &QAction::toggled,
                      plotMan, &PlotManager::showDemoIndicator);
     // load default settings
     QSettings settings("serialplot", "serialplot");
     loadAllSettings(&settings);
     // ensure command panel has 1 command if none loaded
     if (!commandPanel.numOfCommands())
+    {
         commandPanel.newCommandAction()->trigger();
+    }
     // Important: This should be after newCommandAction is triggered
     // (above) we don't want user to be greeted with command panel on
     // the very first run.
     connect(commandPanel.newCommandAction(), &QAction::triggered, [this]()
+            {
                 this->ui->tabWidget->setCurrentWidget(&commandPanel);
             });
+}
 MainWindow::~MainWindow()
+{
     // save settings
     QSettings settings("serialplot", "serialplot");
     saveAllSettings(&settings);
     if (serialPort.isOpen())
+    {
         serialPort.close();
+    }
     delete plotMan;
     delete ui;
     ui = NULL; // we check if ui is deleted in messageHandler
+}
 void MainWindow::closeEvent(QCloseEvent * event)
+{
     if (!snapshotMan.isAllSaved())
+    {
         auto clickedButton = QMessageBox::warning(
             this, "Closing SerialPlot",
             "There are un-saved snapshots. If you close you will loose the data.",
             QMessageBox::Discard | QMessageBox::Discard,
             QMessageBox::Cancel);
         if (clickedButton == QMessageBox::Cancel)
+        {
             event->ignore();
             return;
+        }
+    }
     QMainWindow::closeEvent(event);
+}
 void MainWindow::setupAboutDialog()
+{
     Ui_AboutDialog uiAboutDialog;
     uiAboutDialog.setupUi(&aboutDialog);
     QObject::connect(uiAboutDialog.pbAboutQt, &QPushButton::clicked,
                      [](){ QApplication::aboutQt();});
     QString aboutText = uiAboutDialog.lbAbout->text();
     aboutText.replace("$VERSION_STRING$", VERSION_STRING);
     aboutText.replace("$VERSION_REVISION$", VERSION_REVISION);
     uiAboutDialog.lbAbout->setText(aboutText);
+}
 void MainWindow::onPortToggled(bool open)
+{
     // make sure demo mode is disabled
     if (open && isDemoRunning()) enableDemo(false);
     ui->actionDemoMode->setEnabled(!open);
+}
 void MainWindow::onPortError(QSerialPort::SerialPortError error)
+{
     switch(error)
+    {
         case QSerialPort::NoError :
             break;
         case QSerialPort::ResourceError :
             qWarning() << "Port error: resource unavaliable; most likely device removed.";
             if (serialPort.isOpen())
+            {
                 qWarning() << "Closing port on resource error: " << serialPort.portName();
                 portControl.togglePort();
+            }
             portControl.loadPortList();
             break;
         case QSerialPort::DeviceNotFoundError:
             qCritical() << "Device doesn't exists: " << serialPort.portName();
             break;
         case QSerialPort::PermissionError:
             qCritical() << "Permission denied. Either you don't have \
 required privileges or device is already opened by another process.";
             break;
         case QSerialPort::OpenError:
             qWarning() << "Device is already opened!";
             break;
         case QSerialPort::NotOpenError:
             qCritical() << "Device is not open!";
             break;
         case QSerialPort::ParityError:
             qCritical() << "Parity error detected.";
             break;
         case QSerialPort::FramingError:
             qCritical() << "Framing error detected.";
             break;
         case QSerialPort::BreakConditionError:
             qCritical() << "Break condition is detected.";
             break;
         case QSerialPort::WriteError:
             qCritical() << "An error occurred while writing data.";
             break;
         case QSerialPort::ReadError:
             qCritical() << "An error occurred while reading data.";
             break;
         case QSerialPort::UnsupportedOperationError:
             qCritical() << "Operation is not supported.";
             break;
         case QSerialPort::TimeoutError:
             qCritical() << "A timeout error occurred.";
             break;
         case QSerialPort::UnknownError:
             qCritical() << "Unknown error! Error: " << serialPort.errorString();
             break;
         default:
             qCritical() << "Unhandled port error: " << error;
             break;
+    }
+}
 void MainWindow::clearPlot()
+{
     for (unsigned ci = 0; ci < channelMan.numOfChannels(); ci++)
+    {
         channelMan.channelBuffer(ci)->clear();
+    }
     plotMan->replot();
+}
 void MainWindow::onNumOfSamplesChanged(int value)
+{
     numOfSamples = value;
     channelMan.setNumOfSamples(value);
     plotMan->replot();
+}
 void MainWindow::onNumOfChannelsChanged(unsigned value)
+{
     unsigned int oldNum = plotMan->numOfCurves();
     unsigned numOfChannels = value;
     if (numOfChannels > oldNum)
+    {
         // add new channels
         for (unsigned int i = oldNum; i < numOfChannels; i++)
+        {
             plotMan->addCurve(channelMan.channelName(i), channelMan.channelBuffer(i));
+        }
+    }
     else if(numOfChannels < oldNum)
+    {
         plotMan->removeCurves(oldNum - numOfChannels);
+    }
     plotMan->replot();
+}
 void MainWindow::onSpsChanged(unsigned sps)
+{
     spsLabel.setText(QString::number(sps) + "sps");
+}
 bool MainWindow::isDemoRunning()
+{
     return ui->actionDemoMode->isChecked();
+}
 void MainWindow::enableDemo(bool enabled)
+{
     if (enabled)
+    {
         if (!serialPort.isOpen())
+        {
             dataFormatPanel.enableDemo(true);
+        }
         else
+        {
             ui->actionDemoMode->setChecked(false);
+        }
+    }
     else
+    {
         dataFormatPanel.enableDemo(false);
         ui->actionDemoMode->setChecked(false);
+    }
+}
 void MainWindow::onExportCsv()
+{
     bool wasPaused = ui->actionPause->isChecked();
     ui->actionPause->setChecked(true); // pause plotting
     QString fileName = QFileDialog::getSaveFileName(this, tr("Export CSV File"));
     if (fileName.isNull())  // user canceled export
+    {
         ui->actionPause->setChecked(wasPaused);
+    }
     else
+    {
         Snapshot* snapshot = snapshotMan.makeSnapshot();
         snapshot->save(fileName);
         delete snapshot;
+    }
+}
 void MainWindow::messageHandler(QtMsgType type,
                                 const QMessageLogContext &context,
                                 const QString &msg)
+{
     QString logString;
     switch (type)
+    {
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 5, 0))
         case QtInfoMsg:
             logString = "[Info] " + msg;
             break;
 #endif
         case QtDebugMsg:
             logString = "[Debug] " + msg;
             break;
         case QtWarningMsg:
             logString = "[Warning] " + msg;
             break;
         case QtCriticalMsg:
             logString = "[Error] " + msg;
             break;
         case QtFatalMsg:
             logString = "[Fatal] " + msg;
             break;
+    }
     if (ui != NULL) ui->ptLog->appendPlainText(logString);
     std::cerr << logString.toStdString() << std::endl;
     if (type != QtDebugMsg && ui != NULL)
+    {
         ui->statusBar->showMessage(msg, 5000);
+    }
     if (type == QtFatalMsg)
+    {
         __builtin_trap();
+    }
+}
 void MainWindow::saveAllSettings(QSettings* settings)
+{
     saveMWSettings(settings);
     portControl.saveSettings(settings);
     dataFormatPanel.saveSettings(settings);
     channelMan.saveSettings(settings);
     plotControlPanel.saveSettings(settings);
     plotMan->saveSettings(settings);
     commandPanel.saveSettings(settings);
+}
 void MainWindow::loadAllSettings(QSettings* settings)
+{
     loadMWSettings(settings);
     portControl.loadSettings(settings);
     dataFormatPanel.loadSettings(settings);
     channelMan.loadSettings(settings);
     plotControlPanel.loadSettings(settings);
     plotMan->loadSettings(settings);
     commandPanel.loadSettings(settings);
+}
 void MainWindow::saveMWSettings(QSettings* settings)
+{
     // save window geometry
     settings->beginGroup(SettingGroup_MainWindow);
     settings->setValue(SG_MainWindow_Size, size());
     settings->setValue(SG_MainWindow_Pos, pos());
     // save active panel
     settings->setValue(SG_MainWindow_ActivePanel,
                        panelSettingMap.value(ui->tabWidget->currentIndex()));
     // save panel minimization
     settings->setValue(SG_MainWindow_HidePanels,
                        ui->tabWidget->hideAction.isChecked());
     // save window maximized state
     settings->setValue(SG_MainWindow_Maximized,
                        bool(windowState() & Qt::WindowMaximized));
     // save toolbar/dockwidgets state
     settings->setValue(SG_MainWindow_State, saveState());
     settings->endGroup();
+}
 void MainWindow::loadMWSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_MainWindow);
     // load window geometry
     resize(settings->value(SG_MainWindow_Size, size()).toSize());
     move(settings->value(SG_MainWindow_Pos, pos()).toPoint());
     // set active panel
     QString tabSetting =
         settings->value(SG_MainWindow_ActivePanel, QString()).toString();
     ui->tabWidget->setCurrentIndex(
         panelSettingMap.key(tabSetting, ui->tabWidget->currentIndex()));
     // hide panels
     ui->tabWidget->hideAction.setChecked(
         settings->value(SG_MainWindow_HidePanels,
                         ui->tabWidget->hideAction.isChecked()).toBool());
     // maximize window
     if (settings->value(SG_MainWindow_Maximized).toBool())
+    {
         showMaximized();
+    }
     // load toolbar/dockwidgets state
     restoreState(settings->value(SG_MainWindow_State).toByteArray());
     settings->setValue(SG_MainWindow_State, saveState());
     settings->endGroup();
+}
 void MainWindow::onSaveSettings()
+{
     QString fileName = QFileDialog::getSaveFileName(
         this, tr("Save Settings"), QString(), "INI (*.ini)");
     if (!fileName.isNull()) // user canceled
+    {
         QSettings settings(fileName, QSettings::IniFormat);
         saveAllSettings(&settings);
+    }

src/mainwindow.h

➞

Show inline comments

 /*
   Copyright © 2017 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 MAINWINDOW_H
 #define MAINWINDOW_H
 #include <QMainWindow>
 #include <QButtonGroup>
 #include <QLabel>
 #include <QString>
 #include <QVector>
 #include <QList>
 #include <QSerialPort>
 #include <QSignalMapper>
 #include <QTimer>
 #include <QColor>
 #include <QtGlobal>
 #include <QSettings>
 #include <qwt_plot_curve.h>
 #include "portcontrol.h"
 #include "commandpanel.h"
 #include "dataformatpanel.h"
 #include "plotcontrolpanel.h"
 #include "recordpanel.h"
 #include "ui_about_dialog.h"
 #include "framebuffer.h"
 #include "channelmanager.h"
 #include "snapshotmanager.h"
 #include "plotmanager.h"
 #include "datarecorder.h"
 namespace Ui {
 class MainWindow;
+}
 class MainWindow : public QMainWindow
+{
     Q_OBJECT
 public:
     explicit MainWindow(QWidget *parent = 0);
     ~MainWindow();
     void messageHandler(QtMsgType type, const QMessageLogContext &context,
                         const QString &msg);
 private:
     Ui::MainWindow *ui;
     QDialog aboutDialog;
     void setupAboutDialog();
     QSerialPort serialPort;
     PortControl portControl;
     unsigned int numOfSamples;
     QList<QwtPlotCurve*> curves;
     ChannelManager channelMan;
     PlotManager* plotMan;
     SnapshotManager snapshotMan;
     DataRecorder recorder;       // operated by `recordPanel`
     QLabel spsLabel;
     CommandPanel commandPanel;
     DataFormatPanel dataFormatPanel;
     RecordPanel recordPanel;
     PlotControlPanel plotControlPanel;
     RecordPanel recordPanel;
     bool isDemoRunning();
     /// Stores settings for all modules
     void saveAllSettings(QSettings* settings);
     /// Load settings for all modules
     void loadAllSettings(QSettings* settings);
     /// Stores main window settings into a `QSettings`
     void saveMWSettings(QSettings* settings);
     /// Loads main window settings from a `QSettings`
     void loadMWSettings(QSettings* settings);
     /// `QWidget::closeEvent` handler
     void closeEvent(QCloseEvent * event);
 private slots:
     void onPortToggled(bool open);
     void onPortError(QSerialPort::SerialPortError error);
     void onNumOfSamplesChanged(int value);
     void onNumOfChannelsChanged(unsigned value);
     void clearPlot();
     void onSpsChanged(unsigned sps);
     void enableDemo(bool enabled);
     void onExportCsv();
     void onSaveSettings();
     void onLoadSettings();
 };
 #endif // MAINWINDOW_H

src/recordpanel.cpp

➞

Show inline comments

 /*
   Copyright © 2017 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 "recordpanel.h"
 #include "ui_recordpanel.h"
 #include <QIcon>
 #include <QFile>
 #include <QFileInfo>
 #include <QMessageBox>
 #include <QFileDialog>
 #include <QRegularExpression>
 #include <QtDebug>
 RecordPanel::RecordPanel(QWidget *parent) :
+RecordPanel::RecordPanel(DataRecorder* recorder, QWidget *parent) :
     QWidget(parent),
     ui(new Ui::RecordPanel),
     recordToolBar(tr("Record Toolbar")),
     recordAction(QIcon::fromTheme("media-record"), tr("Record"), this),
     recorder(this)
     recordAction(QIcon::fromTheme("media-record"), tr("Record"), this)
+{
     overwriteSelected = false;
     _recorder = recorder;
     ui->setupUi(this);
     recordToolBar.setObjectName("tbRecord");
     recordAction.setCheckable(true);
     recordToolBar.addAction(&recordAction);
     ui->pbRecord->setDefaultAction(&recordAction);
     connect(ui->pbBrowse, &QPushButton::clicked,
             this, &RecordPanel::selectFile);
     connect(&recordAction, &QAction::triggered,
             this, &RecordPanel::onRecord);
     connect(ui->cbRecordPaused, SIGNAL(toggled(bool)),
             this, SIGNAL(recordPausedChanged(bool)));
+}
 RecordPanel::~RecordPanel()
+{
     delete ui;
+}
 QToolBar* RecordPanel::toolbar()
+{
     return &recordToolBar;
+}
 bool RecordPanel::isRecording()
+{
     return recordAction.isChecked();
+}
 bool RecordPanel::recordPaused()
+{
     return ui->cbRecordPaused->isChecked();
+}
 bool RecordPanel::selectFile()
+{
     QString fileName = QFileDialog::getSaveFileName(
         parentWidget(), tr("Select recording file"));
     if (fileName.isEmpty())
+    {
         return false;
+    }
     else
+    {
         selectedFile = fileName;
         ui->lbFileName->setText(selectedFile);
         overwriteSelected = QFile::exists(fileName);
         return true;
+    }
+}
 void RecordPanel::onRecord(bool start)
+{
     if (!start)
+    {
         stopRecording();
         return;
+    }
     // check file name
     bool canceled = false;
     if (selectedFile.isEmpty() && !selectFile())
+    {
         canceled = true;
+    }
     if (!overwriteSelected && QFile::exists(selectedFile))
+    {
         if (ui->cbAutoIncrement->isChecked())
+        {
             // TODO: should we increment even if user selected to replace?
             canceled = !incrementFileName();
+        }
         else
+        {
             canceled = !confirmOverwrite(selectedFile);
+        }
+    }
     overwriteSelected = false;
     if (canceled)
+    {
         recordAction.setChecked(false);
+    }
     else
+    {
         startRecording();
+    }
+}
 bool RecordPanel::incrementFileName(void)
+{
     QFileInfo fileInfo(selectedFile);
     QString base = fileInfo.completeBaseName();
     QRegularExpression regex("(.*?)(\\d+)(?!.*\\d)(.*)");
     auto match = regex.match(base);
     if (match.hasMatch())
+    {
         bool ok;
         int fileNum = match.captured(2).toInt(&ok);
         base = match.captured(1) + QString::number(fileNum + 1) + match.captured(3);
+    }
     else
+    {
         base += "_1";
+    }
     QString suffix = fileInfo.suffix();;
     if (!suffix.isEmpty())
+    {
         suffix = "." + suffix;
+    }
     QString autoFileName = fileInfo.path() + "/" + base + suffix;
     // check if auto generated file name exists, ask user another name
     if (QFile::exists(autoFileName))
+    {
         if (!confirmOverwrite(autoFileName))
+        {
             return false;
+        }
+    }
     else
+    {
         selectedFile = autoFileName;
+    }
     ui->lbFileName->setText(selectedFile);
     return true;
+}
 bool RecordPanel::confirmOverwrite(QString fileName)
+{
     // prepare message box
     QMessageBox mb(parentWidget());
     mb.setWindowTitle(tr("File Already Exists"));
     mb.setIcon(QMessageBox::Warning);
     mb.setText(tr("File (%1) already exists. How to continue?").arg(fileName));
     auto bCancel    = mb.addButton(QMessageBox::Cancel);
     auto bOverwrite = mb.addButton(tr("Overwrite"), QMessageBox::DestructiveRole);
     mb.addButton(tr("Select Another File"), QMessageBox::YesRole);
     mb.setEscapeButton(bCancel);
     // show message box
     mb.exec();
     if (mb.clickedButton() == bCancel)
+    {
         return false;
+    }
     else if (mb.clickedButton() == bOverwrite)
+    {
         selectedFile = fileName;
         return true;
+    }
     else                    // select button
+    {
         return selectFile();
+    }
+}
 void RecordPanel::startRecording(void)
+{
     qDebug() << "start recording";
     // TEST CODE
     QStringList cn;
     cn << "chan0" << "chan1" << "chan2";
+    // cn << "chan0" << "chan1" << "chan2";
-    recorder.startRecording(selectedFile, cn);
+    _recorder->startRecording(selectedFile, cn);
     // add test data
     double data[3] = {15., 15., 15.};
     recorder.addData(data, 3, 3);
     // double data[3] = {15., 15., 15.};
     // _recorder.addData(data, 3, 3);
     emit recordStarted();
+}
 void RecordPanel::stopRecording(void)
+{
     // TODO
     qDebug() << "stop recording";
     recorder.stopRecording();
     emit recordStopped();
     _recorder->stopRecording();
+}

src/recordpanel.h

➞

Show inline comments

 /*
   Copyright © 2017 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 RECORDPANEL_H
 #define RECORDPANEL_H
 #include <QWidget>
 #include <QString>
 #include <QToolBar>
 #include <QAction>
 #include "datarecorder.h"
 namespace Ui {
 class RecordPanel;
+}
 class RecordPanel : public QWidget
+{
     Q_OBJECT
 public:
-    explicit RecordPanel(QWidget *parent = 0);
+    explicit RecordPanel(DataRecorder* recorder, QWidget* parent = 0);
     ~RecordPanel();
     QToolBar* toolbar();
     bool isRecording();
     bool recordPaused();
 signals:
     void recordStarted();
     void recordStopped();
     void recordPausedChanged(bool enabled);
 private:
     Ui::RecordPanel *ui;
     QToolBar recordToolBar;
     QAction recordAction;
     QString selectedFile;
     bool overwriteSelected;
-    DataRecorder recorder;
+    DataRecorder* _recorder;
     /**
      * @brief Increments the file name.
+     *
      * If file name doesn't have a number at the end of it, a number is appended
      * with underscore starting from 1.
+     *
      * @return false if user cancels
      */
     bool incrementFileName(void);
     /**
      * @brief Used to ask user confirmation if auto generated file
      * name exists.
+     *
      * If user confirms overwrite, `selectedFile` is set to
      * `fileName`. User is also given option to select file and is
      * shown a file select dialog in this case.
+     *
      * @param fileName auto generated file name.
      * @return false if user cancels
      */
     bool confirmOverwrite(QString fileName);
     void startRecording(void);
     void stopRecording(void);
 private slots:
     /**
      * @brief Opens up the file select dialog
+     *
      * If you cancel the selection operation, currently selected file is not
      * changed.
+     *
      * @return true if file selected, false if user cancels
      */
     bool selectFile();
     void onRecord(bool start);
 };
 #endif // RECORDPANEL_H

0 comments (0 inline, 0 general)