Doing so reveals a non-trivial table of the software stacks required to build a display module:

 MCU, Flash, RAM
  • RTOS
  • Serial NOR Flash driver, partition manager & block mode driver abstraction
  • e.MMC Flash Peripheral driver, partition manager & block mode driver abstraction
  • File system
  • Transactional SPI Peripheral driver and abstraction (for Serial  NOR)
  • SDRAM driver and chip initialization
  • Timer driver
  • Power mode driver and manager
  • Watchdog driver
  • Video controller driver
  • Hardware accelerator driver
  • Graphics primitives libraries
  • I2C driver
  • Touchscreen controller driver
  • Touchscreen application stack
  • GPIO driver
  • Interrupt controller driver
  • GPIO driver
  • PWM driver
 Embedded Peripherals
  • GPIO peripheral drivers and abstraction stack
  • ADC peripheral drivers and abstraction stack
  • UART peripheral drivers, packet serializers/deserializers, abstraction stack
  • PWM peripheral drivers
  • DMA peripheral drivers and arbitration stack
  • USB Host/Device peripheral drivers, stacks, class drivers, event frameworks
  • SPI peripheral drivers & abstraction layer
  • I2C peripheral drivers & abstraction layer
 Ambient light sensor
  • ADC driver & abstraction layer
  • Timer driver & abstraction layer 
Security and encryption engines
  • Cryptographic driver
  • Cryptographic libraries (AES, SHA-256,  etc.)
Board to Board Communication
  • RTOS
  • USB peripheral drivers, abstraction stacks, and classes
  • Memory manager
  • UART drivers
  • Ethernet peripheral drivers and abstraction stacks
  • Protocol stacks (USB, TCP/IP, TLS/SSL, MQTT)
  • Interrupt control

The above list is just a base list of all the software that is required to get a display module up and running and performing its basic functions. This doesn’t even include the software necessary to run the actual GUI and move the files and data to interact and controls the outside world. On top of this is higher-level software to manage and coordinate events, error conditions, and GUI assets such as fonts, images, and multi-language text. And further, bootloaders, upgrader systems, and various abstraction layers are wise to ensure your system is maintainable and somewhat portable to future hardware! Look at that base list again carefully. There are several components and software stacks on that list that are not trivial either. Can you imagine how much time it would take to develop each software stack for production if you started from scratch?

Starting a development effort of this magnitude would cost a small fortune if a team were to start from scratch or even use the “example” code from a silicon vendor. There are many silicon vendors who advertise “free libraries” and “free GUI tools” to supposedly make it “easy” to develop within their ecosystem. However, as you can clearly see so far, a free library or tool is only one piece of a much larger puzzle. The silicon vendor may save you some time in writing the GUI library but what use is it if you still have to architect, integrate and write tens of thousands of lines of code to use the “free” library? So, what can developers do to get to market quickly and not spend a fortune developing software? Teams can learn from Serious Integrated’s success by leveraging existing technologies and software stacks and then building their value-added capabilities on top of that foundation.

Every Serious Integrated HMI Module (SIM), under the hood, runs fully licensed, commercially robust software stacks including an RTOS, encryption libraries, USB and network connectivity stacks among many other software components. Serious leverages those existing and robust capabilities to jump start development and then built the HMI infrastructure components and capabilities that their clients needed on top of that foundation.

On top of all this commercial RTOS and stack software as well as the Serious HMI infrastructure, developers using a SIM can use the high-level SHIPTide software to quickly and easily develop their own HMI’s. They don’t need to understand what’s happening behind the scenes but instead can focus on the look and feel and the environmental interactions that are necessary for their application starting on day 1. This dramatically decreases development time and cost for applications that require a display and need to interact with their environment and communicate with the cloud. SHIPTide, along with the Serious Human Interface™ Platform (SHIP) firmware pre-installed on the modules, is much (much) more than a graphic library or a GUI development tool – it is everything you need to develop and deploy complete HMI applications without embedded software or hardware development at all.

If SHIP and SHIPTide sounds intriguing, you may want to check-out the getting started video that shows how to create and deploy a simple GUI in 60 seconds which can be found in the Training Videos section. In our next post, we’ll start exploring how the modern embedded software devleoperneeds to reframe their minds about the way they engineer their products.


As we have seen in today’s post, there is a lot of software that is used to get a display module up and running. Creating all this software from scratch would take considerable time and money and allow a competitor that leveraged existing technologies to gain the advantage. To compete in today’s fast-paced and competitive market, can you leverage an existing display module like the SIM543 to accelerate your development cycle and beat the competition to market? What steps do you need to take to make sure you don’t waste time recreating the wheel?