cdddeef73834c62a8ba5f3ac4c000cd4cb059e06 v0.1

73524cc41d6c6f4a664b39a74ae202be21b58eaf v0.2

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules/")

# Find the QtWidgets library

find_package(Qt5Widgets)

# Find QWT or use static

set(QWT_USE_STATIC false CACHE BOOL "Use a static version of Qwt provided by user.")

set(QWT_STATIC_LIBRARY "" CACHE FILEPATH "Path to the static Qwt library, libqwt.a.")

set(QWT_STATIC_INCLUDE "" CACHE PATH "Path to the Qwt include directory when building Qwt static.")

if (QWT_USE_STATIC)

  set(QWT_LIBRARY ${QWT_STATIC_LIBRARY})

  set(QWT_INCLUDE_DIR ${QWT_STATIC_INCLUDE})

else (QWT_USE_STATIC)

  find_package(Qwt 6.1 REQUIRED)

endif (QWT_USE_STATIC)

# includes

include_directories(${QWT_INCLUDE_DIR})

# wrap UI files

qt5_wrap_ui(UI_FILES mainwindow.ui portcontrol.ui about_dialog.ui)

# Tell CMake to create the helloworld executable

# Use the Widgets module from Qt 5.

target_link_libraries(serialplot ${QWT_LIBRARY})

qt5_use_modules(serialplot Widgets SerialPort Svg)

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

else()

  message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")

endif()

# version number

set(MAJOR_VERSION 0)

set(PATCH_VERSION 0)

set(VERSION_STRING "${MAJOR_VERSION}.${MINOR_VERSION}.${PATCH_VERSION}")

# get revision number from mercurial

find_program(MERCURIAL hg)

if (MERCURIAL)

  execute_process(COMMAND ${MERCURIAL} id -i

    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}

    RESULT_VARIABLE MERCURIAL_RESULT

    OUTPUT_VARIABLE VERSION_REVISION

    OUTPUT_STRIP_TRAILING_WHITESPACE)

  if(NOT MERCURIAL_RESULT EQUAL 0)

    set(VERSION_SCM_REVISION false)

  endif(NOT MERCURIAL_RESULT EQUAL 0)

endif (MERCURIAL)

if (NOT VERSION_REVISION)

  set(VERSION_REVISION "0")

endif (NOT VERSION_REVISION)

message("SCM revision: ${VERSION_REVISION}")

# configure version file

configure_file("${CMAKE_CURRENT_SOURCE_DIR}/version.h.in" "${CMAKE_CURRENT_BINARY_DIR}/version.h")

# add make run target

add_custom_target(run

    COMMAND serialplot

    DEPENDS serialplot

    WORKING_DIRECTORY ${CMAKE_PROJECT_DIR}

)

# installing

install(TARGETS serialplot DESTINATION bin)

# install menu item and icon

find_program(XDG-DESKTOP-MENU xdg-desktop-menu)

find_program(XDG-ICON-RESOURCE xdg-icon-resource)

# first copy files to share/serialplot/

install(FILES

  ${CMAKE_SOURCE_DIR}/misc/serialplot.desktop

  ${CMAKE_SOURCE_DIR}/misc/serialplot.png

  DESTINATION share/serialplot)

# install copyright file (in debian format)

install(FILES

  ${CMAKE_SOURCE_DIR}/debian/copyright

  DESTINATION share/doc/serialplot/)

install(CODE "

  execute_process(COMMAND ${XDG-DESKTOP-MENU} install --novendor ${CMAKE_INSTALL_PREFIX}/share/serialplot/serialplot.desktop)

  execute_process(COMMAND ${XDG-ICON-RESOURCE} install --novendor --size 256 ${CMAKE_INSTALL_PREFIX}/share/serialplot/serialplot.png)

")

# uninstalling

configure_file(

  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"

  "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"

  IMMEDIATE @ONLY)

add_custom_target(uninstall

  COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake

  COMMAND ${XDG-DESKTOP-MENU} uninstall --novendor serialplot.desktop

  COMMAND ${XDG-ICON-RESOURCE} uninstall --novendor --size 256 serialplot)

# packaging

set(CPACK_GENERATOR "DEB")

include(InstallRequiredSystemLibraries)

set(CPACK_PACKAGE_NAME "serialplot")

set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Small and simple software for plotting data from serial port")

set(CPACK_PACKAGE_CONTACT "Hasan Yavuz Özderya <hy@ozderya.net>")

set(CPACK_PACKAGE_VERSION_MAJOR ${MAJOR_VERSION})

set(CPACK_PACKAGE_VERSION_MINOR ${MINOR_VERSION})

set(CPACK_PACKAGE_VERSION_PATCH ${PATCH_VERSION})

set(CPACK_STRIP_FILES TRUE)

set(CPACK_DEBIAN_PACKAGE_DEPENDS "libqt5widgets5 (>= 5.2.1), libqt5serialport5 (>= 5.2.1), libc6 (>= 2.19)")

if (NOT QWT_USE_STATIC)

  set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libqwt6-qt5 (>= 6.1.1)")

endif (NOT QWT_USE_STATIC)

set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA "${CMAKE_SOURCE_DIR}/debian/postinst" "${CMAKE_SOURCE_DIR}/debian/postrm")

# set debian package name

string(TOLOWER "${CPACK_PACKAGE_NAME}" CPACK_PACKAGE_NAME_LOWERCASE)

find_program(DPKG_PROGRAM dpkg DOC "dpkg program of Debian-based systems")

if(DPKG_PROGRAM)

  execute_process(

    COMMAND ${DPKG_PROGRAM} --print-architecture

    OUTPUT_VARIABLE CPACK_DEBIAN_PACKAGE_ARCHITECTURE

    OUTPUT_STRIP_TRAILING_WHITESPACE)

  set(CPACK_PACKAGE_FILE_NAME

	"${CPACK_PACKAGE_NAME_LOWERCASE}_${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}")

else(DPKG_PROGRAM)

  set(CPACK_PACKAGE_FILE_NAME

	"${CPACK_PACKAGE_NAME_LOWERCASE}_${PROJECT_VERSION}-${PROJECT_VERSION_REVISION}_${CMAKE_SYSTEM_NAME}")

endif(DPKG_PROGRAM)

include(CPack)

# SerialPlot

Small and simple software for plotting data from serial port.

