src/snapshot.cpp

  src/snapshotview.cpp

  src/snapshotmanager.cpp

  src/plotsnapshotoverlay.cpp

  src/commandpanel.cpp

  src/commandwidget.cpp

  src/commandedit.cpp

  src/dataformatpanel.cpp

  src/plotcontrolpanel.cpp

  src/tooltipfilter.cpp

  src/sneakylineedit.cpp

  src/channelmanager.cpp

  src/framebufferseries.cpp

  src/numberformatbox.cpp

  src/endiannessbox.cpp

  src/abstractreader.cpp

  src/binarystreamreader.cpp

  src/binarystreamreadersettings.cpp

  src/asciireader.cpp

  src/asciireadersettings.cpp

  src/demoreader.cpp

  src/framedreader.cpp

  src/framedreadersettings.cpp

  src/plotmanager.cpp

  misc/windows_icon.rc

  ${UI_FILES}

  ${RES_FILES}

  )

# Use the Widgets module from Qt 5.

target_link_libraries(${PROGRAM_NAME} ${QWT_LIBRARY})

qt5_use_modules(${PROGRAM_NAME} Widgets SerialPort Svg)

if (BUILD_QWT)

  add_dependencies(${PROGRAM_NAME} QWT)

endif (BUILD_QWT)

# set compiler flags

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")

# Enable C++11 support, fail if not supported

include(CheckCXXCompilerFlag)

CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)

CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)

if(COMPILER_SUPPORTS_CXX11)

  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")

elseif(COMPILER_SUPPORTS_CXX0X)

  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")

    }

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

    }

    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;

}

/*

  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 BINARYSTREAMREADER_H

#define BINARYSTREAMREADER_H

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

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

/*

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

#include "ui_binarystreamreadersettings.h"

#include "utils.h"

BinaryStreamReaderSettings::BinaryStreamReaderSettings(QWidget *parent) :

    QWidget(parent),

    ui(new Ui::BinaryStreamReaderSettings)

{

    ui->setupUi(this);

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

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

            [this](int value)

            {

                emit numOfChannelsChanged(value);

            });

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

            this, SIGNAL(numberFormatChanged(NumberFormat)));

    connect(ui->pbSkipByte, SIGNAL(clicked()), this, SIGNAL(skipByteRequested()));

    connect(ui->pbSkipSample, SIGNAL(clicked()), this, SIGNAL(skipSampleRequested()));

}

BinaryStreamReaderSettings::~BinaryStreamReaderSettings()

{

    delete ui;

}

unsigned BinaryStreamReaderSettings::numOfChannels()

{

    return ui->spNumOfChannels->value();

}

NumberFormat BinaryStreamReaderSettings::numberFormat()

{

    return ui->nfBox->currentSelection();

}

Endianness BinaryStreamReaderSettings::endianness()

{

    return ui->endiBox->currentSelection();

}

/*

  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 BINARYSTREAMREADERSETTINGS_H

#define BINARYSTREAMREADERSETTINGS_H

#include <QWidget>

#include "numberformatbox.h"

#include "endiannessbox.h"

namespace Ui {

class BinaryStreamReaderSettings;

}

class BinaryStreamReaderSettings : public QWidget

{

    Q_OBJECT

public:

    explicit BinaryStreamReaderSettings(QWidget *parent = 0);

    ~BinaryStreamReaderSettings();

    unsigned numOfChannels();

    NumberFormat numberFormat();

    Endianness endianness();

signals:

    void numOfChannelsChanged(unsigned);

    void numberFormatChanged(NumberFormat);

    void skipByteRequested();

    void skipSampleRequested();

private:

    Ui::BinaryStreamReaderSettings *ui;

};

#endif // BINARYSTREAMREADERSETTINGS_H

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

}

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

}

    ui->setupUi(this);

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

            {

                emit selectionChanged(currentSelection());

            });

}

EndiannessBox::~EndiannessBox()

{

    delete ui;

}

Endianness EndiannessBox::currentSelection()

{

    if (ui->rbLittleE->isChecked())

    {

        return LittleEndian;

    }

    else

    {

        return BigEndian;

    }

}

#ifndef ENDIANNESSBOX_H

#define ENDIANNESSBOX_H

#include <QWidget>

namespace Ui {

class EndiannessBox;

}

enum Endianness

{

    LittleEndian,

    BigEndian

};

class EndiannessBox : public QWidget

{

    Q_OBJECT

public:

    explicit EndiannessBox(QWidget *parent = 0);

    ~EndiannessBox();

signals:

    /// Signaled when endianness selection is changed

    void selectionChanged(Endianness endianness);

private:

    Ui::EndiannessBox *ui;

};

#endif // ENDIANNESSBOX_H

    buttonGroup.addButton(ui->rbInt8,   NumberFormat_int8);

    buttonGroup.addButton(ui->rbInt16,  NumberFormat_int16);

    buttonGroup.addButton(ui->rbInt32,  NumberFormat_int32);

    buttonGroup.addButton(ui->rbFloat,  NumberFormat_float);

    QObject::connect(

        &buttonGroup, SIGNAL(buttonToggled(int, bool)),

        this, SLOT(onButtonToggled(int, bool)));

}

NumberFormatBox::~NumberFormatBox()

{

    delete ui;

}

void NumberFormatBox::onButtonToggled(int numberFormatId, bool checked)

{

    if (checked) emit selectionChanged((NumberFormat) numberFormatId);

}

NumberFormat NumberFormatBox::currentSelection()

{

    return (NumberFormat) buttonGroup.checkedId();

}

  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 NUMBERFORMATBOX_H

#define NUMBERFORMATBOX_H

#include <QWidget>

#include <QButtonGroup>

namespace Ui {

class NumberFormatBox;

}

class NumberFormatBox : public QWidget

{

    Q_OBJECT

public:

    explicit NumberFormatBox(QWidget *parent = 0);

    ~NumberFormatBox();

signals:

    /// Signaled when number format selection is changed

    void selectionChanged(NumberFormat numberFormat);

private:

    Ui::NumberFormatBox *ui;

    QButtonGroup buttonGroup;

private slots:

    void onButtonToggled(int numberFormatId, bool checked);

};

#endif // NUMBERFORMATBOX_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_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";

#endif // SETTING_DEFINES_H