End-To-End RDS - sample_rate not set

[vk6flab]

In the end-to-end chapter, there is a difference between the Final Code and the individual code and the variable assignments within the code appear to be at odds with the comments.

While it appears that both "versions" "work", I'm not sure why the discrepencies exist.

The individual code has these two blocks following each other:

# Symbol sync, using what we did in sync chapter
samples = x # for the sake of matching the sync chapter
samples_interpolated = resample_poly(samples, 32, 1) # we'll use 32 as the interpolation factor, arbitrarily chosen, seems to work better than 16
sps = 16
mu = 0.01 # initial estimate of phase of sample
out = np.zeros(len(samples) + 10, dtype=np.complex64)
out_rail = np.zeros(len(samples) + 10, dtype=np.complex64) # stores values, each iteration we need the previous 2 values plus current value
i_in = 0 # input samples index
i_out = 2 # output index (let first two outputs be 0)
while i_out < len(samples) and i_in+32 < len(samples):
    out[i_out] = samples_interpolated[i_in*32 + int(mu*32)] # grab what we think is the "best" sample
    out_rail[i_out] = int(np.real(out[i_out]) > 0) + 1j*int(np.imag(out[i_out]) > 0)
    x = (out_rail[i_out] - out_rail[i_out-2]) * np.conj(out[i_out-1])
    y = (out[i_out] - out[i_out-2]) * np.conj(out_rail[i_out-1])
    mm_val = np.real(y - x)
    mu += sps + 0.01*mm_val
    i_in += int(np.floor(mu)) # round down to nearest int since we are using it as an index
    mu = mu - np.floor(mu) # remove the integer part of mu
    i_out += 1 # increment output index
x = out[2:i_out] # remove the first two, and anything after i_out (that was never filled out)

# Fine freq sync
samples = x # for the sake of matching the sync chapter
N = len(samples)
phase = 0
freq = 0
# These next two params is what to adjust, to make the feedback loop faster or slower (which impacts stability)
alpha = 8.0
beta = 0.02
out = np.zeros(N, dtype=np.complex64)
freq_log = []
for i in range(N):
    out[i] = samples[i] * np.exp(-1j*phase) # adjust the input sample by the inverse of the estimated phase offset
    error = np.real(out[i]) * np.imag(out[i]) # This is the error formula for 2nd order Costas Loop (e.g. for BPSK)

    # Advance the loop (recalc phase and freq offset)
    freq += (beta * error)
    freq_log.append(freq * sample_rate / (2*np.pi)) # convert from angular velocity to Hz for logging
    phase += freq + (alpha * error)

    # Optional: Adjust phase so its always between 0 and 2pi, recall that phase wraps around every 2pi
    while phase >= 2*np.pi:
        phase -= 2*np.pi
    while phase < 0:
        phase += 2*np.pi
x = out

The Full Example has these lines between the two blocks:

#new sample_rate should be 1187.5
sample_rate /= 16

I added some print statements to check the sample rate. Before it's changed in the full code it's 19000.0, afterwards it's 1187.5.

What I don't understand is why the "Time Synchronisation (Symbol-Level)" block would change the sample rate to 1/16th, rather than 1/32, shown as the resample interpolation factor in the resample_poly call. The sps is set to 16, even though the comment just told us that 32 worked better than 16.

Should the sample rate be set like this:

sample_rate /= sps

And should sps be set to 32 in the "Time Synchronization (Symbol-Level)" block?

Or is there some other subtlety happening here that I'm missing?

73 de Onno VK6FLAB

In other words, I'm confused.

[777arc]

Ah yep there is definitely an inconsistency there, thanks for catching it. One quick thing though- the resampling done as part of symbol sync has nothing to do with the sps, it's a fairly arbitrary resampling factor that must be chosen, in fact I think part of the inconsistency is because I started with 16 but then changed it because it was confusing that the sps was also 16. But anyway whatever resampling factor is used there is how much to adjust sample_rate by, totally separate from sps. I'll fix this inconsistency soon.