Jump to content

Joel Bodenmann

Administrators
  • Posts

    2,620
  • Joined

  • Last visited

  • Days Won

    2

Posts posted by Joel Bodenmann

  1. 8 hours ago, AndyV said:

    Now new question. May be not for this topic. How to do text string controlled by dial? Something like frequency readout. I think there is only one way. This is Label. But label can not be attached to simple variable in memory as dial and toggle to objects. Maybe there is an elegant way to do this?

    That should definitely go into a separate topic :)

  2. The µGFX library is actively maintained.
    There is currently no release date for µGFX v3 as we want to put our best efforts into it. The development repository of v3 is not public hence there's very little publicly visible efforts.

    µGFX v2.9 is known to be stable. While we do not currently add new features to it we are applying patches & hotfixes as they appear.

    We can only recommend using the µGFX library in your commercial product ?
    If it helps: There's an equally named company behind the µGFX library - This is not just a floating piece of software. Also professional support is being handled through this company.

  3. Hello & welcome to the µGFX community!

    Thank you for bringing this to our attention. We'll put it on the ToDo list for checking.
    Could you please leave a short description (and if necessary examples) as to why you think that this is the case? Some screenshots might also be helpful if possible :)

  4. Hello and welcome to the µGFX community.

    Providing pre-built libraries (either static or dynamic) for µGFX is not a very good idea. The library makes heavy use of compile time optimization based on the various configuration options given in the main configuration file and the driver configuration files.
    All those compile-time options influence the code that is being presented to the compiler during the pre-processor stage. Therfore, the binary code produced by the compiler (and eventually also the linker) depend on those options.
    This reason makes it very useless to publish binaries. For certain things such as the GDISP feature set we could just enable everything which would result in a larger binary and call it a day but for many of the other options that's simply not possible because the pre-processor makes changes based on the underlying system, the compiler being used and so on. Furthermore, some options are application specific (eg. GDISP_NEED_MULTITHREAD).

    TL;DR: Publishing pre-built binaries for uGFX is not a good idea because of lots of pre-processor modifications.

  5. The imagebox widget (in the code the GImageObject structure) contains the gImage member.
    I didn't try it but you should be able to just open a file regularly and load it into a gImage object (named gdispImage in older versions of the library) and then assign that to the imagebox widget's gImage member. Afterwards you have to trigger a re-render of the imagebox widget.

    Note that the underlying widget object should always be treated as a blackbox and you should only use the GWIN highlevel API passing GHandle around.
    If you want this functionality I'd recommend that you implement a proper API call for this in the imagebox widget.
    Pull requests are of course welcome ?

     

  6. Hello & welcome to the µGFX comunity!

    The µGFX library has been designed to be completely agnostic. In the 7 years of its existence we never came across a situation (platform, operating system, compiler, architecture, ...) where µGFX didn't run on.
    The library comes with built-in drivers to run on Linux. The "Linux drivers" support X, SDL or direct kernel framebuffer. You can find more information in the documentation (eg. the wiki & API docs).

    There is no existing display driver for the ATSAMA5D36.
    Which driver is the closest to take as a starting point depends on how the display controller works. µGFX supports all possible display driver models (see the driver docs wiki).
    You can find all existing drivers in the /drivers/gdisp directory.

    We're happy to help where we can - The more specific questions you ask the further we'll get.

  7. Hi,

    Currently there's no way to modify the behavior of the default clearing & orientation of the pixmaps.
    The startup color clearing behavior is implicitly implemented by the fact that a pixmap is just regular GDISP driver like any other "real" / "physical" display. The GDISP driver calls gdispInit() as part of the driver initialization - and therefore also when creating a new pixmap.
    The orientation is simply hardcoded.

    You can find the related code here: https://git.ugfx.io/uGFX/uGFX/src/master/src/gdisp/gdisp_pixmap.c#L113

  8. Hello and welcome to the µGFX community!

    Those fonts (and the two UI fonts) have been custom designed by the µGFX developers. The sources of these fonts are not openly available and therefore there won't be any easy solution for you to modify them.

    If you're a commercial customer you can contact us via e-mail to further discuss possible solutions.

  9. Just before we dive too much into this: Can you replicate the same issue with the latest version of the µGFX library?
    The font stuff (especially wrapping and alignment/justification) has been reworked intensively in a release after 2.4 (can't remember, was 2.7 or 2.8 I think - check the changelogs).

    If you integrated µGFX properly into your project you should be able to just replace the library directory.
    If upgrading is for some reason not an option, I'd recommend you to first investigate and re-evaluate why that is not an option and if the situation stays the same you can go through the changelogs and git history to figure out which patches were applied to this and cherry-pick those patches to your copy of µGFX 2.4.

  10. Thank you for your suggestion.

    If you feel like opening an µGFX channel please feel free to do so. We're happy to promote it here and on our website - I'd also join in personally.
    However, we're not going to do / maintain this ourselves. We have done this in the past (eg. the #ugfx channel on freenode) but we mainly stopped doing that as we prefer to invest our time into development.

  11. Hi,

    The font converter engine supports TTF and BDF font files. I think the font converter should reject other files but maybe that's not the case and it can't process at some point. The online font converter definitely checks for the proper file extension.

  12. Make sure that all your DMA stuff is setup properly (i.e that there are no conflicts).
    Keep in mind that the DMA stuff is not part of µGFX - it's part of the application. You need to configure all the DMA components in a way that it works for the entire application.

    You might also find this forum post helpful: 

     

  13. What exactly is "1mg" or "1Mg"?

    If you also need OpAmps you might want to have a look at the "PSoC" series of Cypress. The PSoC 4, 5 and 6 all feature Cortex-M cores. Those devices come with your regular amount of peripherals (SPI, I2C, ...) but also feature programmable analog components such as OpAmps, comparators and so on.

    There's a guide on how to use µGFX with the PSoC creator studio (their IDE) in our wiki.

  14. Hello and welcome to the µGFX community!

    The answer to all your questions is: Yes.

    µGFX has been written to run on virtually any system/platform. The STM32F103 is very well supported. In fact, when I started writing µGFX the initial development took place on an STM32F103RB6T.
    However, while still working great the STM32F103 is "quite an old" chip by now. There have been several revisions on even basic things such as the SPI and I2C peripherals ever since then (and they provided huge improvements). If you could better state your requirements (especially in terms of memory & CPU resources) we might be able to recommend a "better" chip to you.
    But keep in mind that this would just be optimizing: µGFX will definitely run just well within the environment that you described.

    µGFX also allows you to compile your resources (eg. images) directly as part of the application itself using GFILE's ROMFS so you don't have to fiddle around with linker scripts.

×
×
  • Create New...