Our community member @cpu20 wrote a very nice and detailed step-by-step guide on how to use the µGFX library in an Eclipse project. Check it out!
About this blog
Entries in this blog
The µGFX project has grown steadily over the past five and a half years. It has become much bigger than what I ever expected back when I started it as a hobby project. Until now, the µGFX project was part of my company named Bodenmann Electronics. Today we made a huge step forward by creating a dedicated company named uGFX GmbH. The German abbreviation GmbH means Limited Liability Company or short: LLC.
Our headquarter is still in Switzerland but we have now a branch office in Australia to further expand and to provide support more efficiently.
Also, our Graphics & User-Interface designer @thoeby will act as a social media engineer. You should expect a lot more content in the future targeted towards extending this awesome community. To get started, here's a way to win either a free STM32F7-Discovery board or an Arduino with an LCD-Shield: Simply like our Facebook page and the corresponding post to participate: https://www.facebook.com/ugfx.io
Until now, the generic framebuffer driver supported RGB888 and BGR888 only through the unpacked 32-bits format. Now there is a new driver "Fb24bpp" that supports a framebuffer using RGB888 and BGR888 packed formats (24-Bits).
Certain configuration parameters that affected the rendering performance & resource usage when rendering images have now been exposed to the configuration file. This allows changing the performance of the image rendering depending on how many resources (mainly memory) the target hardware has to offer. The following configuration options are now available:
The default values have not been changed. Therefore, simply not touching these values will not change the behavior of the system when upgrading.
We added a new function named gwinListItemSetText() that allows changing the text of list items without re-populating the entire list.
The µGFX library version 2.7 has been released just a couple of moments ago and is now available for download in the download section.
Let's have a look at the change log:
FEATURE: Added EXC7200 driver FEATURE: Added STM32F439i-EVAL board files FIX: Fixed crash when passing NULL to gwinSetStyle() FIX: Fixed potential crash when GDISP_NEED_TEXT_WORDWRAP is turned on FEATURE: Added SDL driver FEATURE: Added ILI9225 driver FEATURE: Added ST7735 driver FEATURE: Added Linux event input driver FIX: Fixed an issue with color formats in Linux-Framebuffer board files FIX: Fixed and improving arc rendering functions FIX: Preventing possible crash when no valid GWIN default font has been set FIX: Updating Windows binaries of the font encoder to improve compatibility FIX: Fixed progressbar bounds checking and decrementing FEATURE: Added gdispFillDualCircle() FIX: Fixed an issue in the filled polygon drawing function which caused irregularities FEATURE: Added high-level functions to modify image color palettes FIX: Improving gdispDrawThickLine() FEATURE: Added gdispAddFont() for adding a dynamic font to the permanent font list FEATURE: Added gmiscHittestPoly() for checking whether a point is inside of a polygon FIX: Fixed strange multi-thread issues in GEVENT FEATURE: Added ILI9488 driver FEATURE: Added the ability to display the detected compiler FIX: Fixed an illegal instruction in the Cortex M0 task switcher FEATURE: Added RAW32 task switching functions which work with ARMCC (the compiler used by Keil) for Cortex M0,M1,M3,M4 and M7 FEATURE: Added gdispGDrawThickArc() FIX: Fixed a memory merging issue with the RAW32 memory allocator FIX: Update RAW32 libc threads support for more recent versions of the MinGW compiler
Upgrading & Compatibility
This new version of the µGFX library is fully compatible with any previous 2.x release. Upgrading is quite easy as you just have to replace your current version of the library with the new one.
New drivers & board support
This release contains support for many new drivers and some boards. We have reserved ourselves a chunk of time during the upcoming month of January where we will create a set of easy to use, pre-configured read-to-run projects for different combinations of boards, underlying systems and IDEs. We feel like we have let that slip by in the past. Being able to just download & run appears to be every important to many community members so we'll try to improve that. Of course any help is highly welcomed here.
Various fixes are part of this new release. While some of these only fix cosmetic issues (eg. off-by-one pixel), others are quite vital to prevent crashes and unexpected behavior of the application. Therefore, we strongly recommend everybody to upgrade to this new version.
We'd like to thank the entire community for making this possible. It wouldn't be possible for us to provide this software in this form without your continuous contributions, donations, feedback and more. Having a community like the one we have is something we know to value.
Please don't hesitate to leave your comments below and opening a forum topic if you have any questions regarding the new release.
The RAW32 port which allows running µGFX on a baremetal platform was known to cause issues when using the ARMCC compiler (the compiler used by Keil µVision). These issues have finally been resolved. The RAW32 port now runs fine & efficient without any further dependencies with ARMCC on Cortext-M0, M1, M3, M4, M4F, M7 and M7F processors.
A new function has been added to the GDISP module that allows drawing thick arcs: gdispGDrawThickArc().
/** * @brief Draw a thick arc. * @pre GDISP_NEED_ARC must be TRUE in your gfxconf.h * * @param[in] g The display to use * @param[in] xc,yc The center point * @param[in] startradius The inner radius of the thick arc * @param[in] endradius The outer radius of the thick arc * @param[in] startangle The start angle (0 to 360) * @param[in] endangle The end angle (0 to 360) * @param[in] color The color of the arc * * @note This routine requires trig support. It can either come from your C runtime library * cos() and sin() which requires floating point support (and is slow), or you can define GFX_USE_GMISC * and either GMISC_NEED_FIXEDTRIG or GMISC_NEED_FASTTRIG. * GMISC_NEED_FASTTRIG uses table based floating point trig operations. * GMISC_NEED_FIXEDTRIG uses fixed point integer trig operations. * Note accuracy on both the table based options are more than adequate for the one degree * resolution provided by these arc routines. Both are much faster than your C runtime library. * * @api */ void gdispGDrawThickArc(GDisplay *g, coord_t xc, coord_t yc, coord_t startradius, coord_t endradius, coord_t startangle, coord_t endangle, color_t color); #define gdispDrawThickArc(x,y,rs,re,s,e,c) gdispGDrawThickArc(GDISP,x,y,rs,re,s,e,c)
A new function has been added to the GMISC module which allows testing whether a certain point is inside of a given polgyon:
/** * @brief Check whether a point is inside or on the edge of a polygon * @pre Requires GFX_USE_GMISC and GMISC_NEED_HITTEST_POLY * * @note This function works both with convex and concave polygons * * @param[in] pntarray The array of points that form the polygon * @param[in] cnt The number of points in the point array @pntarray * @param[in] p The point to test * * @return @p TRUE if the point @p p is inside or on the edge of the polygon @p pntarray, @p FALSE otherwise. * * @api */ bool_t gmiscHittestPoly(const point *pntarray, unsigned cnt, const point *p);
We added a new function named gdispAddFont() to the GDISP module. This new function allows adding new fonts to the internal font list during runtime. This allows loading fonts from external mass storage devices such as external FLASH chips or an SD-Card.
/** * @brief Add a font permanently to the font list. * @returns TRUE on success. Reasons it may fail: out of memory, if it is already on the list, it is not a font loaded in RAM. * @pre GDISP_NEED_TEXT must be TRUE in your gfxconf.h * * @param[in] font The font to add to the font list. * * @api */ bool_t gdispAddFont(font_t font);
Certain image formats such as GIF, PNG and some of the BMP formats use color palettes. We added new high-level API functions to access and modify those color palettes:
uint16_t gdispImageGetPaletteSize(gdispImage *img); color_t gdispImageGetPalette(gdispImage *img, uint16_t index); bool_t gdispImageAdjustPalette(gdispImage *img, uint16_t index, color_t newColor);
These new functions allow to modify the color palettes dynamically during run time. This can be very handy, especially for things like icons. Colors can now be exchanged dynamically which allows having an image (icon) only once in memory but displaying it with different colors (eg. for different application themes).
The following screenshot shows how the same image can be drawn multiple times with different colors:
This demo is available as a ready-to-run demo under /demos/modules/gdisp/images_palettes.
Currently we only implemented support for these new high-level functions in the BMP image format. We'll add support for GIF and PNG in the following days/weeks.
Our new community member @Corentin Barman fixed a bug in the gdispGFillConvexPoly() function. That bug has been around for quite some time and caused issues many times. The symptoms of the bug were "off by one" errors that lead to irregularities in symmetrical shapes and other issues. More information can be found in the corresponding pull request.
The bug has been fixed as part of the bug report from @Aivars Plume:
We added a new rendering function to the GDISP module that's named gdispGFillDualCircle(). That new function allows rendering two filled, concentric circles. The result is the same as rendering a circle with a larger radius in one color and then rendering a circle with a different color and a smaller radius at the same center. However, this new, optimized function only takes one pass to render the entire dual circle and therefore is not only a lot faster but also prevents any flickering due to overwriting a large area with a different color.
The new setting GDISP_NEED_DUALCIRCLE needs to be set to TRUE in order to be able to use this new function.
#if GDISP_NEED_DUALCIRCLE /** * @brief Draw two filled circles with the same centre. * @pre GDISP_NEED_DUALCIRCLE must be TRUE in your gfxconf.h * * @param[in] g The display to use * @param[in] x,y The center of the circle * @param[in] radius1 The radius of the larger circle * @param[in] color1 The color to use for the larger circle * @param[in] radius2 The radius of the smaller circle * @param[in] color2 The color to use for the smaller circle * * @api */ void gdispGFillDualCircle(GDisplay *g, coord_t x, coord_t y, coord_t radius1, color_t color1, coord_t radius2, color_t color2); #define gdispFillDualCircle(x,y,r1,c1,r2,c2) gdispGFillDualCircle(GDISP,x,y,r1,c1,r2,c2) #endif
Today we launched our brand new website! Check this forum topic for more information:
The uGFX arc filling routine is a complex operation with lots of edge cases. It is (as far as we can tell) the only arc filling algorithm on the internet for which source code is published. This routine is one that we created from scratch specifically for uGFX (wait for an upcoming wiki article on how it works).
The bugs fixed are:
1. Certain small angles would fill the entire circle. For example, a filled arc from 88o to 89o would exhibit this problem.
2. Certain angles would draw a spurious horizontal line. For example, a filled arc from 271o to 275o would exhibit this problem.
Integer rounding improvements were made to provide greater accuracy on small displays or with arcs with small radii. These improvements have also been added to the arc drawing routine.
There is also a small change in behaviour to arc filling. If you fill from 30 degrees to 30 degrees it would previously fill the entire circle. It now draws a line at the 30 degree angle.
µGFX applications can run as native Linux applications through either the bare Linux framebuffer or the SDL drivers. We created a step-by-step tutorial showing how to compile & run a µGFX application on an embedded Linux device. The guide is available here: https://wiki.ugfx.io/index.php/Raspberry_Pi
A complete project for the Raspberry Pi 3 can be downloaded from the downloads section. We used the official Raspberry Pi Foundation 7" touchscreen in our tests but the example project works with any kind of video output device (eg. a regular HDMI monitor).
We fixed an issue with color formats in the Linux framebuffer board files. The issue prevented running µGFX with the stock board files on most RGB888 system.
Thank you @lentinj for bringing this issue to our attention.
We added a driver to the repository to use touchscreens/mice through the Linux event system (eg. /dev/input/event0). Along with the driver we provide the corresponding new board files named Linux-Framebuffer-Touch to use touchscreens with embedded Linux systems that run µGFX applications through direct framebuffer access. Using these new board files, any embedded Linux system with a working touchscreen or mouse can be used to run full µGFX applications.
Repository commit: https://git.ugfx.io/uGFX/uGFX/commit/ac5e96cca18884727b165f4245e42887ef0e3a21
Two new display drivers have been added to the repository: ILI9225 and ST7735.
Big "Thanks!" towards @olegator for contributing these drivers. Nice work!
We created an extensive guide that explains how the µGFX library can be added to a PSoC 5LP based project using the PSoC Creator IDE. Furthermore, we added a complete pre-configured and ready-to-run example project that demonstrates runs on the PSoC 5LP Prototyping Kit (CY8CKIT-059) that is available for $10 and an ILI9341 display module connected over SPI that is available for $5.
Our community member @olegator contributed a new driver that uses the SDL library (huge thanks at this point!).
This new driver is a replacement for the current X driver that allows running µGFX as native applications on Linux and OS X (or rather almost any Unix system). The old X driver had serious performance issues because it only relied on setPixel() to change each pixel. The new SDL driver VASTLY improves performance as the video below demonstrates. Furthermore, the new SDL driver also implements the GINPUT keyboard interface to use your computer keyboard as an input source to the µGFX application.
Other benefits of the new driver are that OS X users don't have to use XQuartz anymore to run µGFX application on their machines.
The following video compares the rendering speed of the old X driver to the new SDL driver. Note that the video has been recorded with only 15 frames per seconds. It's actually even smoother in real life. Also, no vertical synchronization, double buffering or similar techniques have been used to improve the quality (hence the horrible tearing effects at the end).
A patch addressing a potential crash in the GDISP module when GDISP_NEED_TEXT_WORDWRAP is enabled has been pushed to the repository. A big thanks towards @kengineer for bringing this to our attention and providing the corresponding patch.
Running a project like µGFX requires a lot more than just writing C code and a bit of documentation. We need a proper forum, wiki, git repository, domains, web servers and so on. As the project is growing we had to update our infrastructure. Besides moving to a more powerful server, we also made the following changes:
We registered the domain ugfx.io. All services have been permanently moved from *.ugfx.org to *.ugfx.io. Old links are still working as all requests to the old .org domain are being forwarded to the new .io one.
Until now, the official repository was hosted at BitBucket under my private account. However, as the project grows we also have numerous other repositories which are not public but shared between the µGFX developers. In order to move away from the repository being hosted on a private account and in order to simplify repository management inside the µGFX organization we decided to host our own git server. The new server is available at https://git.ugfx.io. The official µGFX repository can be found here: https://git.ugfx.io/ugfx/ugfx.git
The old repository will be closed soon, new pull requests will only be accepted through the new git server. Please ensure that you update your own repositories in case of you are using the µGFX repository as a Git submodule.
We kindly ask the people who have public forks of the old repository hosted at BitBucket to either remove them or make them private.
Almost all web services are now SSL encrypted.
A fix for the GWIN module has been pushed to the repository that prevents a crash: When the function gwinSetStyle() is called with a null-pointer instead of a pointer to a valid widget style the widget is supposed to fall back to the GWIN default style. However, there was a bug that caused a crash/hardfault instead. This bug has been fixed by this commit: https://git.ugfx.io/uGFX/uGFX/commit/0c695b2471c347847e579aa19ada5612341bfc2d