site  contact  history  index

Considering uGFX

August 19, 2018 — BarryK

I posted about a first hands-on with LittlevGL:

http://bkhome.org/news/201808/tentative-first-step-framebuffer-with-littlevgl.html

In an earlier post, there is a list of contenders for creating GUI apps that will run on the Linux framebuffer:

http://bkhome.org/news/201808/gui-creation-for-the-linux-framebuffer.html

...in that post, I mentioned µGFX. Yeah, looks good. The intention now, is to have a hands-on with µGFX.

image

µGFX is commercial, open-source, free for personal and educational use. I am OK with that. In fact, this kind of model might be more likely to stick around into the future (unless the company gets bought by Microsoft, and then dies -- that's a joke!). Also likely to be more sophisticated and polished that a totally freebie product.

One thing that did put me off initially, is that it only generates 32-bit executables. As I am currently working with 64-bit builds of Easy and Quirky, without any 32-bit libraries, this is a problem. Well, that applies to my "Pyro" series, which is compiled from source in my fork of OpenEmbedded.

There is Quirky Xerus 8.6, built with Ubuntu DEBs, and that does have 32-bit libs available, however, I am moving away from that, in future will likely focus on the Pyro series.

Does it matter that executables are 32-bit? Actually, no, as my planned usage is to create static executables, and they will work on both 32-bit and 64-bit systems, no shared libraries required. In which case, there is an advantage to building 32-bit executables.

The easiest platform (for me) on which to evaluate µGFX will be a i686 build of EasyOS, Pyro series. Compiling it right now. Might even release it, for those who still need a 32-bit x86 distro.

Another preliminary impression of µGFX is of it's maturity and capability -- the new beta 0.2 of µGFX-Studio is written using µGFX libraries. It is a drag-and-drop GUI designer. This uses SDL2 and will run on the desktop. Here is a forum thread:

https://community.ugfx.io/topic/843-ugfx-studio-v020-beta/

image

A comment about SDL2: it uses OpenGL for rendering, cannot use the Linux framebuffer. SDL1 can use the framebuffer. Unfortunate!

There is an active user community:

https://community.ugfx.io/

The online documentation looks good:

https://wiki.ugfx.io/

https://api.ugfx.io/

Project homepage:

https://ugfx.io/

Looks good, keen to try it! 

Tags: linux

Tentative first step framebuffer with LittleVGL

August 19, 2018 — BarryK


As posted earlier today, I have started to evaluate LittlevGL:

http://bkhome.org/news/201808/first-go-at-evaluating-littlevgl.html

the "PC simulator" does look like a good starting point, though it is setup to create a binary named "demo" that is linked against SDL2. That's OK for learning, but I am aiming to talk directly to the Linux framebuffer.

For EasyOS, SDL2 packages are available here (libsdl2-*):

http://distro.ibiblio.org/easyos/amd64/packages/compat/oe/pyro/

Download the pc-simulator zip file:

https://littlevgl.com/download
Direct link to version 5.1.1:
https://littlevgl.com/download/pc_simulator_v5_1_1.zip

Expand the zip file, and this is what you see:

image

Open a terminal, and type "make". That's it, a binary named "demo" will be created. Run it "# ./demo", and you get a GUI:

image

There is another tutorial web page that explains how to create a simple "Hello World" app using the Linux framebuffere, so onto that...

Hello World with Linux framebuffer

There is an introduction and tutorial here:

https://littlevgl.com/blog/23/embedded-gui-using-linux-frame-buffer-device-with-littlevgl

I fiddled around for awhile. Like the "PC Simulator" tutorial page, there is a conceptual-gap in the instructions. Here:

2. Compile the code and go back to character terminal mode

...er, how to compile it? For a beginner, this is an awkward step. A Makefile is needed. These are the steps that I followed:

  1. Run "make clean"
  2. In the 'pc-simulator' folder, I moved 'lv-conf.h', 'lv_drv_conf.h', 'lv_ex_conf.h', 'main.c' and 'Makefile' elsewhere.
  3. I then created new 'lv_drv.h', 'lv_conf.h' and 'main.c' as per instructions in the above URL.
  4. I copied-back the 'Makefile' that I had previously moved away, and edited it. Snapshot of the files, 'hide1' is where I moved the original files to:

image

Here is my edited Makefile:

#
# Makefile
#
CC = gcc
CFLAGS = -Wall -Wshadow -Wundef -Wmaybe-uninitialized
CFLAGS += -O3 -g3 -I./
#LDFLAGS += -lSDL2 -lm
BIN = demo
VPATH =

LVGL_DIR = ${shell pwd}

MAINSRC = main.c

#LIBRARIES
include ./lvgl/lv_core/lv_core.mk
include ./lvgl/lv_hal/lv_hal.mk
include ./lvgl/lv_objx/lv_objx.mk
include ./lvgl/lv_misc/lv_fonts/lv_fonts.mk
include ./lvgl/lv_misc/lv_misc.mk
include ./lvgl/lv_themes/lv_themes.mk
include ./lvgl/lv_draw/lv_draw.mk

#DRIVERS
include ./lv_drivers/display/display.mk
include ./lv_drivers/indev/indev.mk

OBJEXT ?= .o

AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT))