![SerialPlot v0.2 Screenshot](http://i.imgur.com/l7mNWfB.png)

## Features

* Reading data from serial port

* Binary data formats (u)int8, (u)int16, (u)int32, float

* ASCII input (Comma Separated Values)

* Synchronized multi channel plotting

## Dependencies

- Qt 5, including SerialPort module

- Qwt 6.1

## Building

### Obtain Dependencies

- Qt5 development packages

- Qt5 SerialPort module

- CMake

- Mercurial

Under Ubuntu/Debian:

```sudo apt-get install qtbase5-dev libqt5serialport5-dev cmake mercurial```

### Download and Install Qwt

[Qwt](http://qwt.sourceforge.net) is the library that provides

plotting widgets for SerialPlot. As of this moment there is no

appropriate version of Qwt in debian repositories. You will need to

download and build Qwt with Qt5 yourself.

Download Qwt 6 from here: http://sourceforge.net/projects/qwt/files/

Follow these instructions to build and install:

http://qwt.sourceforge.net/qwtinstall.html#qwtinstall-unix

Make sure that you have built the Qwt with Qt 5 not Qt 4.

### Download and Build SerialPlot

You can use Mercurial to download SerialPlot source code. Or you can

download it from here:

https://bitbucket.org/hyOzd/serialplot/downloads

    hg clone https://hyOzd@bitbucket.org/hyOzd/serialplot

    cd serialplot

    mkdir build && cd build

    cmake ..

    make

You can also build with QtCreator IDE using `serialplot.pro` file.

## Known Issues

- Port error 13 happens when closing. This is a Qt issue. It's known

  to not happen with Qt 5.4.1 . Not fatal.

## License

<?xml version="1.0" encoding="UTF-8"?>

<ui version="4.0">

 <class>AboutDialog</class>

 <widget class="QDialog" name="AboutDialog">

  <property name="geometry">

   <rect>

    <x>0</x>

    <y>0</y>

    <width>487</width>

    <height>325</height>

   </rect>

  </property>

  <property name="windowTitle">

   <string>About</string>

  </property>

  <layout class="QVBoxLayout" name="verticalLayout">

   <item>

    <widget class="QLabel" name="lbAbout">

     <property name="text">

     </property>

     <property name="wordWrap">

      <bool>true</bool>

     </property>

     <property name="openExternalLinks">

      <bool>true</bool>

     </property>

    </widget>

   </item>

   <item>

    <layout class="QHBoxLayout" name="horizontalLayout">

     <item>

      <widget class="QPushButton" name="pbAboutQt">

       <property name="text">

        <string>About Qt</string>

       </property>

      </widget>

     </item>

     <item>

      <widget class="QDialogButtonBox" name="buttonBox">

       <property name="orientation">

        <enum>Qt::Horizontal</enum>

       </property>

       <property name="standardButtons">

#

# Copyright © 2015 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/>.

#

#

# Note: This module will only find local Qwt installations in

# /usr/local/qwt-VERSION directories.

#

if(qwt_glob_dir)

  foreach(qwt_path ${qwt_glob_dir})

	# find the qwt_global.h file

	unset(qwt_root CACHE)

	find_path(qwt_root

	  "include/qwt_global.h"

	  HINTS "${qwt_path}")

	if(qwt_root)

	  list(APPEND qwt_roots ${qwt_root})

	endif(qwt_root)

  endforeach(qwt_path)

endif(qwt_glob_dir)

# select qwt root according to version

if(qwt_roots)

  foreach(qwt_root ${qwt_roots})

	# extract the version information

	unset(qwt_version_string)

	file(STRINGS "${qwt_root}/include/qwt_global.h" qwt_version_string

	  REGEX "#define[ \t]+QWT_VERSION_STR")

	if(qwt_version_string)

	  string(REGEX REPLACE "[^\"]*\"([0-9.]+)\".*" "\\1"

		qwt_version_string ${qwt_version_string})

#include <QtGlobal>

template <> inline float qbswap<float>(float source)

{

    float result;

    char* s = (char*) &source;

    char* t = (char*) &result;

    t[0] = s[3];

    t[1] = s[2];

    t[2] = s[1];

    t[3] = s[0];

    return result;

}

  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 <QFile>

#include <QTextStream>

#include <QtDebug>

#include <QtEndian>

#include <QTextCursor>

#include <qwt_plot.h>

#include <limits.h>

#include <cmath>

#include <iostream>

#include "utils.h"

#include "version.h"

#include "floatswap.h"

MainWindow::MainWindow(QWidget *parent) :

    QMainWindow(parent),

    ui(new Ui::MainWindow),

    portControl(&serialPort)

{

    ui->setupUi(this);

    ui->tabWidget->insertTab(0, &portControl, "Port");

    ui->tabWidget->setCurrentIndex(0);

    setupAboutDialog();

    // init UI signals

    // menu signals

    QObject::connect(ui->actionHelpAbout, &QAction::triggered,

              &aboutDialog, &QWidget::show);

    QObject::connect(ui->actionExportCsv, &QAction::triggered,

                     this, &MainWindow::onExportCsv);

    QObject::connect(&portControl, &PortControl::portToggled,

                     this, &MainWindow::onPortToggled);

    QObject::connect(&portControl, &PortControl::skipByteRequested,

                     this, &MainWindow::skipByte);

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

                     this, &MainWindow::onNumOfSamplesChanged);

    QObject::connect(ui->cbAutoScale, &QCheckBox::toggled,

                     this, &MainWindow::onAutoScaleChecked);

    QObject::connect(ui->spYmin, SIGNAL(valueChanged(double)),

                     this, SLOT(onYScaleChanged()));

    QObject::connect(ui->spYmax, SIGNAL(valueChanged(double)),

                     this, SLOT(onYScaleChanged()));

    QObject::connect(ui->actionClear, SIGNAL(triggered(bool)),

                     this, SLOT(clearPlot()));

    // setup number of channels spinbox

    QObject::connect(ui->spNumOfChannels,

                     SELECT<int>::OVERLOAD_OF(&QSpinBox::valueChanged),

    {

        dataX[i] = i;

    }

    // init channel data and curve list

    for (unsigned int i = 0; i < numOfChannels; i++)

    {

        channelsData.append(DataArray(numOfSamples, 0.0));

        curves.append(new QwtPlotCurve());

        curves[i]->setSamples(dataX, channelsData[i]);

        curves[i]->setPen(makeColor(i));

        curves[i]->attach(ui->plot);

    }

    // init number format

    if (numberFormatButtons.checkedId() >= 0)

    {

        selectNumberFormat((NumberFormat) numberFormatButtons.checkedId());

    }

    else

    {

        selectNumberFormat(NumberFormat_uint8);

    }

    // init text view

    ui->ptTextView->setEnabled(ui->cbEnableTextView->isChecked());

    // TODO: does this work in binary mode? (no new lines)

    ui->ptTextView->setMaximumBlockCount(10000);

    QObject::connect(ui->cbEnableTextView, &QCheckBox::toggled,

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

    QObject::connect(ui->pbClearTextView, &QPushButton::clicked,

                     ui->ptTextView, &QPlainTextEdit::clear);

    // Init demo mode

    demoCount = 0;

    demoTimer.setInterval(100);

    QObject::connect(&demoTimer, &QTimer::timeout,

                     this, &MainWindow::demoTimerTimeout);

    QObject::connect(ui->actionDemoMode, &QAction::toggled,

                     this, &MainWindow::enableDemo);

}

MainWindow::~MainWindow()

{

    for (auto curve : curves)

    {

        delete curve;

    }

    if (serialPort.isOpen())

    {

        serialPort.close();

    }

    delete ui;

}

void MainWindow::setupAboutDialog()

{

    Ui_AboutDialog uiAboutDialog;

    uiAboutDialog.setupUi(&aboutDialog);

    QObject::connect(uiAboutDialog.pbAboutQt, &QPushButton::clicked,

                     [](){ QApplication::aboutQt();});

                for (unsigned int ci = 0; ci < numOfChannels; ci++)

                {

                    channelSamples[ci].replace(i, (this->*readSample)());

                }

                i++;

            }

            for (unsigned int ci = 0; ci < numOfChannels; ci++)

            {

                addChannelData(ci, channelSamples[ci]);

            }

        }

    }

    else

    {

        serialPort.clear(QSerialPort::Input);

    }

}

