Skip navigation

Go Graphical in Your Product's Design Cycle

Ever-increasing numbers of technologies are converging into the simplest of devices, technologies that expand these devices beyond their main function. A good example is Apple’s iPhone, which combines the functionality of multiple devices into a single compact unit.

The iPhone’s flexible user interface changes based on the function, whether it involves making a phone call or listening to music. Here, we can clearly see the underlying technology that makes this possible—software, and how it integrates with hardware.

By employing a technique known as graphical system design, engineers and scientists developing electronic systems can be more involved throughout the development cycle from design, through prototyping and verification, to final deployment and functional test. Graphical system design integrates software developed in a flexible graphical development environment, a target computing engine, either real-time or based on a general-purpose operating system, and mandatory associated I/O and communications.

Let’s take a step back and look at some elements of software design that are limiting factors, especially for embedded systems. A large proportion of people developing embedded systems don’t specialise in writing code for embedded systems; they are domain experts in their own field. For example, a machine builder developing a system to improve retinal disease treatment would have detailed knowledge of ophthalmology, but not how to write embedded C code. However, for those individuals who are experts at integrating embedded systems, some elements of development remain non-trivial. For instance, writing driver-level code to interface with I/O points, managing threads of execution, timing, synchronisation, and resource scheduling all take up a large amount of project time. Lest we not forget the explosion of multicore processors onto the marketplace.

A method to abstract the complexity of programming embedded systems, both in single processor and multicore designs, is to choose a software-tool flow based on a graphical approach. The advantage of this methodology is that many graphical-based tools, such as National Instruments’ LabVIEW graphical development environment, include native functionality to handle complex programming and timing.

Therefore, rather than deal with low-level details, the embedded developer can focus on the critical pieces of code, such as the intellectual property (IP) of the application itself. This ultimately differentiates it from other embedded designs.

Various high-level views within NI LabView help design the IP. For example, an engineer could describe control tasks using a model-based view, digital-signalprocessing tasks using data flow, and mathematical formulae textually. NI LabVIEW accommodates these different views by including text-based math, continuous time simulation, state diagrams, and graphical dataflow models all within the same development environment.

Dr. Edward Lee, a leading researcher for embedded software platforms at the University of California at Berkeley, refers to these various design views as models of computation. Such models match the way system designers view their system and, thus, help minimise the complexity of translating system requirements into a software design.

From early on in a project, seamless integration with realworld signals is extremely important. Initially, it may involve taking measurements from a target system that’s to be controlled and feeding the time-domain signals into a software simulation containing in-work versions of mathematical algorithms.

Moving forward, easier integration of the developing software into the real-world to quickly test out “what if” scenarios will reduce time spent in these early development stages. On top of that, it will identify problems earlier in the design flow, saving on what would be costly corrections later in the cycle.

As modules of the software become complete, it’s possible to move into a rapid-control-prototyping (RCP) phase, with certain provisions. Prerequisites for RCP include the productive graphical development environment that we’ve been discussing, along with commercial-off-the-shelf (COTS) processors and I/O modules.

An example of such a system is National Instruments’ CompactRIO (Fig. 1), a low-cost reconfigurable control and acquisition system designed for applications that require high performance and reliability. The system combines an open embedded architecture with small size, extreme ruggedness, and hotswappable industrial I/O modules. NI CompactRIO is powered by reconfigurable I/O (RIO) FPGA technology.

Using such a prototyping phase, custom hardware isn’t needed until later in the design cycle. This gives software developers more licence to make design changes that directly effect hardware requirements.

Continued on Page 2

For low-volume applications, when it comes to deploying the system to the target hardware, it may make commercial sense to use the COTS hardware prototyping platform. This eliminates the need to spend large amounts of time designing, building, and debugging a custom PCB.

If a custom, higher-volume, lowcost deployment is required, then the IP generated in the graphical development environment can be deployed onto a custom microprocessor. In the case of NI LabVIEW, utilising the LabVIEW Embedded Development Module (Fig. 2) allows the IP created in the graphical programming environment to be automatically translated into target-specific embedded C code.

We can now see some of the key advantages that graphical system design brings to the development cycle. The domain expert for the application area, who’s been working heavily on design in software, and prototyping on COTS hardware, can now take a step back as an embedded design expert completes the integration to the target-specific hardware.

Once this stage is complete, the domain expert can return to their same graphical code to make tweaks and changes to the functionality of the software, automatically regenerating the C code as changes are made.

The technique of graphical system design is a new concept only in terms of its name. Engineers and scientists have been taking advantage of productive graphical programming for over 20 years, citing increases in productivity of 10 times.

With the ever-increasing range of computing targets and industrial I/O modules, graphical system design pushes into more and more application areas. From circuit design, electronic system design, and control design to the functional test systems for these devices or systems, gains can be made by improving the integration between the different phases of the design cycle.

Hide comments


  • Allowed HTML tags: <em> <strong> <blockquote> <br> <p>

Plain text

  • No HTML tags allowed.
  • Web page addresses and e-mail addresses turn into links automatically.
  • Lines and paragraphs break automatically.