MAINOBJ = $(MAINSRC:.c=$(OBJEXT))

SRCS = $(ASRCS) $(CSRCS) $(MAINSRC)
OBJS = $(AOBJS) $(COBJS)

## MAINOBJ -> OBJFILES

all: clean default

%.o: %.c
@$(CC) $(CFLAGS) -c $< -o $@
@echo "CC $<"

default: $(AOBJS) $(COBJS) $(MAINOBJ)
$(CC) -o $(BIN) $(MAINOBJ) $(AOBJS) $(COBJS) $(LDFLAGS)

clean:
rm -f $(BIN) $(AOBJS) $(COBJS) $(MAINOBJ)

I do realise that more modules than are needed, are being included in the build, but that's OK, as I plan to play with adding more widgets. Notice that SDL2 is not being linked.

Run "make", it creates 'demo'. This will not run on the Xorg desktop, though I vaguely recall a method of doing it in a terminal. Anyway, the way to test 'demo' is to exit from X, via the Shutdown menu in EasyOS (and most pups). Then, on the commandline, as long as a framebuffer has command of the screen, which is likely (there are some caveats), just execute 'demo', where-ever it is.

On the commandline, here is what it looks like:

image

That's as far as I've got. Next, need to investigate mouse support...

Tags: linux, easy

First go at evaluating LittlevGL

August 19, 2018 — BarryK

As posted about a couple of days ago on this blog, I have an interest in creating small GUI apps that will talk directly to the Linux framebuffer. Here is the post:

http://bkhome.org/news/201808/gui-creation-for-the-linux-framebuffer.html

I tentatively narrowed the choices down to LittlevGL, uGFX and Nuklear. LittlevGL looks great, so giving it a go. The website:

https://littlevgl.com/

The "PC simulator" looks like a good starting point:

https://littlevgl.com/pc-simulator

...so, I followed the instructions. Installed Eclipse IDE, etc. Got to this part:

Now you are ready to run the Littlev Graphics Library on your PC. Click on the Hammer Icon on the top menu bar to Build the project. If you have done everything right you will not get any errors. Note that on some systems additional steps might be required to "see" SDL 2 from Eclipse but in most of cases the configurtions in the downloaded project is enough.

After a success build click on the Play button on the top menu bar to run the project. Now a window should appear in the middle of your screen.

Now everything is ready to use the Littlev Graphics Library in the practice or begin the developement on your PC.

...er, no, that didn't work. Yeah, the "Hammer Icon" part is OK, it reported a successful build, however, the "Play" button did nothing. Searched the source, couldn't find the compiled files anywhere. Hmmm...

It turned out, the instructions are incomplete, extra steps are required, as explained on YouTube:

