Fork me on GitHub
Lorris

Lorris Toolbox

GUI tool written in Qt which aims to be used when dealing with embedded devices, robots
and similar applications where you need to do something with data.

Downloads

There are binaries available for MS Windows. If you're using other operating system, you have to build Lorris yourself.

Windows binaries

You can always download the most recent version here: Lorris.zip
Some of the older version can be found in this repository: Lorris_binaries
Binaries are hosted on Bitbucket.

Python support: all files needed to run Lorris are in the ZIP archive, but you need to install Python 2.7.x if you want all its features. Without it, you will not be able to use extra modules, which means that for example "import random" will result in exception.

Debian/Ubuntu packages

An APT repository is running at http://apt.tasemnice.eu/ubuntu 

# 1. Add the repository key
wget -O - -q https://apt.tasemnice.eu/key.gpg | sudo apt-key add -v -

# 2. Add the lorris repository
echo deb http://apt.tasemnice.eu/ubuntu stable main | sudo tee /etc/apt/sources.list.d/lorris.list

# 3. Update packages and install
sudo apt-get update && sudo apt-get install lorris

The stable dist is for the latest Ubuntu LTS and is likely to work on all recent debian-based distributions. Some other Ubuntu releases are also supported, so you can try those as well (e.g. xenial or zesty).

For Ubuntu 14.04/Mint 17.1, use dist trusty instead:
echo deb http://apt.tasemnice.eu/ubuntu trusty main | sudo tee /etc/apt/sources.list.d/lorris.list

You can find the raw .deb packages in the pool.

Source code

GitHub repository is at https://github.com/Tasssadar/Lorris, you can clone it with: 

git clone git://github.com/Tasssadar/Lorris.git
cd Lorris
git submodule update --init

Testing and newest changes are in "master" branch, stable release is in "stable" branch.

Thanks to github, you can also download source code in ZIP archive or .tar.gz archive.

Description

Main thing about Lorris is that it's modular - program iself provides only connection to target device, modules do all the work. You can run multiple modules at the same time (even connect them to the same port/address/whatever) as tabs, like in web browser.

Lorris is using Qt Framework (4.7), which (also) means it is multiplatform - it is tested on Debian Linux(Wheezy, 64bit) and MS Windows(Xp, 7).
You can find Windows binaries in downloads section.

Available connection types:

Module: Analyzer

Supported connection types: Serial Port, TCP socket, None(load from file)

This module is graphical parser of incomming data, and displays them in user-selected widgets. Incomming data are expected to be in packet format, preferably with some kind of header. Exact packet format is set in this window, it should be pretty self-explanatory.

(Image is worth a thousand words, so take a look at this screenshot so you can understand what am I talking about)
Once you have packet structure set-up, you can drag widgets from right bar to main "workspace". To assign data to widget, just drag desired byte (or first byte from left side, in case you want to display for example uint32, which is 4 bytes long) from top data view to widget. Each widget has it's individual settings, accesible by right-click.

Available widgets:

You can also save currect Analyzer configuration and received data to file, so that you do not have set up everything every time you use it.

Module: Serial port <-> TCP socket proxy

Supported connection types: Serial Port

This module acts as simple proxy between serial port and TCP socket. You can connect from Lorris (or another program) to this proxy via internet network.
It is kinda awsome, we tested it a while ago so that my friend from across the country programmed a chip laying on my table via this proxy :)

Module: Shupito

Supported connection types: Serial Port, TCP Socket

This is controling interface for Shupito programmer. It is programmer of microcontrollers or anything compatible with it. Lorris supports memory read, write and erasing and fuse read and write.

Supported programming interfaces

It also can utilize Shupito's RSR232 tunnel ability. When you set-up tunnel (see this screenshot, left-top), new connection type will appear - "Shupito tunnel". It is basically forwarded serial port, and it acts like one, so every module which use serial port connection can also use Shupito tunnel.

Module: Terminal

Supported connection types: Serial Port, TCP Socket

Standart terminal. It shows incomming data as normal text (and can handle \f, \r, \n and \b control characters) or as hex dump (you can chose mode in top "format" menu).

Terminal also sends key presses to device, and it can do it in two modes:
  1. Send each key press - sends each character immediately after key press
  2. TCP-terminal-like mode - shows what you type in terminal and sends it only when you press return/enter key
You can switch between these modes in "Terminal -> Input handling" top menu.

Build instructions

You will need QtFramework >= 4.7 to build Lorris (4.6 _should_ be also ok, but it is not tested).
Built binaries should be in bin/debug or bin/release.

Building on Windows

Download Qt SDK with Qt version >= 5.4 and gcc compiler and install it.
If you want python support, you also need to install python 2.7.x. If not, comment out line "DEFINES += WITH_PYTHON" in config.pri.
Now download Lorris, open Lorris.pro in QtCreator and hit "Build" button.

Building on Linux

Required packages:

- Qt SDK >= 5.4.0
- make, g++
- libudev-dev
- python-dev == 2.7.x (Only if you want python support in LorrisAnalyzer - see config.pri)

So, apt-get line for Debian Testing would look like this: 

    sudo apt-get install g++ make libudev-dev python2.7-dev qt5-default qttools5-dev qtscript5-dev pkg-config

Now you can build Lorris with QtCreator or go to Lorris folder and execute these commands: 

    ./prepare.sh
    make
    sudo make install

Lorris binary will be installed as /usr/bin/Lorris and translations as /usr/share/lorris/Lorris.*.qm.

What about ARM?
Lorris can be built on ARM cpu, and it works there, so long as it is little-endian ARM. Here is screenshot of Lorris running on my Android phone, under Debian which is in chroot. I am connected to it via VNC. The phone has (overclocked) 768MHz cpu and _really_ slow SD card, so the compilation took about 55 minutes, but it run quicker than I expected.
I may be able to get my hands on the Raspberry Pi soon, so I could test this on real arm computer.

Building on Mac OS X

Lorris can be built on OS X with a bit of effort (since 20b3dc2a75e7), but it looks kinda horrible and there are some weird crashes. Qt on Mac requires OS X version >= 10.6.
Build with python was not tested on OS X, comment out "DEFINES += WITH_PYTHON" line in config.pri

1. XCode

Download Xcode from that Apple store or whatsitsname. Can take a while.
When it is done, open XCode, top menu XCode->Preferences->Downloads and install "Console tools" (GCC is in this package).

2. SDL

Download libSDL source, extract it, open Terminal, go to the libSDL folder you've just created and run: 

./configure
make
sudo make install

3. Qt Framework

Just download Qt framework package and install it.

4. Lorris

Download Lorris source, open Terminal and go to it's folder. 

/Users/*username*/QtSDK/Desktop/*your qt version*/bin/qmake CONFIG+=release
make
sudo make install

Lorris will be installed among other applications (eg. /Applications).

License & third-party libraries

Lorris is licensed under the GNU GPLv3 and uses these 3rd-party libraries:

Bug report

If you find bug in Lorris or if you want some new feature in it, please create an issue on github.

Screenshots


Main window
Analyzer module
Analyzer module - packet structure settings

Shupito module
Terminal module
Serial port <-> TCP proxy module

Main window

Analyzer module

Analyzer module - packet structure settings

Shupito module

Terminal module

Serial port <-> TCP proxy module
This web page is using Twitter's bootstrap