2 replaced http://dsp.stackexchange.com/ with https://dsp.stackexchange.com/
source | link

Mathematically, shifting the frequency of a signal is pretty easy:

Following @OlliNiemitalo's answeranswer, the 0.003 frequency shift can either be done in

  • time domain, or
  • frequency domain.

I recommend doing it in time domain, by multiplying the signal with a complex sinusoid,

$$e^{j 2 \pi f_\text{shift} n},\, n \in\{1,2,\ldots\}$$

that way you can get arbitrary frequency shifts.

Still, you're not right about needing to add up the amplitudes -- what you're doing is probably coherent sampling (i.e., the sampling clock doesn't stop after each 2048 sample chunk and starts with a random delay for the next, but continously runs at a stable frequency), so adding up multiple FFTs without reducing them to their amplitude works -- that's the beauty of the DFT being a linear operation, and the bases of the base transform it is being orthogonal.

Think of it like this:

Assume you add up many ($k$) consecutive FFTs. Because the DFT is linear, it'd be the same as adding up many consecutive 2048-vectors of time samples. What happens then is that things that repeat every 2048 samples get multiplied by $k$, whereas things that don't get attenuated or cancel themselves out. That sounds like a bad thing™, however, you have to realize one thing about the frequencies that the DFT can represent in each bin:

Every bin in the 2048-FFT represents one frequency that is an integer multiple of the fundamental frequency (ie. $\frac{f_\text{sample}}{N_\text{FFT}}$). So things that perfectly fall into each bin already inherently repeat every $N_\text{FFT} = 2048$. Hence, doing that will usually (assuming sufficiently stable sampling clock!) simply improve your SNR by $k$.

Concluding, just add up 2048-vectors of your time signal, and transform the result. You will get a 2048-DFT with an increased SNR, which definitely is meaningful.

Mathematically, shifting the frequency of a signal is pretty easy:

Following @OlliNiemitalo's answer, the 0.003 frequency shift can either be done in

  • time domain, or
  • frequency domain.

I recommend doing it in time domain, by multiplying the signal with a complex sinusoid,

$$e^{j 2 \pi f_\text{shift} n},\, n \in\{1,2,\ldots\}$$

that way you can get arbitrary frequency shifts.

Still, you're not right about needing to add up the amplitudes -- what you're doing is probably coherent sampling (i.e., the sampling clock doesn't stop after each 2048 sample chunk and starts with a random delay for the next, but continously runs at a stable frequency), so adding up multiple FFTs without reducing them to their amplitude works -- that's the beauty of the DFT being a linear operation, and the bases of the base transform it is being orthogonal.

Think of it like this:

Assume you add up many ($k$) consecutive FFTs. Because the DFT is linear, it'd be the same as adding up many consecutive 2048-vectors of time samples. What happens then is that things that repeat every 2048 samples get multiplied by $k$, whereas things that don't get attenuated or cancel themselves out. That sounds like a bad thing™, however, you have to realize one thing about the frequencies that the DFT can represent in each bin:

Every bin in the 2048-FFT represents one frequency that is an integer multiple of the fundamental frequency (ie. $\frac{f_\text{sample}}{N_\text{FFT}}$). So things that perfectly fall into each bin already inherently repeat every $N_\text{FFT} = 2048$. Hence, doing that will usually (assuming sufficiently stable sampling clock!) simply improve your SNR by $k$.

Concluding, just add up 2048-vectors of your time signal, and transform the result. You will get a 2048-DFT with an increased SNR, which definitely is meaningful.

Mathematically, shifting the frequency of a signal is pretty easy:

Following @OlliNiemitalo's answer, the 0.003 frequency shift can either be done in

  • time domain, or
  • frequency domain.

I recommend doing it in time domain, by multiplying the signal with a complex sinusoid,

$$e^{j 2 \pi f_\text{shift} n},\, n \in\{1,2,\ldots\}$$

that way you can get arbitrary frequency shifts.

Still, you're not right about needing to add up the amplitudes -- what you're doing is probably coherent sampling (i.e., the sampling clock doesn't stop after each 2048 sample chunk and starts with a random delay for the next, but continously runs at a stable frequency), so adding up multiple FFTs without reducing them to their amplitude works -- that's the beauty of the DFT being a linear operation, and the bases of the base transform it is being orthogonal.

Think of it like this:

Assume you add up many ($k$) consecutive FFTs. Because the DFT is linear, it'd be the same as adding up many consecutive 2048-vectors of time samples. What happens then is that things that repeat every 2048 samples get multiplied by $k$, whereas things that don't get attenuated or cancel themselves out. That sounds like a bad thing™, however, you have to realize one thing about the frequencies that the DFT can represent in each bin:

Every bin in the 2048-FFT represents one frequency that is an integer multiple of the fundamental frequency (ie. $\frac{f_\text{sample}}{N_\text{FFT}}$). So things that perfectly fall into each bin already inherently repeat every $N_\text{FFT} = 2048$. Hence, doing that will usually (assuming sufficiently stable sampling clock!) simply improve your SNR by $k$.

Concluding, just add up 2048-vectors of your time signal, and transform the result. You will get a 2048-DFT with an increased SNR, which definitely is meaningful.

1
source | link

Mathematically, shifting the frequency of a signal is pretty easy:

Following @OlliNiemitalo's answer, the 0.003 frequency shift can either be done in

  • time domain, or
  • frequency domain.

I recommend doing it in time domain, by multiplying the signal with a complex sinusoid,

$$e^{j 2 \pi f_\text{shift} n},\, n \in\{1,2,\ldots\}$$

that way you can get arbitrary frequency shifts.

Still, you're not right about needing to add up the amplitudes -- what you're doing is probably coherent sampling (i.e., the sampling clock doesn't stop after each 2048 sample chunk and starts with a random delay for the next, but continously runs at a stable frequency), so adding up multiple FFTs without reducing them to their amplitude works -- that's the beauty of the DFT being a linear operation, and the bases of the base transform it is being orthogonal.

Think of it like this:

Assume you add up many ($k$) consecutive FFTs. Because the DFT is linear, it'd be the same as adding up many consecutive 2048-vectors of time samples. What happens then is that things that repeat every 2048 samples get multiplied by $k$, whereas things that don't get attenuated or cancel themselves out. That sounds like a bad thing™, however, you have to realize one thing about the frequencies that the DFT can represent in each bin:

Every bin in the 2048-FFT represents one frequency that is an integer multiple of the fundamental frequency (ie. $\frac{f_\text{sample}}{N_\text{FFT}}$). So things that perfectly fall into each bin already inherently repeat every $N_\text{FFT} = 2048$. Hence, doing that will usually (assuming sufficiently stable sampling clock!) simply improve your SNR by $k$.

Concluding, just add up 2048-vectors of your time signal, and transform the result. You will get a 2048-DFT with an increased SNR, which definitely is meaningful.