https://www.youtube.com/watch?v=ZzLdct2ymvg

However, decided to start again, from scratch. I was not drawn to the Eclipse IDE, it seemed unnecessarily complex, and bloated, requiring Java JRE. Will attempt to do it from  a terminal only.

To keep a clean separation, will create another blog post...

Tags: linux

GUI creation for the Linux framebuffer

August 17, 2018 — BarryK

For a long time I have wanted some means of creating very small GUI apps that are statically compiled and work directly with the Linux framebuffer. The use would be for a GUI app in the initramfs.

I recently discovered LittlevGL, and then decided to ask for the opinion of two guys who are real experts in this field, 'technosaurus' and 'goingnuts' (their Puppy Forum names).

Firstly, here is a post about LittlevGL:

https://littlevgl.com/blog/23/embedded-gui-using-linux-frame-buffer-device-with-littlevgl

I sent a pm on the Puppy Forum to technosaurus, and he responded:


littlevgl has been on my radar for a while now - I do like it, but its no gtkdialog replacement; you can see more of my projects of interest at https://github.com/technosaurus?tab=stars I am in the process of moving from near Houston, Texas to near Kansas City, Missouri (U.S.) We have moved 3 times in 3 years so I have not been coding for some time - just reading/analyzing code for future use (thus all the starred projects, but few commits)

Besides littlevgl, the ones I know of that will work for the framebuffer (and X) are:
https://github.com/vurtun/nuklear forum thread here
https://github.com/memononen/nanovg + oui/blendish
https://github.com/ImpulseAdventure/GUIslice (uses SDL)
https://github.com/grz0zrg/fbg (lacks widgets)

more gtkdialog-like:
http://lcui.org/ some largish dependencies (libpng,libjpeg,
libxml2,freetype,fontconfig)
http://tekui.neoscientists.org/ possibly unmaintained and needs freetype and lua - uses any raw framebuffer (or X11 depending on configuration)

Some notes.

