Small and simple software for plotting data from serial port
To make the experience fit your profile, pick a username and tell us what interests you.
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:
Linux AppImage (Ubuntu Trusty based, should work on anything newer):
Windows 32 bit (should work fine on 64 bit windows):
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:
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.
You should have following dependencies installed, preferably using your package manager:
On ubuntu or similar operating systems you can install these dependencies with the following command.
sudo apt install build-essential qtbase5-dev libqt5serialport5-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 "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.
When you have everything ready, run following commands in the serialplot directory.
mkdir build cmake .. make run
This should build SerialPlot and start it.
Note: This only works on ubuntu 14.04 at the moment due to restrictions from appimage creator tool that I use at the moment.
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 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_trusty .
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_trusty /serialplot/build_docker/SerialPlot-x86_64.AppImage > ./serialplot.appimage
Make it executable and start serialplot:
chmod +x ./serialplot.appimage ./serialplot.appimage
Although actual build process is quite simple and straightforward, if you are not experienced you may have issues building SerialPlot successfully. It is usually missing dependencies. It is rarely 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...Read more »
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:
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:
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... : )
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:
(*) Appimage may be broken on some systems. Please let me know if you have any problems.
It's time for another release. As always screenshot first:
As you can see from the screnshot now its possible to plot each channel as a separate row. Activated from menu "View -> Multi Plot".
When you zoom enough symbols are shown to indicate data points.
Another addition is the ability to save application settings to a file. Every time the SerialPlot starts, it loads the settings from the last session automaticaly.
"Number of samples" limit is increased upon request. It was 10 000 samples now it is 1 000 000. My experiments show that, around 100 000 samples, things start to get slow. If you set it to 1M samples you are probably going to have a hard time, obviously this depends on your computer hardware. Because of that SerialPlot will warn you if you try to set it to more than 10 000 samples.
There are also numerous bug fixes.
Download Windows installer: https://bitbucket.org/hyOzd/serialplot/downloads/serialplot-0.8.1-win64.exe
List of changes:
Read more »
Become a member to follow this project and never miss any updates