void MainWindow::onDataReadyASCII()

{

    while(serialPort.canReadLine())

    {

        QByteArray line = serialPort.readLine();

        line = line.trimmed();

        if (ui->cbEnableTextView->isChecked())

        {

            ui->ptTextView->appendPlainText(line);

        }

        auto separatedValues = line.split(',');

        if (separatedValues.length() >= int(numOfChannels))

        {

            for (unsigned int ci = 0; ci < numOfChannels; ci++)

            {

                double channelSample = separatedValues[ci].toDouble();

                addChannelData(ci, DataArray({channelSample}));

            }

        }

        else // there is missing channel data

        {

            qWarning() << "Incoming data is missing data for some channels!";

            for (int ci = 0; ci < separatedValues.length(); ci++)

            {

                double channelSample = separatedValues[ci].toDouble();

                addChannelData(ci, DataArray({channelSample}));

        }

    }

    else if (offset == 0)

    {

        (*channelDataArray) = data;

    }

    else

    {

        // shift old samples

        int shift = data.size();

        for (int i = 0; i < offset; i++)

        {

            (*channelDataArray)[i] = (*channelDataArray)[i + shift];

        }

        // place new samples

        for (int i = 0; i < data.size(); i++)

        {

            (*channelDataArray)[offset + i] = data[i];

        }

    }

    // update plot

    curves[channel]->setSamples(dataX, (*channelDataArray));

    ui->plot->replot(); // TODO: replot after all channel data updated

}

void MainWindow::clearPlot()

{

    for (unsigned int ci = 0; ci < numOfChannels; ci++)

    {

        channelsData[ci].fill(0.0);

        curves[ci]->setSamples(dataX, channelsData[ci]);

    }

    // update plot

    ui->plot->replot();

}

void MainWindow::onNumOfSamplesChanged(int value)

{

    unsigned int oldNum = this->numOfSamples;

    numOfSamples = value;

    // resize data arrays

    if (numOfSamples < oldNum)

    {

        dataX.resize(numOfSamples);

        for (unsigned int ci = 0; ci < numOfChannels; ci++)

    {

        QTextCursor cursor(ui->ptTextView->document());

        cursor.movePosition(QTextCursor::End);

        QByteArray ba((char*) &data, sizeof(data));

        cursor.insertText(ba.toHex() + " ");

    }

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

    {

        data = qFromLittleEndian(data);

    }

    else

    {

        data = qFromBigEndian(data);

    }

    return double(data);

}

bool MainWindow::isDemoRunning()

{

    return ui->actionDemoMode->isChecked();

}

void MainWindow::demoTimerTimeout()

{

    demoCount++;

    if (demoCount > 100) demoCount = 0;

    if (!ui->actionPause->isChecked())

    {

        for (unsigned int ci = 0; ci < numOfChannels; ci++)

        {

            DataArray data(1);

            data.replace(0, (ci + 1)*demoCount);

            addChannelData(ci, data);

        }

    }

}

void MainWindow::enableDemo(bool enabled)

{

    if (enabled)

    {

        if (!serialPort.isOpen())

        {

            demoTimer.start();

            ui->actionDemoMode->setChecked(true);

        }

        else

        {

            ui->actionDemoMode->setChecked(false);

        }

    }

    else

    {

        demoTimer.stop();

        ui->actionDemoMode->setChecked(false);

    }

}

/*

  Below crude drawing demostrates how color selection occurs for

  given channel index

  0°                     <--Hue Value-->                           360°

  |* . o . + . o . * . o . + . o . * . o . + . o . * . o . + . o . |

  * -> 0-3

  + -> 4-7

  o -> 8-15

  . -> 16-31

 */

QColor MainWindow::makeColor(unsigned int channelIndex)

{

    auto i = channelIndex;

    if (i < 4)

    {

        return QColor::fromHsv(360*i/4, 255, 230);

/*

  Copyright © 2015 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef MAINWINDOW_H

#define MAINWINDOW_H

#include <QMainWindow>

#include <QButtonGroup>

#include <QString>

#include <QVector>

#include <QList>

#include <QSerialPort>

#include <QSignalMapper>

#include <QTimer>

#include <QColor>

#include <QtGlobal>

#include <qwt_plot_curve.h>

#include "portcontrol.h"

#include "ui_about_dialog.h"

namespace Ui {

class MainWindow;

}

class MainWindow : public QMainWindow

{

    Q_OBJECT

public:

    explicit MainWindow(QWidget *parent = 0);

    ~MainWindow();

    void messageHandler(QtMsgType type, const QMessageLogContext &context,

                        const QString &msg);

private:

    enum NumberFormat

    {

        NumberFormat_uint8,

        NumberFormat_uint16,

        NumberFormat_int8,

        NumberFormat_int16,

        NumberFormat_int32,

        NumberFormat_float,

        NumberFormat_ASCII

    };

    Ui::MainWindow *ui;

    QButtonGroup numberFormatButtons;

    QDialog aboutDialog;

    void setupAboutDialog();

    QSerialPort serialPort;

    PortControl portControl;

    unsigned int numOfSamples;

    unsigned int numOfChannels;

    QList<QwtPlotCurve*> curves;

    typedef QVector<double> DataArray;

    DataArray dataX;   // array that simply contains numbers 0..numberOfSamples

    QList<DataArray> channelsData;

    void addChannelData(unsigned int channel, DataArray data);

    NumberFormat numberFormat;

    unsigned int sampleSize; // number of bytes in the selected number format

    double (MainWindow::*readSample)();

    // note that serialPort should already have enough bytes present

    template<typename T> double readSampleAs();

    bool skipByteRequested;

    // demo

    QTimer demoTimer;

    int demoCount;

    bool isDemoRunning();

    QColor makeColor(unsigned int channelIndex);

private slots:

    void onPortToggled(bool open);