SerialPlot - Realtime Plotting Software

I'm considering moving this project to git. There has been a few requests. Not many. But I feel like reason is that people just don't request such things unless a project is really really popular. Actually there has been a git repository at github for quite some time. But I did not update it. I only kept it for visibility and as another place for people to create tickets.

From now on; I will keep github repository up to date which is at: https://github.com/hyOzd/serialplot

I enjoy using mercurial even though I don't have much opportunity to do so. For a while I will keep using both git and mercurial. There is a mercurial extension called hggit that makes this relatively easy and pain free. For git users there should be no drawbacks.

To be honest if git repository turns into something popular I will probably stop using mercurial altogether.

This is another minor release. There isn't any significant changes.

Changes:

• Filter by prefix for ASCII data format parser (thanks to Alexander Amelkin)
  This is useful when your data is mixed with other information such as log messages. There is no way of displaying such log messages on SerialPlot yet.
• Export SVG (thanks to martijuerg)
• Other minor fixes improvements etc:
  • remember user entered custom baud rate
  • add double precision floating point number format support for binary readers
  • fix 'settings invalid' error when loading config with 'first byte is size byte' enabled
  • fix for data format selection can be empty (no button is selected state which is invalid)

As always you can find latest download links in the sidebar.

Download links for v0.12:

Windows installer: https://serialplot.ozderya.net/downloads/serialplot-0.12.0-win32-setup.exe

Windows EXE 7Zip: https://serialplot.ozderya.net/downloads/serialplot-0.12.0-win32.7z

Windows EXE: https://serialplot.ozderya.net/downloads/serialplot-0.12.0-win32.exe

Linux AppImage (based on Ubuntu 18.04): https://serialplot.ozderya.net/downloads/serialplot-0.12.0-x86_64.AppImage

Well, it's been a while.

But I decided to finally put together a new release. There aren't any big news or changes. To be honest what pushed me to finally create a new release is that I forgot to move the "downloads' section from the bitbucket before they axed the mercurial repositories and as a result got a lot of mails/comments from people around to world. Sorry.

Here are some changes that come in v0.11:

• command line options thanks to Mehmet Aslan
• "value tracker" that displays the sample values under cursor
• "Text View" panel to display read values
• Gain and Offset to adjust input data
• An experimental "Bar Plot" widget
• added icons for Windows
• recorder timestamp format
• decimal precision setting for recorder
• port read statistics
• many fixes

Download links:

Linux AppImage (Ubuntu Trusty based, should work on anything newer):

https://serialplot.ozderya.net/downloads/serialplot-v0.11.0-x86_64.AppImage

Windows 32 bit (should work fine on 64 bit windows):

https://serialplot.ozderya.net/downloads/serialplot-0.11.0-win32.exe

Important: I didn't have time to test either of these images. Please let me know if you have any problems with them.

Building serialplot on windows isn't much different than building on linux. But it isn't as straightforward. Installing dependencies can be difficult. And it is also difficult to build a static EXE that doesn't require DLLs to keep it company. But most importantly it is difficult for me, because I don't use windows other than for gaming purposes. Unfortunately most users of SerialPlot use windows and as a result I can't ignore it.

Luckily there is MXE to my rescue. This is a cross compilation toolchain to build windows binaries (and more) on a linux (unix like) host. Whats more is that they also provide 'static' toolchains. When you build your project with a static toolchain it is easier to deploy and can be smaller in size.

So I prepared a dockerfile to make it even easier to build windows using docker. You can build this docker image on linux. AFAIK there are ways to run docker on windows host but I won't go into any details of that. It is also possible to use MXE in msys2, which is a layer to run unix programs on windows. In fact most of the windows releases until now has been built on windows using msys2 and mxe.

Dockerfile is already included in the serialplot source code called:

Dockerfile_mxe

Assuming you have already installed docker, download the serialplot source code using mercurial and build the docker image:

hg clone https://hg.sr.ht/~hyozd/serialplot/
cd serialplot
sudo docker build -t serialplot_mxe -f Dockerfile_mxe ./

Remember this might easily take a couple hours depending on your internet speed and cpu power. To give you an idea resulting docker image is around 5GB in size.

If all goes well you can get the built binary from inside the docker image with this command:

sudo docker run --rm --entrypoint cat serialplot_mxe /serialplot/build_docker_mxe/serialplot.exe > ../serialplot.exe 

These are the steps for building SerialPlot on linux. I will also provide more detailed steps for Ubuntu and similar debian based distributions.

Building SerialPlot on linux is quite easy. Most difficult part (not really difficult) is gathering the dependencies. It is possible that you already have some of them installed such as a C++ compiler.

I've also described how to build with docker which might be the easiest method if you are familiar with it.

Install Dependencies

You should have following dependencies installed, preferably using your package manager:

• Qt5 Development Package (at least version 5.9; recommended 5.15)
• Qt5 serialport and svg package
• Cmake (version 3.x)
• C++ compiler (somewhat new, should support C++11) and make (usually installed with a base package)
• Mercurial (to download source code, optional)

On ubuntu or similar operating systems you can install these dependencies with the  following command.

sudo apt install build-essential qtbase5-dev libqt5serialport5-dev libqt5svg5-dev cmake mercurial

 Note: instead of 'qtbase5-dev' you can install 'qt5-default' package to make sure it is the default qt version.

Also note: SerialPlot doesn't build with Qt4, you need Qt5.

Also also note: you need internet access during build process. It is not necessary, but if you don't, you have to also have "Qwt" library installed.

