5 days ago •
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
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.
5 days ago •
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
09/07/2020 at 07:59 •
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:
- Qt5 Development Package (at least version 5.9)
- Qt5 serialport 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 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 try to add them here.
05/01/2020 at 10:15 •
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.
09/27/2018 at 21:11 •
09/03/2017 at 15:19 •
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.
05/05/2017 at 12:25 •
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.
04/17/2017 at 12:55 •
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... : )
- 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:
(*) Appimage may be broken on some systems. Please let me know if you have any problems.
09/27/2016 at 19:36 •
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
06/18/2016 at 18:19 •
List of changes:
- Custom frame format support added.
- Command labels and commands menu added.
- Legend added.
- Skip sample button (for Simple Binary reader) added.
- ASCII mode can determine number of channels automatically.
- Changed shortcut for "Open Port" to F12 (was F2).
- Numerous GUI improvements and bug fixes
Most important addition of this release is the "Custom Frame" data format selection. With this option you can define your own binary data format. A custom frame format is defined as follows:
- Define a frame start sequence (sync word). This is defined as an array of bytes and should be at least 1 byte long. You have to have a sync word!
- Define number of channels.
- Define frame size. It can be a fixed number or you can transfer frame size at the beginning of each frame, right after sync word. Note that frame size byte doesn't count itself.
- Define number type.
- Define endianness.
- Enable/disable checksum byte. When enabled checksum byte is sent at the end of each frame. It should be the least significant byte of the byte sum of all the samples. This basically includes all bytes between the frame size byte and checksum byte.
I plan to write a tutorial on how to use this feature in detail with some code examples in the near feature.
New for this release, I've created an ubuntu ppa which makes installing software and updates very easy. Here is how:
sudo add-apt-repository ppa:hyozd/serialplot sudo apt-get update sudo apt-get install serialplotIf you want to access .deb packages directly. You can find them on the sidebar links.
Here is the windows setup by the way. Still 64bit only at the moment.