tempo-plotter Changeset - 538d40c57b2b · protofusion repositories

Changeset - 538d40c57b2b

Parent rev.

Child rev.

[Not reviewed]

recording

0 6 0

Hasan Yavuz ÖZDERYA - 9 years ago 2017-02-14 05:58:51
hy@ozderya.net

moved buffer access to abstract reader class

6 files changed with 17 insertions and 18 deletions:

src/abstractreader.cpp

src/abstractreader.h

src/asciireader.cpp

src/binarystreamreader.cpp

src/demoreader.cpp

src/framedreader.cpp

0 comments (0 inline, 0 general)

src/abstractreader.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 "abstractreader.h"
 AbstractReader::AbstractReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :
     QObject(parent)
+{
     _device = device;
     _channelMan = channelMan;
     // initialize sps counter
     sampleCount = 0;
     samplesPerSecond = 0;
     QObject::connect(&spsTimer, &QTimer::timeout,
                      this, &AbstractReader::spsTimerTimeout);
     // TODO: start sps timer when reader is enabled
     spsTimer.start(SPS_UPDATE_TIMEOUT * 1000);
+}
 void AbstractReader::spsTimerTimeout()
+{
     unsigned currentSps = samplesPerSecond;
     samplesPerSecond = (sampleCount/numOfChannels())/SPS_UPDATE_TIMEOUT;
     if (currentSps != samplesPerSecond)
+    {
         emit samplesPerSecondChanged(samplesPerSecond);
+    }
     sampleCount = 0;
+}
 void AbstractReader::addData(double* samples, unsigned length)
+{
     _channelMan->addData(samples, length);
     sampleCount += length;
     emit dataAdded();
+}

src/abstractreader.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 ABSTRACTREADER_H
 #define ABSTRACTREADER_H
 #include <QObject>
 #include <QIODevice>
 #include <QWidget>
 #include <QTimer>
 #include "channelmanager.h"
 /**
  * All reader classes must inherit this class.
  */
 class AbstractReader : public QObject
+{
     Q_OBJECT
 public:
     explicit AbstractReader(QIODevice* device, ChannelManager* channelMan, QObject *parent = 0);
     /**
      * Returns a widget to be shown in data format panel when reader
      * is selected.
      */
     virtual QWidget* settingsWidget() = 0;
     /**
      * Number of channels being read.
+     *
      * This number may be user selected or automatically determined
      * from incoming stream.
      */
     virtual unsigned numOfChannels() = 0;
     /// Reader should only read when enabled. Default state should be
     /// 'disabled'.
     virtual void enable(bool enabled = true) = 0;
 signals:
     void numOfChannelsChanged(unsigned);
     // TODO: this must be signaled by 'channel man' for better abstraction
     void dataAdded(); ///< emitted when data added to channel man.
     // TODO: this should be a part of 'channel man'
     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;
     ChannelManager* _channelMan;
     /// Implementing class should simply increase this count as samples are read
     unsigned sampleCount;
     /// Should be called with read data
     void addData(double* samples, unsigned length);
 private:
     const int SPS_UPDATE_TIMEOUT = 1;  // second
     ChannelManager* _channelMan;
     unsigned sampleCount;
     unsigned samplesPerSecond;
     QTimer spsTimer;
 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)
+{
     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;
             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();
         addData(channelSamples, _numOfChannels);
         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 © 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)();
+        }
+    }
     _channelMan->addData(channelSamples, numOfPackagesToRead*_numOfChannels);
     sampleCount += numOfPackagesToRead*_numOfChannels;
     emit dataAdded();
     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/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)
+{
     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);
             sampleCount++;
+        }
-        _channelMan->addData(samples, _numOfChannels);
         addData(samples, _numOfChannels);
         delete[] samples;
         emit dataAdded();
+    }
+}

src/framedreader.cpp

➞

Show inline comments

@@ @@ -217,142 +217,141 @@ void FramedReader::onDataReady() @@
             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
         _channelMan->addData(channelSamples, numOfPackagesToRead * _numOfChannels);
         emit dataAdded();
         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);
+}

0 comments (0 inline, 0 general)