DataFormatPanel::~DataFormatPanel()

{

    delete ui;

}

unsigned DataFormatPanel::numOfChannels()

{

    return currentReader->numOfChannels();

}

void DataFormatPanel::pause(bool enabled)

{

    paused = enabled;

    currentReader->pause(enabled);

    demoReader.pause(enabled);

}

void DataFormatPanel::enableDemo(bool enabled)

{

    if (enabled)

    {

        demoReader.enable();

        connect(&demoReader, &DemoReader::dataAdded,

                this, &DataFormatPanel::dataAdded);

        connect(&demoReader, &DemoReader::samplesPerSecondChanged,

                this, &DataFormatPanel::samplesPerSecondChanged);

    }

    else

    {

        demoReader.enable(false);

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

    }

}

void DataFormatPanel::addChannelData(unsigned int channel,

                                     double* data, unsigned size)

{

    _channelMan->addChannelData(channel, data, size);

}

void DataFormatPanel::selectReader(AbstractReader* reader)

{

    currentReader->enable(false);

    reader->enable();

    // re-connect signals

    disconnect(currentReader, 0, this, 0);

    connect(reader, SIGNAL(dataAdded()), this, SIGNAL(dataAdded()));

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

            this, SIGNAL(numOfChannelsChanged(unsigned)));

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

            this, SIGNAL(samplesPerSecondChanged(unsigned)));

    // switch the settings widget

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

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

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

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

    // notify if number of channels is different

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

    {

        emit numOfChannelsChanged(reader->numOfChannels());

    }

    // pause

    reader->pause(paused);

    currentReader = reader;

}

void DataFormatPanel::saveSettings(QSettings* settings)

{

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

}

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

}

            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;

        }

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

}

