The Anatomy of a Display Module: Software

In our last post, we explored the hardware that makes up a display module using the SIM543 as an example. We quickly discovered that there is far more to display module than a LCD and a touch screen.  In today’s post, we are going to dig into the software and realize just how complex a display module really is. I hope that by the end of this post, you’ll realize just how important it is to leverage existing technologies in your own design rather than starting from scratch.

In “The Anatomy of a Display Module”, we saw that a Serious Integrated HMI Module (SIM) is a complex and modern embedded system that utilizes a real-time processor to interact with its environment and display an HMI. Just like any processor-based product, there is a plethora of software that needs to control the hardware. We are talking about low-level drivers, middleware, libraries and a scheduler or operating system to manage all these capabilities. This doesn’t even include the application code that provides the value-added features on top of those software stacks. Taking just a couple moments to examine the hardware diagram for the SIM543, we can map the software required to run the hardware that we identified in the last post. 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.

SHIPTide screenshot

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 devleoper needs to reframe their minds about the way they engineer their products.

A Serious Tip for the Thoughtful Engineer

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?

Jacob Beningo, Editor in Chief

Written by Jacob Beningo, Editor in Chief on 4/4/18 10:07 AM

Jacob Beningo is an embedded software consultant with over 15 years of experience in microcontroller based real-time embedded systems. Jacob is an avid writer, trainer, consultant and entrepreneur who transforms the complex into simple and understandable concepts that accelerate technological innovation. He has published more than 200 articles on embedded software development techniques, is a sought-after speaker and technical trainer who holds three degrees which include a Masters of Engineering from the University of Michigan.

Follow Us

Share Blog



project acceleration packages100

Would you like to go to production in under 6 months? Do you have limited software development resources? 

Learn More



Whitepaper: The Evolution of Industrial Machine Architectures 

Download Whitepaper