Today most embedded problems can be solved with a cheap 32bit MCU.
Those are also much easier to program than FPGAs.
But small FPGAs are an absolute must if you have a problem which requires very fast reaction time,
very precise synchronization of multiple sensors or actuators or you need very accurate timing of events.
This is the case when you need fast control loops controlling very fast processes (like controlling fast spinning motors, regulating voltage or electric current, when you want to filter data very fast (like in a logic analyzer looking in real time for a trigger situation) or in driving lots of nozzels in an Injet print-head or the laser in a laser-printer (in case you do not want to have printed trackable documents http://www.net-security.org/secworld.php?id=18995 ).
Precise synchronization you need when you have system with lots of sensors where the data acquisition need to be at the exact same time with precise repetition (=low jitter) to be able to do a good measurement (like in a MRI scanner or phased array antenna).
Here you can find a good video explaining when a FPGA might be a better solution than an embedded controller.
Generate great music
FPGAs are very well suited for high level math operations, especially for complex algorithms or when operating on data streams at a high data rate (in the MHz). The strength of an FPGA is its ability to pipeline operations which means that the algorithm is broken up spatially into different steps. Each cycle new data flows into the top of the pipe and the processed data exits at the end. In this way, each step of the process occurs simultaneously, like an assembly line, so that no single iteration of the algorithm is blocked by the iteration before. By contrast a processor is a sequential machine so each iteration of an algorithm has to wait until the previous one finishes before starting.
A CPU is doing one thing after the other, no matter how fast it is clocked. And high end CPUs are massive pipelines, which increases the latency of any code execution.
FPGA are needed when you want to be sure that things happen exactly at the same time on a microsecond scale. This might be required treating several sensor inputs (like in a MRI or other sensor arrays where timing is critical) or a phased array antenna, or this might be at the output like controlling several currents and voltages of several motors to generate one smooth and precise movement of one robot arm or CNC machine with minimal electrical loss.
If you want to happen small things really fast (like a trigger at a logic analyzer), CPUs with their task switching and pipeline of instructions just react too slow. You want to have the trigger be implemented in hardware.
If you want things to be reliable and save, then you implement something in hardware. Simple hardware circuits are much simpler to prove to be error free that a whole CPU with its operating system software stack and the simple application on top. Complicated software can not be implemented in hardware, So there you need to “use the complex stack. But if you don’t have a complex problem, you can keep it simple by implementing it in programmable hardware.
Small FPGAs can move closer to the sensors and make the edge smart. This simplifies system design and software development a lot. The signal conditioning and validation and aggregation could be done directly at the sensor.
Very often this could be done by a MCU, but when low latency is important, FPGA are a better choice.
They can be used for indoor navigation system where the run time of radio waves determines the location of devices.