User Interfaces and Usability for Embedded Systems

Niall Murphy's Articles

Niall Murphy is a contributing editor at Embedded Systems Programming magazine. Many of the pieces below appeared as part of his Murphy's Law column, while others were feature articles. Feel free to e-mail nmurphy@panelsoft.com any comments you have on these pieces.

Usability Designing User Interfaces: What Does the Customer Really Want?
This article discusses usability issues in the design of embedded products, and also addresses the engineers role in the process of making a product usable.
  Understanding Usability Standards for Medical Devices
Regulatory bodies look for evidence that the development of medical devices followed a usability program. This article discusses that standards that can be used to show that you are following good practice.

Safe Systems Through Better User Interfaces
This article discussed the tradeoffs between safety and usability when designing the interactions between user and machine.

  Principles Of User Interface Design
Usability improvement can be achieved by constant reviewing and tweaking of a design, but this articles describes principles you can chose to apply right from the first incarnation of your design.
  Usability for Graphical User Interfaces
Adding a Graphical User Interface to your product will allow you to add a lot of functionality, but it also raises usability issues.

It's Worse on a Browser
User interfaces are always less usable when they're served up via HTTP. But there are ways of improving the user's experience. Readers' Comments.

So that button must ...
Niall vents some anguish about frustrating and misleading user interfaces. Readers' Comments

Interfacing the User
This column looks at factors in the mindset of the engineer that make them less suitable as user interface designers. If you are aware of these issues, it is easy to avoid the common pitfalls. Readers' Comments
Looking Good - A Lesson in Layout
Programmers need to learn a few graphic design principles to make the best of their GUI. Readers' Comments
The Usability Dilemma
Another attack on the engineering mindset and why you have to think different when it comes to usability. Readers' Comments
The text our applications display to the user has a huge impact on usability, and so deserves close scrutiny during development. Readers' Comments
Modes and the User Interface
Software engineers should not fall into the trap of assuming the general population is as comfortable with modes as the typical engineer. Readers' Comments
To Err is Human
Handling user errors is a tricky business. In this piece we look at how to let the user off the hook, and how to design good error responses. Readers' Comments
  The Secret of Good Timing
Timing responses to the user can be the difference between a good user experience and a great one. The speed of response, the feedback during a delay, and the timing of changing elements such as flashing lights go under the microscope here.
  Put the User in the Driver's Seat
Designing user interfaces means striking a tricky balance between being helpful, being too helpful, or getting in the way. Here are some examples to guide you through these treacherous waters. Readers' Comments

User Interface Programming

Parlez Vous Franšias?
Examine translation issues, dealing with translation houses, managing code files and translation files. Readers' Comments

More translation issues and a look at double-byte encodings. Readers' Comments

  User Interface Prototypes
Niall uses Borland C++ Builder to implement PC based prototypes of user interfaces. Readers' Comments
  More Prototyping Tips
A continuation of last months piece where we look at some more examples built with Borland C++ Builder and we discuss graphics prototypes.
Graphics Programming

Embedded Graphics Part 1: Bitmaps and Fonts
This article discussed the use of graphics in embedded systems, and in particular methods for converting bitmaps and fonts from a PC to a form suitable for compiling into an embedded system. The companion page for this article contains downloadable code and executables.

  Embedded Graphics Part 2: Objects and Refreshing the Display
This article discusses structures that can be used to control objects on the display to allow interactive interfaces to be built. Different refresh policies are examined, which provide varying amounts of control over the objects on the display.
Color by Numbers
Embedded GUIs are growing more elaborate day by day. Developers now have to contend with such arcana as a color palette. We also look at the Palm Pilot and discuss anti-aliasing. Readers' Comments and further comment from Niall
  Light and Magic
This month we look at how we can take advantage of diasplays with a large color range to produce shading effects for buttons and widgets.

GUI Add-On Options
Discussion of the Amulet serial GUI and the Segger graphics library.

Dealing with touch sensitive areas of graphical objects
This piece explores various algorithms for establishing the exact point of intended touch on an GUI and whether those touches should be applied to an object at or near that location.
Robust Programming Safe Memory Utilisation
The general purpose allocation mechanism, malloc(), can suffer from fragmentation, regardless of how carefully it is used. Also, a general purpose allocation scheme usually has undeterministic real-time properties as it may have to perform a search for memory of the appropriate size. This paper examines how to manage memory and looks at some alternatives that eliminate fragmentation and searches, such as fixed size pools.
  Beginner's Corner: Watchdog Timers
An introduction to watchdog timers. Niall Murphy co-authored this piece with Michael Barr.

Watchdog Timers
More advanced use of a watchdog timer as a safety check to make sure your software has not hung. The second half of this article deals with RTOS integration.

Lock Up Your Software
Interlocks providing mechanical limitations on software. The key to preventing software catastrophe is outthinking an imaginary malicious programmer.


Lock Up Your Software Part 2
Further discussion of interlocks and dead man controls. We also look at how the user interacts with such protection mechanisms. Readers' Comments

Assertiveness Training for Programmers
I look at when and why to use the assert() macro. Readers' Comments and Errata
Assert Yourself
More discussion of the assert() macro, with a look at how to define it in a style suitable for embedded systems.
Forget Me Not
If using EEPROM or NVRAM, you need to take precautions such as checksums and double-buffering if you want to detect or fix corrupt data. Readers Comments
A Version Therapy
A follow-on from last month. If you upgrade your software, but you want your persistent storage to remain valid then you need to plan for it in advance. Readers' Comments
  Flushing Out Memory Leaks
First of two parts on memory leaks. This month discusses the challenges of measuring usage and leaks, and the shortcomings of the tools available.
More on Memory Leaks
This month we look at some extra code that can be added to malloc() and free() to let you know if memory is being wasted. Readers' Comments

Start Me Up
Curious bugs can creep in if you do not give sufficient attention to the initialisation of variables. Readers' Comments and Errata

We all learn from our mistakes, but it's less painful to learn from the mistakes of others. This list of bugs shows some dangers that lurk within subtlties of the compiler.
Development Process What have the Romans Ever Done for Us?
Niall muses about the real advantages of objects, and some of the hidden drawbacks. Readers Comments

A Question of Quality
Can quality be generalized across multiple industries? ISO 9000 and its promoters claim it can. Here's a look at the ubiquitous standard. Readers' Comments

ISO 9000 Backlash
Since the last ISO article generated so much reader feedback, I decided that it was worth another look. Readers' Comments

Training for the Long Run
A discussion of the pains and gains of technical training in the embedded world.

Technologies A Short Message about Short Messaging
Mobile phone text messaging opens some interesting doors for the embedded designer, and when it moves to fixed lines it will open even more.
CAN We Talk?
A look at SPI and CAN as design options for getting your processors talking to each other.

Is Linux Worth the Effort?
A look at the ups and downs of embedded Linux.
Readers' Comments and further comment from Niall

A Short Trip on the CAN Bus
A look at the hardware robustness of CAN and a discussion of how to program it. Readers' Comment
  An Uncertain Future
A look at how to protect your design from reverse engineering, and a discussion of the viruses and hacks that may threaten embedded systems in the future. Readers' Comments
Miscellaneous Right Brained Programming
In this piece I discuss a few examples of lateral thinking when it comes to challanging design issues in embedded software design.
Murphy's Bookshelf
Niall discusses some fun reads he had over the years. Readers' Comments


[PanelSoft Home | Training Courses ]