In [1]:

    

""" setup """
%load_ext autoreload
%autoreload 2

import numpy as np

import matplotlib.pyplot as plt
plt.style.use(['classic'])

from redbaron import redbaron
redbaron.ipython_behavior = False

from pyha.simulation.simulation_interface import assert_sim_match

from scipy import signal
from pyhacores.under_construction.clock_recovery.gardner import GardnerTimingRecovery
from scipy.interpolate import interp1d


    

In [2]:

    

def insig(bits, sps, int_delay=0):
    nrz = [[1] * sps if x == 1 else [-1] * sps for x in bits]
    nrz = np.array(nrz).flatten()

    taps = [1 / sps] * sps
    matched = np.convolve(nrz, taps, mode='full')

    # delays
    sig = matched[int_delay:]
    return sig

def fract_delay(sig, fract_delay=0.0):
    f = interp1d(range(len(sig)), sig)
    new_x = np.array(range(len(sig))) + fract_delay
    fract_sig = f(new_x[:-1])
    return fract_sig

# input data
data = [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]*4
sps = 4
sig = insig(data, sps, 3)

plt.plot(sig)
plt.show()


    

In [3]:

    

def case(f_delay):
    #channel
    sig_f = fract_delay(sig, f_delay)

    recover = GardnerTimingRecovery(sps)

    ret, err, mu = recover.model_main(sig_f)
    
    plt.plot(ret, label='ret')
    plt.plot(err, label='err')
    plt.plot(mu, label='mu')
    plt.plot(sig_f[::sps], label='simple sampler')
    plt.title('Fractional delay:' + str(f_delay))
    plt.grid()
    plt.legend()
    plt.show()


    

In [4]:

    

for x in range(10):
    case(x/10)


    

In [ ]: