tempo-plotter Changeset - 0894be6d3943 · protofusion repositories

Changeset - 0894be6d3943

Parent rev.

Child rev.

[Not reviewed]

default

0 8 0

Hasan Yavuz ÖZDERYA - 9 years ago 2017-02-06 16:42:50
hy@ozderya.net

improved api by replacing addChannelData function with addData that adds all channels data at the same time

8 files changed with 43 insertions and 41 deletions:

src/asciireader.cpp

src/binarystreamreader.cpp

src/binarystreamreader.h

src/channelmanager.cpp

src/channelmanager.h

src/demoreader.cpp

src/framedreader.cpp

src/mainwindow.cpp

0 comments (0 inline, 0 general)

src/asciireader.cpp

➞

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/>.
 */
 #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)
+{
     paused = false;
     discardFirstLine = true;
     sampleCount = 0;
     _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;
             double channelSample = separatedValues[ci].toDouble(&ok);
             if (ok)
+            {
                 _channelMan->addChannelData(ci, &channelSample, 1);
                 sampleCount++;
+            }
             else
             channelSamples[ci] = separatedValues[ci].toDouble(&ok);
             if (!ok)
+            {
                 qWarning() << "Data parsing error for channel: " << ci;
                 channelSamples[ci] = 0;
+            }
+        }
         // commit data
         _channelMan->addData(channelSamples, _numOfChannels);
         sampleCount += numReadChannels;
         emit dataAdded();
         delete[] channelSamples;
+    }
+}
 void AsciiReader::saveSettings(QSettings* settings)
+{
     _settingsWidget.saveSettings(settings);
+}
 void AsciiReader::loadSettings(QSettings* settings)
+{
     _settingsWidget.loadSettings(settings);
+}

src/binarystreamreader.cpp

➞

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/>.
 */
 #include <QtEndian>
 #include <QtDebug>
 #include "binarystreamreader.h"
 #include "floatswap.h"
 BinaryStreamReader::BinaryStreamReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :
     AbstractReader(device, channelMan, parent)
+{
     paused = false;
     skipByteRequested = false;
     skipSampleRequested = false;
     sampleCount = 0;
     _numOfChannels = _settingsWidget.numOfChannels();
     connect(&_settingsWidget, &BinaryStreamReaderSettings::numOfChannelsChanged,
             this, &BinaryStreamReader::numOfChannelsChanged);
     connect(&_settingsWidget, &BinaryStreamReaderSettings::numOfChannelsChanged,
             this, &BinaryStreamReader::onNumOfChannelsChanged);
     // initial number format selection
     onNumberFormatChanged(_settingsWidget.numberFormat());
     connect(&_settingsWidget, &BinaryStreamReaderSettings::numberFormatChanged,
             this, &BinaryStreamReader::onNumberFormatChanged);
     // enable skip byte 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)();
+        }
+    }
     for (unsigned int ci = 0; ci < _numOfChannels; ci++)
+    {
         addChannelData(ci,
                        channelSamples + ci*numOfPackagesToRead,
                        numOfPackagesToRead);
+    }
     _channelMan->addData(channelSamples, numOfPackagesToRead*_numOfChannels);
     sampleCount += numOfPackagesToRead*_numOfChannels;
     emit dataAdded();
     delete[] channelSamples;
+}
 template<typename T> double BinaryStreamReader::readSampleAs()
+{
     T data;
     _device->read((char*) &data, sizeof(data));
     if (_settingsWidget.endianness() == LittleEndian)
+    {
         data = qFromLittleEndian(data);
+    }
     else
+    {
         data = qFromBigEndian(data);
+    }
     return double(data);
+}
 void BinaryStreamReader::addChannelData(unsigned int channel,
                                         double* data, unsigned size)
+{
     _channelMan->addChannelData(channel, data, size);
     sampleCount += size;
+}
 void BinaryStreamReader::saveSettings(QSettings* settings)
+{
     _settingsWidget.saveSettings(settings);
+}
 void BinaryStreamReader::loadSettings(QSettings* settings)
+{
     _settingsWidget.loadSettings(settings);
+}

src/binarystreamreader.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 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);
     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();
     // `data` contains i th channels data
     void addChannelData(unsigned int channel, double* data, unsigned size);
 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;
     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);
+}
 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::addChannelData(unsigned channel, double* data, unsigned size)
+void ChannelManager::addData(double* data, unsigned size)
+{
     channelBuffer(channel)->addSamples(data, 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);
+}

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);
 public slots:
     void setNumOfChannels(unsigned number);
     void setNumOfSamples(unsigned number);
     void addChannelData(unsigned channel, double* data, unsigned size);
     /**
      * 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;
     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/demoreader.cpp

➞

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/>.
 */
 #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)
+{
     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
             double value = 4*sin(2*M_PI*double((ci+1)*count)/period)/((2*(ci+1))*M_PI);
             _channelMan->addChannelData(ci, &value, 1);
             samples[ci] = 4*sin(2*M_PI*double((ci+1)*count)/period)/((2*(ci+1))*M_PI);
             sampleCount++;
+        }
         _channelMan->addData(samples, _numOfChannels);
         delete[] samples;
         emit dataAdded();
+    }
+}

src/framedreader.cpp

➞

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/>.
 */
 #include <QtDebug>
 #include <QtEndian>
 #include "floatswap.h"
 #include "framedreader.h"
 FramedReader::FramedReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :
     AbstractReader(device, channelMan, 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
         for (unsigned int ci = 0; ci < _numOfChannels; ci++)
+        {
             _channelMan->addChannelData(
                 ci,
                 channelSamples + ci*numOfPackagesToRead,
                 numOfPackagesToRead);
             sampleCount += numOfPackagesToRead;
+        }
         _channelMan->addData(channelSamples, numOfPackagesToRead * _numOfChannels);
         emit dataAdded();
+    }
     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/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)
+{
     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->setCurrentIndex(0);
     auto tbPortControl = portControl.toolBar();
     addToolBar(tbPortControl);
     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(&dataFormatPanel, &DataFormatPanel::dataAdded,
                      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));
+    }
     // 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;

0 comments (0 inline, 0 general)