Get Source Code

You can download the source code using mercurial with the following command. Mercurial is a version control tool very similar to git.

hg clone https://hg.sr.ht/~hyozd/serialplot

Or if you don't want to deal with the mercurial you can download the latest code from this link.

https://hg.sr.ht/~hyozd/serialplot/archive/tip.tar.gz

Build

When you have everything ready, run following commands in the serialplot directory.

mkdir build
cmake ..
make run

 This should build SerialPlot and start it.

Building AppImage

When you build SerialPlot this way it probably only works on your computer. It should work on other computers with the same distribution as yours as long as they have the correct libraries installed. If you want to lend your build to your friends you can create a portable executable called AppImage. This should run on most distributions. And it is how I release the Gnu/Linux version of the SerialPlot.

It is easy to build SerialPlot appimage.

Run below command in your build directory.

cmake ..
make appimage

That's it. If everything goes well you should  now have SerialPlot appimage in your build directory, and it should run in most distributions (fingers crossed).

Building with Docker

There is a Dockerfile inside the serialplot directory ready to go. It is based on Ubuntu 18.04 (bionic) [used to be 14.04 (trusty)]. Building it, produces an appimage that you can use on Ubuntu/Debian based systems. Maybe on other distros too?

If you don't have it installed, you can install docker on Ubuntu with this command:

sudo apt install docker.io

After that, get into the directory of 'serialplot' where the 'Dockerfile' exists and run this command. It might take some time depending on your internet speed.

sudo docker build -t serialplot_bionic .

 This will build a docker image that should contain the SerialPlot appimage. After building appimage, you should get it from inside the docker image with this command.

sudo docker run --rm --entrypoint cat serialplot_bionic /serialplot/build_docker/SerialPlot-x86_64.AppImage > ./serialplot.appimage

Make it executable and start serialplot:

chmod +x ./serialplot.appimage
./serialplot.appimage

Notes

Although actual build process is quite simple and straightforward, if you are not experienced you may have issues building SerialPlot successfully. It usually is missing dependencies. It rarely is an incompatible library. In that case please leave a comment : ) I will be happy to help.

Also if you have steps for other distributions and recommendations, please share, I will try to add them here.

Bitbucket is removing mercurial support along with all mercurial repositories.

I decided to move the source code to sourcehut.

Here is the mercurial repository: https://hg.sr.ht/~hyozd/serialplot/

Here is the new issue tracker: https://todo.sr.ht/~hyozd/serialplot

I haven't moved download files yet. I will probably have to host them myself. Sourcehut doesn't provide file hosting.

SerialPlot 0.10 is released. This release brings some performance improvements, minor features and bug fixes.

Instead of "number of samples" option in the "Plot" tab, now there are 2 options you can set. "Buffer Size" and "Plot Width". "Buffer Size" is the total number of samples that are kept in memory, while "Plot Width" is the maximum number of samples that are plotted at once, in X axis. To see previous samples you simply use the X axis scrollbar. The main reason for this distinction is the performance. Previously you couldn't set number of samples too high because SerialPlot tried to plot all data at one time. Now you can set "Buffer Size" to 1.000.000 and it will most likely will be fine as long as you keep "Plot Width" small. Another advantage is that, sometimes when you have frequently changing data, zooming way out doesn't mean much, you have too keep a certain zoom level in X axis to be able to see any detail. If you enjoy the old behaviour you can always set buffer size option same number as plot width and it should be fine. Remember though "plot width" option has a smaller limit then "buffer size" for performance reasons. A note; performance improvements are not done. I'm still working on some improvements to increase "buffer size" limitations.

Now you can set RS232 control signals (DTR, RTS) and see input signal () statuses from the "Port" tab. Being able to set DTR signal was a requested feature so that SerialPlot can work with Arduino Leanardo board.

Also we now have an update checker. You can launch it from the "Help" menu. It will check updates once a day when you first launch SerialPlot unless you disable it.

Other improvements and bug fixes:

• custom ASCII (csv) data column delimiter
• fixed snapshot display bug
• fixed command type not loaded/remembered
• fixed duplicated channel names

Check the sidebar for download links. I will try update the win32 version and launchpad PPA later this week.

This patch fixes various issues and adds small improvements:

• fix symbols getting stuck after multiplot mode
• fix symbols in snapshot view
• add options to disable (or always enable) symbols
• panning (Ctrl+Left Mouse) @Maxim
• show snapshot view in current plot settings
• fix snapshot view axis stuck at [0-1]

See downloads links at the sidebar.

Hi everyone, it's release time. First of all I want to thank everyone who contacted me via various channels for their kind comments! And ideas of course... some to be implemented... some day... : )

Changes:

• scrollbars for plot (appears when zoomed)
• continuous recording to CSV file
• channels can be hidden and plot colors are adjustable ("Plot" tab)
• bunch of various GUI improvements and minor bug fixes

Installation for linux:

PPA for Ubuntu 16.04 (xenial) and based distros: https://launchpad.net/~hyozd/+archive/ubuntu/serialplot

Appimage(*) for other distros: https://bitbucket.org/hyOzd/serialplot/downloads/SerialPlot-x86_64.AppImage

Installation for windows:

64bit setup: https://bitbucket.org/hyOzd/serialplot/downloads/serialplot-0.9.0-win64.exe

32bit setup: https://bitbucket.org/hyOzd/serialplot/downloads/serialplot-0.9.0-win32.exe

(*) Appimage may be broken on some systems. Please let me know if you have any problems.