Introductory help with the Toradex platform


I’ve been prototyping an embedded device with a Raspberry Pi, using Qt5.x on a stripped down version of Raspbian Linux. I’m starting to run into OpenGL issues, which have me thinking that a more industrial platform such as Toradex will be better suited for my application.

I have a couple of questions if you don’t mind:

  1. I’ve done a cursory search, but can’t seem to find a definitive comparison between the Apalis and Colibri platforms. The Colibri T30 looks to be a good module for my application, but that isn’t based on a thorough understanding of the products.
  2. My current software is written in Python using PyQt5 for the Qt binding. Has this been done on a Toradex module, or do almost all Qt-based developers opt for c++?
  3. Is interfacing with GPIO, I2C, UART, PWM, etc. as simple as one would expect?
  4. Is the ‘quick boot’ Embedded Linux image available from Toradex, or is comprehensive modification required to get the <2 boot-into-application capability?

As some additional information, I’m currently considering the Viola Plus carrier board with the Colibri T30. I would likely compile Qt and PyQt5 initially to see what sort of Python-based Qt performance I can achieve, before looking at re-developing in c++ if the performance isn’t adequate.

EDIT: Just realised the Viola board doesn’t have a VGA/DVI/HDMI output, so I guess I’ll be using the Iris or Aster board.


  1. It is possible to run Qt5 application on Colibri T30. However, it has some limitations, e.g. it requires the X-Server to run Qt5 applications. A Colibri iMX6 allows to use EGLFS which is helpful especially with #4 in mind. Also the Qt Company offers pre-built Boot2Qt images for Colibri iMX6 in case you decide to use their offerings.
  2. Internally we did not try PyQt5 on our modules so far. There is a OpenEmbedded recipe for Python bindings for Qt5, so I would expect it should be doable with a reasonable amount of expertise/effort.
  3. This depends on your expectation/definition of simple… There are standard Linux interface for all those interfaces which we support (GPIO through sysfs, I2C through the /dev/ device, UART through /dev/tty* devices, PWM through sysfs).
  4. We do not have a a quick boot image available. Yes, there are comprehensive modification required to get under 2 seconds. I guess you refer to the Cluster Fast Boot Demo with Linux and Qt. This has been done together with the Qt Company. It required stripping down the image to a bare minimum (including Kernel and Bootloader). In this demo we used the commercial Qt framework which allows static linking and allows to precompile the Qt Quick UI. You can find a video talking about details what modifications have been necessary here.

Thank you very much stefan, you’ve provided all I was looking for and considerably more!

  1. EGLFS is a must, so I will instead focus on the iMX6 modules. I will also investigate Qt’s Boot2Qt image, as I’d rather leverage their/your expertise on the image itself and focus on the application.
  2. I’ve built many PyQt/PySide-based desktop applications without issue, but am running into performance issues on this embedded application, so don’t know if I want to continue struggling with Python in this instance. I preemptively downloaded Qt yesterday, and have replicated the basic application GUI and structure using QtQuick QML, so I may in fact rebuild the application with QML and c++.
  3. I haven’t used those interfaces before, but they look relatively straight forward from a quick search.
  4. That was indeed the example to which I was referring. At this stage I plan on using the commercial Qt license, so static linking won’t be an issue. I’ve never messed with the kernel or bootloader before, but I will certainly give it a go.

Thanks again!

One additional question, would the Colibri iMX6 DualLite 512MB be capable of the linked automotive instrument cluster application? I note that that particular demo was using an Apalis module, so I’m wondering whether a dual core, 512MB module would be capable.

The Apalis family uses the i.MX6 Dual/Quad which do offer a faster GPU (Vivante GC880 vs GC2000), more L2 cache (512kB vs 1MB) and more CPU cores (the Quad variant). So there is definitely more performance available on the Apalis platform.

We did not run this demo on a Colibri iMX6 DualLite, but I would expect that it works similar well. The demo is not particular demanding since it is very optimized. So my guess would be that you wouldn’t notice much other than maybe a little penalty in boot time.

Note also that with both families, if your application is putting high loads on CPU/GPU a cooling solution might be necessary (heatsink).

Brilliant, thanks again stefan, I may well buy the DualLite with suitable carrier for testing when my application is suitably developed.