/*

  Copyright © 2016 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 "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);

    QWidget* settingsWidget();

    unsigned numOfChannels();

    void enable(bool enabled = true);

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

    // `data` contains i th channels data

    void addChannelData(unsigned int channel, double* data, unsigned size);

private slots:

    void onDataReady();

    void onNumberFormatChanged(NumberFormat numberFormat);

    void onNumOfChannelsChanged(unsigned value);

    void onSyncWordChanged(QByteArray);

    void onFrameSizeChanged(unsigned);

};

#endif // FRAMEDREADER_H

/*

  Copyright © 2016 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 <QButtonGroup>

#include "utils.h"

#include "framedreadersettings.h"

#include "ui_framedreadersettings.h"

FramedReaderSettings::FramedReaderSettings(QWidget *parent) :

    QWidget(parent),

    ui(new Ui::FramedReaderSettings)

{

    ui->setupUi(this);

    ui->leSyncWord->setMode(false); // hex mode

    ui->leSyncWord->setText("AA BB");

    connect(ui->cbChecksum, &QCheckBox::toggled,

            [this](bool enabled)

            {

                emit checksumChanged(enabled);

            });

    connect(ui->cbDebugMode, &QCheckBox::toggled,

            this, &FramedReaderSettings::debugModeChanged);

    connect(ui->rbFixedSize, &QRadioButton::toggled,

            ui->spSize, &QWidget::setEnabled);

    connect(ui->rbFixedSize, &QRadioButton::toggled,

            [this](bool checked)

            {

                emit frameSizeChanged(frameSize());

            });

    // Note: if directly connected we get a runtime warning on incompatible signal arguments

    connect(ui->spSize, SELECT<int>::OVERLOAD_OF(&QSpinBox::valueChanged),

            [this](int value)

            {

                emit frameSizeChanged(value);

            });

    connect(ui->spNumOfChannels, SELECT<int>::OVERLOAD_OF(&QSpinBox::valueChanged),

            [this](int value)

            {

                emit numOfChannelsChanged(value);

            });

    connect(ui->leSyncWord, &QLineEdit::textChanged,

            this, &FramedReaderSettings::onSyncWordEdited);

    connect(ui->nfBox, SIGNAL(selectionChanged(NumberFormat)),

            this, SIGNAL(numberFormatChanged(NumberFormat)));

    // add frame size selection buttons to same group

    QButtonGroup* group = new QButtonGroup(this);

    group->addButton(ui->rbFixedSize);

    group->addButton(ui->rbSizeByte);

}

FramedReaderSettings::~FramedReaderSettings()

{

    delete ui;

}

void FramedReaderSettings::showMessage(QString message, bool error)

{

    ui->lMessage->setText(message);

    if (error)

    {

        ui->lMessage->setStyleSheet("color: red;");

    }

    else

    {

        ui->lMessage->setStyleSheet("");

    }

}

unsigned FramedReaderSettings::numOfChannels()

{

    return ui->spNumOfChannels->value();

}

NumberFormat FramedReaderSettings::numberFormat()

{

    return ui->nfBox->currentSelection();

}

Endianness FramedReaderSettings::endianness()

{

    return ui->endiBox->currentSelection();

}

QByteArray FramedReaderSettings::syncWord()

{

    QString text = ui->leSyncWord->text().remove(' ');

    // check if nibble is missing

    if (text.size() % 2 == 1)

    {

        return QByteArray();

    }

    else

    {

        return QByteArray::fromHex(text.toLatin1());

    }

}

void FramedReaderSettings::onSyncWordEdited()

{

    // TODO: emit with a delay so that error message doesn't flash!

    emit syncWordChanged(syncWord());

}

unsigned FramedReaderSettings::frameSize()

{

    if (ui->rbFixedSize->isChecked())

    {

        return ui->spSize->value();

    }

    else

    {

        return 0; // frame byte is enabled

    }

}

bool FramedReaderSettings::isChecksumEnabled()

{

    return ui->cbChecksum->isChecked();

}

bool FramedReaderSettings::isDebugModeEnabled()

{

    return ui->cbDebugMode->isChecked();

}

/*

  Copyright © 2016 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 FRAMEDREADERSETTINGS_H

#define FRAMEDREADERSETTINGS_H

#include <QWidget>

#include <QByteArray>

#include "numberformatbox.h"

#include "endiannessbox.h"

namespace Ui {

class FramedReaderSettings;

}

class FramedReaderSettings : public QWidget

{

    Q_OBJECT

public:

    explicit FramedReaderSettings(QWidget *parent = 0);

    ~FramedReaderSettings();

    void showMessage(QString message, bool error = false);

    unsigned numOfChannels();

    NumberFormat numberFormat();

    Endianness endianness();

    QByteArray syncWord();

    unsigned frameSize(); /// If frame bye is enabled `0` is returned

    bool isChecksumEnabled();

    bool isDebugModeEnabled();

signals:

    /// If sync word is invalid (empty or 1 nibble missing at the end)

    /// signaled with an empty array

    void syncWordChanged(QByteArray);

    /// `0` indicates frame size byte is enabled

    void frameSizeChanged(unsigned);

    void checksumChanged(bool);

    void numOfChannelsChanged(unsigned);

    void numberFormatChanged(NumberFormat);

    void debugModeChanged(bool);

private:

    Ui::FramedReaderSettings *ui;

private slots:

    void onSyncWordEdited();

};

#endif // FRAMEDREADERSETTINGS_H

/*

  Copyright © 2016 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 SETTING_DEFINES_H

#define SETTING_DEFINES_H

const char SettingGroup_MainWindow[] = "MainWindow";

const char SettingGroup_Port[] = "Port";

const char SettingGroup_DataFormat[] = "DataFormat";

const char SettingGroup_Binary[] = "DataFormat_Binary";

const char SettingGroup_ASCII[] = "DataFormat_ASCII";

const char SettingGroup_Channels[] = "Channels";

const char SettingGroup_Plot[] = "Plot";

const char SettingGroup_Commands[] = "Commands";

// mainwindow setting keys

const char SG_MainWindow_Size[] = "size";

const char SG_MainWindow_Pos[] = "pos";

const char SG_MainWindow_ActivePanel[] = "activePanel";

const char SG_MainWindow_HidePanels[] = "hidePanels";

// port setting keys

const char SG_Port_SelectedPort[] = "selectedPort";

const char SG_Port_BaudRate[] = "baudRate";

const char SG_Port_Parity[] = "parity";

const char SG_Port_DataBits[] = "dataBits";

const char SG_Port_StopBits[] = "stopBits";

const char SG_Port_FlowControl[] = "flowControl";

// data format panel keys

const char SG_DataFormat_Format[] = "format";

// binary stream reader keys

const char SG_Binary_NumOfChannels[] = "numOfChannels";

const char SG_Binary_NumberFormat[] = "numberFormat";

const char SG_Binary_Endianness[] = "endianness";

// ascii reader keys

const char SG_ASCII_NumOfChannels[] = "numOfChannels";

#endif // SETTING_DEFINES_H