14
$\begingroup$

When developing products I do all of my algorithm design in Matlab. They are usually pretty basic, an IIR or FIR filter or two, a couple FFTs, etc. When it comes time to move it to an embedded environment I always have a hard time deciding what platform to run it on. I usually think of these (broad) platforms:

  • DSP core
  • FPGA
  • Microcontroller
  • ARM

What factors should I consider when trying to make this decision?

$\endgroup$
  • 2
    $\begingroup$ Why do you distinguish "ARM" from "Microcontroller"? Trying to categorize TI's DSP+ARM parts? Are you trying to separate low-power small stuff from bigger microprocessors? (In this last case, you should probably include MIPS and vendor-specific 32-bit cores) $\endgroup$ – Kevin Vermeer Aug 16 '11 at 20:22
  • $\begingroup$ When I think of Microcontroller I think of PIC, Atmel, etc but I suppose ARM can fall under that as well. I was not trying to say those were all of the options, just asking what factors should be considered. $\endgroup$ – Kellenjb Aug 16 '11 at 20:30
  • 1
    $\begingroup$ What do you determine "best"? Are you limited by power? Cost? Ease of programming? Flexibility? $\endgroup$ – Oliver Charlesworth Aug 16 '11 at 20:31
  • $\begingroup$ @Oli That is the whole question, what factors should be considered when trying to decided. $\endgroup$ – Kellenjb Aug 16 '11 at 20:32
  • 3
    $\begingroup$ @Kellen: At the moment, this question is a bit like "How to decide what car is best?", with no further constraints. $\endgroup$ – Oliver Charlesworth Aug 16 '11 at 20:34
13
$\begingroup$

If you are keeping to "standard algorithms" like IIR, FIR, radix-2 or 4 FFT (ie stuff that fits DSP architectures well without much control flow), you can try this:

Count up how many "multiply accumulates" you need per second in all your algorithms.

  • < 10 million you can probably get a fast microcontroller to do the job (or even a slow one if you are <1M)
  • < 100M is easy DSP territory
  • < 1G is likely to be doable fast DSP territory
  • 1G-10G is where the cross-over between DSP and FPGA comes
  • > 10G is multiple DSPs or FPGA
$\endgroup$
  • 2
    $\begingroup$ This is actually a very nice list for reference! $\endgroup$ – Kellenjb Aug 17 '11 at 11:57
  • 3
    $\begingroup$ Just remember to multiply by 10x every couple of years or so :) $\endgroup$ – Martin Thompson Aug 17 '11 at 20:08
  • $\begingroup$ Can you give an example of a "fast microcontroller"? $\endgroup$ – endolith Apr 1 '14 at 16:12
  • 1
    $\begingroup$ @endolith: not with any likelihood of it being current next time we look :) In early 2014, maybe something like the LPC1768 (which clocks at 100MHz - pushing it a bit for 10MMACS I guess) $\endgroup$ – Martin Thompson Apr 1 '14 at 20:27
  • $\begingroup$ @MartinThompson: DSP library for LPC1700 says the Cortex-M3 does "2-cycle (32x32)+32 -> 32 signed multiply accumulate", so 50 MMACs? $\endgroup$ – endolith Apr 1 '14 at 21:00
11
$\begingroup$

As far as I know, ARM should be considered an architecture rather than a platform. However, the question is quite relevant as to what platform to use for RT signal (in this case audio) processing.

You could begin by asking following questions, not in strict order:

  • How much time do I have for the implementation?
  • What are my power constraints?
  • What mathematical operations do I need? You might end up requiring lots of multipliers in parallel and hence limit your choice.
  • How much memory do I need? (most MCUs are limited)
  • [Important] What is my frequency of operation? How much can I squeeze in within the sampling period keeping operating frequency low?
  • What libraries are available for my choice of implementation?

I would begin by looking at the algorithm first and foremost. If, for example, you need a lot of FFTs and MAC operations, you can probably rule out most microcontrollers and focus more on DSP cores. Bear in mind that there are MCUs with embedded DSP cores as well.

Another important consideration would be your ability and expertise in the area of implementation. Most people shy away from FPGA because you must use an HDL for the implementation. Another reason to shy away from FPGAs is the power requirement.

$\endgroup$
2
$\begingroup$

With just the information you provide the choice is probably ARM, (simple IIRs and FIRs) but there are other factors to consider such as power requirements, IO requirements, additional features you expect to implement: How much development time would you save if this device had a network connection and an API to modify DSP parameters in the field?

Have you considered expanding your range of options to smartphones or compact computers such as the Beagle Board? You might realize that the signal processing is only a small part of the entire problem you're solving.

$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.