In our modern world we've come to expect everything to be instant and immediate – our food, our entertainment, our communications; you name it and we want it, right now. But until recently, developing a new electronics product has been anything but instant. In fact the growing complexity born from more sophisticated electronic devices, combined with the need to support more inter-connected and sophisticated communications systems, have actually stretched the development cycle.
All this has meant more grey hair and a faster receding hairline for the designers of electronic products, as they push themselves to deliver that latest feature-rich product in record time. And the actual result? More often than not the new model is just like the old model – except with more memory, a new case, and some new jazzy icons.
Why is it so hard to bring those great, original ideas to life? Try as we might there never seems to be enough time, because we're dragged down by our antiquated and over-bearing approach to development.
With the traditional approach to product development firmly ingrained in my engineer blood – specify and create the hardware platform ASAP so we've got something to start developing the software on – I was definitely ready to open my eyes and my mind to an alternate approach. I really didn't want to go grey and loose my hair before my father!
Enter what seemed to me to be an upside-down and back-to-front product development model from Altium. The concepts are:
Explore your ideas first, lock in the solutions later
Focus on the idea, not the hardware
Take a holistic product development, where the idea remains as your central focus
But I'm an engineer, and we're a cautious bunch of optimists. While we love new ideas, we really need to be convinced before buying in.
How many pieces in this puzzle?
There are multiple challenges that must be solved to successfully deliver such a bold design solution. None of them are trivial challenges either, and to top it off, all of the pieces in the puzzle must mesh together for this new solution to really work.
As designers of electronic products know:
- You can't develop in thin air. You need a development platform to build, implement and test the application on.
- Introducing new technologies, such as new communications technologies or new hardware technologies like FPGAs, is difficult, requiring a huge investment in learning the technology and design tools.
- The real development roadblocks are more often at the domain interfaces, rather than within any design domain.
So to deliver on the promise of a new, holistic approach to product development, the Altium model must:
- Support the rapid development of the application and let me utilize new technologies in a high-level way, without requiring me to climb numerous steep and high learning curves (I'd like to save being an FPGA guru and learning the nuts and bolts of the I2S protocol for some other time).
- Cover the entire development process, not just design capture, and include implementation, testing and debugging.
- Allow me to move seamlessly between the various design implementation modalities. I want to easily explore my ideas and experiment with how they are implemented, but not have to sweat over passing pin allocation files between an FPGA project and a PCB design.
A tall order for sure. So let's see how it copes on my test project; a digital audio effects unit.
An audio reverb unit
It makes sense to start with a simple test project, so I've decided to develop relatively simple digital reverb unit. It's not something to commercialize in itself, but elements of it will be useful for a project that's in the pipeline.
A rough sketch of the reverb unit
The idea behind the effects unit is to feed incoming audio signal into an ADC, read the captured data in using a processor, store and delay it, add the delayed signal back to the original signal, then feed it out to a DAC and onto an audio amplifier/speaker.
Simple enough really, but underlying it was a bunch of low level development detail that I was not looking forward to – like getting my head around I2S to communicate to the ADC and DAC, learning SPI to configure the audio codec, configuring a processor inside an FPGA. And how was I going to control this reverb unit from my PC???
The implementation platform
Soft, or programmable hardware is immensely appealing to every engineer. The idea that you can go; "whoops I didn't get that quite right. Oh well, I'll update and reprogram" is so attractive to every hardware engineer that's felt that sinking feeling in their stomach when they find the first problem in their carefully designed hardware. But soft hardware is a new ball game for me, so I'm creating my first FPGA project with some trepidation.
I'm using the Altium NanoBoard as the development platform, since it has all off the hardware I need for this design. The core of the system is going to be soft hardware – that is, chunks of logic inside the FPGA on the NanoBoard, including the processor and all of the control hardware needed to interface to the external audio signals, via the ADC and DAC.
The Altium Wiki refers to using OpenBus to capture your system core, and this seems a good approach. A simple diagram with eight elements on it, with each connected by a single line, and I has almost everything I needed – the processor, the memory interface, and the audio interface.
OpenBus allows you to capture a complex processor-based system easily and quickly (click for larger view)
A top level schematic sheet was all that was left to complete my hardware. This tied the audio and ADC/DAC hardware on the NanoBoard into the core system inside the FPGA.
The top level schematic interfaces the FPGA-based system to the external hardware (click for larger view)
A new platform for embedded application development
Embedded software development has not moved forward like PC-based application development. The embedded development tools have, necessarily, focused on criteria such as system performance and memory usage. Delivering this has required compact and efficient code that is tightly coupled to the hardware, usually resulting in code that is highly system-specific, difficult to analyze and maintain, and not portable.
While this was appropriate in times of expensive and slow silicon, those conditions are no longer the barriers they once were.
But as convoluted and complex as PC hardware is, there are well understood abstraction layers that make high-level application development feasible and effective, without the developer needing to know about or manage low-level detail like configuring and interfacing to peripheral hardware.
The Altium Wiki shows that Altium is delivering a high-level software development system for embedded software, called the Software Platform Builder, which looks very slick. To make use of it just added a SwPlatform document to my embedded project and clicked the Import button. This created a set of peripheral hardware wrappers directly from the FPGA hardware design.
Delivering an elegant and deceptively simple solution to a perennial problem, the software
platform builder brings rapid application development to the embeddedsoftware domain (click for larger view)
Then selecting each hardware wrapper in turn and clicking on the Grow Stack Up button, I soon had the software drivers and services for each of the peripherals in my design – as easy as that! This is a very effective system for managing detail such as base addresses, bus widths, interrupts, and peripheral configuration and interfacing. It's not smoke and mirrors either. It simply hooks in real code files into my project, and lets me deal with configuration detail through simple dialogs.
Peripherals are configured through dialogs, rather than directly in the code (click for larger view)
Low-level detail like this usually consumes a substantial amount of the code development time, so to say I was pleased at how easily and quickly it had happened was an understatement. I could now focus on the coding that was important to me – managing and manipulating the audio data.
The other thing that caught my eye in the Wiki was ‘C to hardware'. This is about pushing software routines into FPGA hardware, which offers offering dramatic performance improvements. I'm definitely going to explore those concepts.
Now for some real fun; LiveDesign
You're never short of concepts and functions in the Altium space. The next Wiki information I came across was about ‘LiveDesign', which is a way you can interact directly with your working design, right inside the FPGA.
LiveDesign allowed me to use FPGA-embedded test instruments to stimulate and monitor the hardware – even using a full-bore logic analyzer. And because I can run my embedded code in debug mode and examine memory and registers at will, debugging should proceed smoothly.
Just two days into this small project I had close to a fully working design. I was starting to understand the depth and sophistication of Altium's approach to electronic product development.
Are we there yet?
Most engineers, regardless of the discipline they work ion, know that the good old days of holding an engineering position because of acquired knowledge are coming to an end.
New devices, new communications technologies, new expectations and a stream of new players in the product development game are changing the electronics design landscape. It means that today, your real value comes from your ability to innovate and create, and to really stand out you need to be the one who actually succeeds in bringing their ideas to life.
Just how do you do that? How do you be the one who succeeds in bringing their ideas to life? Taking a moment to consider the development process I'd just experienced, I was starting to see how I could do it. If I wanted to stay in the game I needed to stay ahead of the pack, and this comprehensive development system, this holistic and novel approach to development, was offering me that. Not only could I quickly evaluate my ideas and how they could be implemented, but I also had all the tools I needed to take those ideas right through to custom board design, and on to production.
And one last thing; it seems that the domain boundaries I was talking about earlier have been thought of too.
In the Altium solution, right out of the box, you can:
- Move between the embedded code and the FPGA processor + hardware
- Transfer design detail between the FPGA design and the PCB design
- Bring the enclosure into the PCB design to check for fit
- Pass the loaded PCB out to mechanical CAD
- Get the PCB design into production
All of these are all foundation capabilities in the Altium solution, not high-cost optional extras.
Got 10 minutes to see it for yourself?
If you'd like to see the audio reverb design being created from scratch, then watch the video here.