For the ones that use opengl (or GLES) a specially built Mesa is needed and some framebuffer drivers are not supported because they lack support for kernel mode setting (unfortunately no one has ported Fabrice Bellard's tinygl as a fallback)

littlevgl seems to be a retained mode GUI like gtk and kde (but seems to be simplified so that you need ~1/3 less code than gtk and without the huge overhead of c++ and qt) There is a template here and it seems to be targeted to Linux with growing driver support
nuklear and nanovg are immediate mode GUIs which cater toward game development and tend to use more CPU, though nuklear appears to have addressed this since I last tested it. However, since they are single header files, anything unused will get compiled out so they make small binaries.
https://bitbucket.org/duangle/oui-blendish/src

GUIslice could be a good compromise since it uses SDL (1.2 or 2.x) which will handle the framebuffer (or X) for you. It isn't as pretty though - basically an improvement on curses.


I was aware of Nuklear, and did look at it briefly a year or so ago.

Here is another one, uGFX:

https://ugfx.io/

This is a commercial product, free for "home, hobby and educational" use. It is an open source project, and will work with sdl or directly with the framebuffer. Git project site:

https://git.ugfx.io/uGFX/uGFX 

Tags: linux

Quirky Xerus 8.6 released

August 16, 2018 — BarryK

Quirky Linux 8.6 is the latest in the "Xerus" series, binary-compatible with x86_64 Ubuntu 16.04.5 LTS, though built with woofQ and architecturally very different from Ubuntu.
Quirky is an experimental distribution, that forked from Puppy Linux a few years ago, and has followed a different path, exploring some new ideas. Continuing the Puppy tradition, Quirky has a "complete" suite of applications, drivers and utilities, in a very small size.
Version 8.6 is an incremental upgrade from 8.5, with package upgrades and architectural improvements. The SeaMonkey web browser is now 2.49.4 and the Linux kernel 4.14.63. EasyShare, simple network file and printer sharing, continues to evolve, and now supports connection to an Android phone.

Release notes:

http://distro.ibiblio.org/quirky/quirky6/amd64/releases/xerus-8.6/release-xerus64-8.6.htm

There is a choice to download either a ISO file for a CD, or an image for a USB flash drive:

http://distro.ibiblio.org/quirky/quirky6/amd64/releases/xerus-8.6/

Instructions to install:

http://distro.ibiblio.org/quirky/quirky6/amd64/releases/xerus-8.6/howto-install.htm

There are some alternative install scripts, for those experienced on the Linux commandline:

http://distro.ibiblio.org/quirky/quirky6/amd64/releases/xerus-8.6/alternatives/

The latest woofQ, as used to build Quirky 8.6, is here:

http://distro.ibiblio.org/quirky/quirky6/project/woof-project/woof-project-20180816.tar.gz

Forum feedback thread, discussion of 8.6 starts on page 53:

http://murga-linux.com/puppy/viewtopic.php?t=106460

Have fun!

Tags: quirky

EasyShare supports Android phone via USB

August 13, 2018 — BarryK

I posted recently about Android utilities being included in future EasyOS and Quirky releases:

http://bkhome.org/news/201808/android-tools-and-adbfs-rootless-in-oe.html

EasyShare is now using these utilities and supports file sharing via an Android phone connected by USB cable.

The main GUI now has a checkbox "Android USB", and it is very simple to use. Here is a snapshot:

image

The only slight difficulty, very slight, is that Developer mode and USB debugging have to be turned-on on the phone. The phone is automatically discovered, and it is just a matter of clicking the "Mount" button. 

I have updated the EasyShare tutorial page:

http://bkhome.org/easyapps/easyshare-super-easy-network-file-and-printer-sharing.html   

Tags: easy, quirky

CAPITAL F pdf magazine

August 09, 2018 — BarryK

This is interesting. "CAPITAL F" is created by Bryan Lunduke, and the first issue features an interview with the main guy behind Purism and the Librem 5 phone. It also has an overview of all the failed attempts to put Linux, or Linux-like OSs on a phone.

See here:

https://www.patreon.com/posts/20626433

And here is the magazine, a pdf file:

http://capitalf.org/issues/CapitalF-001.pdf

image

And the website:

http://capitalf.org/ 

Tags: ethos

Windows 10 is soooo awful

August 09, 2018 — BarryK

I don't normally use Windows, except for testing purposes, for example developing EasyShare to transfer files.

However, my Asus baby laptop currently has only Windows 10. I did have it dual-booting with Quirky, however there is only 32GB, and there was not enough space for Windows updates. So, restored the ntfs C: partition to fill the drive.

For the past few weeks, have been using it when relaxing in my lounge chair, for general web browsing. Have applied the updates, but the frequency and size of them, and the frequent notifications, makes for a frustrating user experience.

Today, the frustration reached a peak. Installed the latest updates, then on the next reboot, got the login window OK, but after login, just a black screen with a mouse pointer on it. Rebooted several times, even unplugged the power cord, no good.

At the login screen, held down the SHIFT key and then clicked the power button and chose "Reboot", which brings up various recovery options, including one to rollback.

Selected to rollback, but then it asked for my password... oh dear, I don't remember it. Have always logged in with the pin number. So backtracked and selected to bootup, got the login screen, and yippy, this time got the desktop.

I did three things, firstly applied for a new password, got that. Second, went into the Internet connection settings -- it is already set as a timed-data connection, however Windows ignores that and still forces downloads -- but, there is an option to set a data limit, and I chose 1MB per month.

Third, attempted to uninstall the latest updates. Was only able to uninstall a virus-checking-update. When click on the main Windows 10 incremental update, there is no option to uninstall -- very odd.

Anyway, now have a desktop.

I mentioned, years ago, that I was going to get rid of this laptop, as the Cherry Trail CPU is extremely Linux-unfriendly. That situation hasn't changed. Intel never developed proper Linux support for it, and it seems never will. I still have that laptop, but will one day retire it -- though, it probably has a residual use for testing Samba file and printer access.

Tags: ethos