为什么我的正弦波频率扫描不正确？

Question

I'm trying to create a simple WAV file that emits a changing pitch. However, the waveform that gets written to the file does not correspond to the data that get_sample returns.

I expect the tone to change in a logarithmic fashion, starting at A10 (28,160 Hz) and to end at A0 (27.5 Hz). As each second passes, the pitch should smoothly drop by one octave.

What is actually happening is difficult to explain. The tone changes, but in unintended ways. And what makes my problem more peculiar is that lowering the sample rate worsens the problem. In this output at 48,000 samples per second, the pitch rapidly drops and then rises again just to slowly fall once more. In this output at 3,000 samples per second, a similar effect happens, but it is more extreme and chaotic. What am I doing wrongly?

from math import pi, sin
from sys import byteorder
import wave

def get_sample(time):
    frequency = a10 / 2.0 ** time
    # print('{:.15f} {:.15f} {:.15f}'.format(time, frequency, sin(pi2 * frequency * time)))
    return sin(pi2 * frequency * time)

pi2 = 2 * pi
a10 = 28160.0

NUMBER_OF_CHANNELS = 1
SAMPLE_RATE = 48000  # samples per second
SAMPLE_WIDTH = 3  # bytes
DURATION = 10  # seconds

MAX_SAMPLE_VALUE = 2 ** (SAMPLE_WIDTH * 8 - 1)

samples = bytearray()

for i in range(SAMPLE_RATE * DURATION):
    time = i / SAMPLE_RATE
    sample = round(get_sample(time) * MAX_SAMPLE_VALUE)

    if sample == MAX_SAMPLE_VALUE:
        sample -= 1

    samples.extend(sample.to_bytes(SAMPLE_WIDTH, byteorder, signed=True))

with wave.open('output.wav', 'wb') as output:
    output.setnchannels(NUMBER_OF_CHANNELS)
    output.setsampwidth(SAMPLE_WIDTH)
    output.setframerate(SAMPLE_RATE)
    output.setnframes(NUMBER_OF_CHANNELS * SAMPLE_RATE * DURATION)
    output.setcomptype('NONE', 'not compressed')

    output.writeframes(samples)

Answer 1

A Frequency of 28,160Hz is to high for a sample rate of 48000.

And a sample rate of 3,000Hz , the maximum frequency would be less than 1.5KHz

This is related to the Nyquist sample rate. In short the maximum frequency you can sample at a given sample rate is 1/2 the Sample rate. In reality it is less than 1/2 the sample rate.

Please See:

https://en.wikipedia.org/wiki/Nyquist_frequency

0 https://dsp.stackexchange.com/

Given a 48000Hz sample rate, the maximum frequency you can sample is 24,000Hz. This maximum frequency is IDEALIZED , it would be much less.

To capture 28,160Hz frequency, you will need a sample rate more than 56,320Hz. Say 64,000Hz, or better yet 96000Hz sample rate.

EDIT: BTW Why is frequency function raising to the power of TIME ? **

That would cause some weird aliasing effects

I believe it should be Should be:

 
 
 
  
  frequency = a10 * time
 
  

I see... you're doing a frequency Sweep. thus adjusting the Frequency at each sample time.

Answer 2

There are two problems.

Aliasing

A signal sampled at a rate f _S can only be reconstructed correctly if it contains no components at frequencies higher than f _S /2. Any signal components with frequencies outside the interval [0, f _S /2] get folded into that interval when reconstructing the signal from the samples (eg by your soundcard).

This is called aliasing and can be avoided by either low-pass filtering a signal before sampling it or by making the sampling rate sufficiently high.

In your case, if you want to sample a sine wave with a frequency of 28160 Hz, the sampling rate must be at least 56320 Hz.

Incorrect computation of phase

 def get_sample(time): frequency = a10 / 2.0 ** time return sin(pi2 * frequency * time) 

The phase is the argument to the sin function. Its derivative with respect to time is the instantaneous frequency which is the pitch of the tone we hear.

In this case, if we plug frequency = a10 / 2.0 ** time into pi2 * frequency * time , the phase is

pi2 * (a10 / 2.0 ** time) * time

or in symbolic notation:

φ = 2π · A10 · 2 ^{− t} · t

The derivative of this is then

f = 2π · A10 · 2 ^{− t} · (1 − ln 2 · t ),

and not 2π · A10 · 2 ^{− t} as you had expected.

This is a plot of the actual frequency sweep that you get using your method (taking into account aliasing, notice how the curve is reflected at the 0 Hz and 24000 Hz lines), vs. what you had intended:

And here is the same plot with logarithmic frequency scale, which is how we perceive frequencies as pitches:

Solution

You get the correct result by making the following changes:

1. Use a high enough value for SAMPLE_RATE .

2. Don't calculate the sample directly from the given time, instead maintain a phase value which is incremented at a rate proportional to the intended frequency (wrap it at 2π so that it doesn't grow out of bounds), by replacing

    def get_sample(time): frequency = a10 / 2.0 ** time return sin(pi2 * frequency * time) […] for i in range(SAMPLE_RATE * DURATION): time = i / SAMPLE_RATE sample = round(get_sample(time) * MAX_SAMPLE_VALUE) 

   by

    def get_frequency(time): frequency = a10 / 2.0 ** time return frequency […] phase = 0 for i in range(SAMPLE_RATE * DURATION): time = i / SAMPLE_RATE f = get_frequency(time) phase = (phase + pi2 * f / SAMPLE_RATE) % pi2 sample = round(sin(phase) * MAX_SAMPLE_VALUE)