![no use](https://cdn.opencores.org/img/pils_lt.png)
![no use](https://cdn.opencores.org/img/pil_lt.png)
![no use](https://cdn.opencores.org/img/pil_rt.png)
![no use](https://cdn.opencores.org/img/pils_rt.png)
Does anyone have an idea of implementing deconvolution?
by wangyipeng on Dec 6, 2018 |
wangyipeng
Posts: 1 Joined: Nov 27, 2018 Last seen: Apr 14, 2022 |
||
I've tried "classic" long division, but the circuit has feedback and cannot pipeline to speed up.
characters: 1. a long sequence (usually > 2048) deconvoluted by a small sequence(3 or 5). 2. ignore the remainder. |
RE: Does anyone have an idea of implementing deconvolution?
by robfinch on Dec 9, 2018 |
robfinch
Posts: 28 Joined: Sep 29, 2005 Last seen: Aug 13, 2024 |
||
I don’t know much about convolutions, I just looked it up in Wikipedia, but could you make a guess estimate then use multiplication rather than division? And compare with the convoluted sequence. Then refine the guess. It might be possible to process multiple guesses at the same time in parallel and pick from the best. If you’re using an FPGA some of them have lots of multipliers. I’m thinking something like hardware annealing.
|
RE: Does anyone have an idea of implementing deconvolution?
by dgisselq on Dec 11, 2018 |
dgisselq
Posts: 247 Joined: Feb 20, 2015 Last seen: Jul 15, 2022 |
||
Deconvolution is one of those academic topics that rarely make sense in practice. The basic idea is that you have a signal, X_o(f), which was somehow corrupted by a filter, H(f), to create X(f). The thought is that if you filter X(f) by 1/H(f) so as to create Y(f) = X(f)/H(f) then you can get the original X_o(f) signal back.
This looks great on paper, it hardly ever works in practice. One of the biggest problems with deconvolution centers around what happens when H(f) is small, perhaps even zero or near zero. To see how this is a problem, consider an input X(f)+N(f) where X(f) is the corrupted waveform, H(f)X_o(f). Now, if H(f) is near zero, then [X(f)+N(f)]/H(f), will amplify your noise producing (roughly) Y(f) ~= N(f)/H(f). This is usually not desired. From an actual implementation perspective, the divide tends to get in the way. Divides within hardware, while doable, tend to be difficult. My own division algorithm takes just over N clocks for an N/N divide. If you know H(f) ahead of time, you might be able to just multiply by 1/H(f) to avoid this divide. Alternatively, there is another approach which uses a recursive estimate for 1/H(f) and then multiply the incoming data by 1/H(f) rather than dividing it by H(f). This can be ideal if H(f) isn't necessarily known, or if it is slowly approximated over time. Given the reality of what a deconvolution function does with the noise, matched and LMS adaptive filters tend to work better. Sure, they might distort the signal of interest, but used properly they can create an output that comes closer to the original intent. Both of these types of filters are easily implemented within an FPGA. Dan |
![no use](https://cdn.opencores.org/img/pils_lt.png)
![no use](https://cdn.opencores.org/img/pil_lt.png)
![no use](https://cdn.opencores.org/img/pil_rt.png)
![no use](https://cdn.opencores.org/img/pils_rt.png)