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.

The magazine no longer appears in print, so these articles are quite dated, but some remain relevant for current embedded design.

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.
  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.

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 This Button Must ...
Niall vents some anguish about frustrating and misleading user interfaces. Readers' Comments

(Inter)Facing the User
DEAD 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
  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

Do You Speak Japaneese?
More translation issues and a look at double-byte encodings. 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.
  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.

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.

Control the Source
Source code version control system is vital to allowing teams cooperate.

A Case Load of Tests
Writing code and testing code are often two different disciplines. This piece shows how to create good tests that catch real bugs without antagonizing the people who write the software in the first place. 

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

Murphy's Bookshelf
Niall discusses some fun reads he had over the years. Readers' Comments


[PanelSoft Home ]