There are few electronic products or devices on the market that haven’t succeeded because of an inspired idea. That core idea is the unique creative spark that ultimately sets a device apart from the others, or in some cases, even defines a whole new genre of products.
Products, of course, can define themselves as unique in the market for a range of other valid reasons, including low cost, being first to market or by offering better performance. But that perceived uniqueness is quickly lost as competing designs catch up. A widget that’s only incrementally better, for whatever advantage it offers, will soon be bypassed by one that’s incremented a little further.
The trick is developing the unique widget idea and concept in the first place, and just as importantly, turning it into a functional device that offers a desirable experience for the user. For that to part happen, we need to stand in the users' shoes, and explore how a new widget will interact and function from their perspective.
Really, we need to prototype ideas, before heading down the path of prototyping a product.
Nail the idea
So, you have a great idea. Your creative electronics design brain has come up with a concept that will potentially redefine a market sector by solving the limitations of existing products and how they can be used.
As a design engineer you, or perhaps your team, have the hard-earned skills to take that idea through to reality, so the normal process is to begin developing the hardware and software (usually, in that order) to support the concept, as defined in a design specification. But in doing so, you’ve already started down the path of creating a hardware prototype before the idea has been fleshed out from a user’s standpoint.
To really explore and develop how a user will experience your new concept, the first step is to pull back from your naturally tight focus on the engineering details of a design.
So, hold off on considering what processor, peripheral devices and software routines you figure will be needed for the right functional result. Instead, zoom out to the broad focus of the user experience by prototyping it, where you can explore options, allow others to give feed back, and see how it interacts with the outside world. You need to see if the idea will fly.
Mechanisms for empathy
Let’s say the device you’ve conceived has a typical range of I/O peripherals that connect with the user and external systems. There might be an LCD screen (possibly a touch screen), a bunch of controls and buttons, several indicator LEDs and some I/O connections.
To test and explore how these I/O devices will translate your idea to a user, you need to create the basic level of functional intelligence that drives them. At this point the normal path would be to create the software and hardware required to make that happen, then continuously tune and change that structure as different user interface behaviors are explored and developed.
Very soon though, you’re back at the detailed design level of hardware logic, peripheral drivers and software routines. The broad, high-level focus on the user experience is lost and you’re again trundling down the path to a product prototype, but without a properly explored idea.
In part, FPGAs come to the rescue here. By absolving the need to create new physical hardware with every significant design iteration, FPGAs offer a potential way to explore design options and alternatives more easily. Simply change the embedded hardware design, and then load the revised version into the FPGA, in true burn and learn style. Nevertheless, revising the design using conventional HDL capture methods takes you back to the idea-killing detail of an arcane coding environment.
 |
|
| FPGA-hosted Digital I/O instrument |
But there’s another way. A previously untapped methodology for this type of exploratory design is using FPGA-embedded virtual test instruments, such as a multi bit-width I/O instrument block, which can be driven by a high-level scripting language (such as DelphiScript). These blocks of clever IP offer a potential way to create, control and refine a design’s user interaction using a simple and fast approach.
Smart instruments
Based on preconfigured hardware-software IP blocks, virtual instruments allow you to both actively monitor and control the internals of an FPGA design, while it’s running. A user-created script can take charge of the instrument, allowing a level of ‘intelligence’ to take command of any I/O signals it has been connected to in the design.
 |
|
| NanoBoard 3000 – smart, connected, versatile |
At this basic level, an embedded I/O instrument can easily be configured and scripted to sense switches, toggle LEDs, activate I/O ports, and so on. Where it gets really practical is when the idea is applied to a smart FPGA-based hardware development platform that includes a wide range of useful peripherals, plus the ability to change and expand those peripherals.
If such a hardware development system can also communicate with the PC-based design software at a high-level over a USB-based JTAG link, and the software includes ready-to-go IP for the board’s peripherals it gets even more interesting. Using a high-level, schematic or icon-based design capture system, FPGA-based IP blocks and instrument controllers can then be wired together to quickly create an entire functional I/O system, ultimately controlled by simple but powerful scripts.
One valuable addition to this approach is a ‘custom’ virtual instrument that offers a blank canvas for creating a comprehensive graphical interface, which apperas as a dashboard on the PC. By dragging and configuring user interface objects such as numerical readouts, slider controls, buttons and labeling from a palette of options, a custom GUI panel can be created in moments. And each element on that panel can be assigned an I/O signal and behavior under control of an internal script.
 |
|
| A fast, easy way to explore ideas |
Pulling this entire system together, if you so choose, is a development board scripting interface where you can create a ‘master’ script to take further control over the process. This allows you to connect the functions of key embedded instruments to create a more sophisticated interface system – while still using relatively simple, easy to debug scripts.
And here’s the important bit, if it’s not obvious already. With this approach to testing and exploring concepts and ideas, no detailed design is necessary. No low-level hardware is developed, no detailed software code is written, but a functional system with a design’s representative intelligence now exists – as does your idea from a user’s perspective.
Explore ideas without distraction
The end result is that ideas, and how a user will experience those, can be tested, explored and debugged within a very short time frame. The software component of the basic idea is represented by the intelligence embodied in the scripts you write, and the peripheral hardware that responds to that functional intelligence is created by connecting a few IP blocks together with a high level design capture system.
The really important advantage here is that the distraction of detailed design is removed from the equation. Ideas can flourish, user interaction and the experience can be tested, and alternative concepts can be explored – potentially within minutes, and on real hardware.
What you are actually creating when designing an electronic product is, in the end, a user experience. It’s critical for the success of that product that the ideas you develop as a designer properly translate to the user experience, and here’s a way to get that right before diving into detailed, low-level design.
When detailed design does happen, the direction is clear and much of the conceptual and hardware framework is already in place. And that can also be done in a high-level, rapid way – but that’s another story.
