def test10():
# PRUEBA A FULL SCALE
sd = SigmaDelta()
f = 5e+2 # Frecuencia fundamental de la senoidal de prueba
fn = 2 * f # Frecuencia de Nyquist
fs = 25 * f # Frecuencia de sampleo de mi señal, con esto generamos las muestras
# El espaciado entre las muestras es función de la frecuencia de muestreo
time = np.arange(0, 8e-3, 1 / fs)
sine = 0.8 * np.sin(2 * np.pi * f * time)
# Por el momento sd.modulator devuelve la señal resampleada (con más samples) para poder plotear
M = 256
ry, rt, y = sd.modulator(time, sine, int((256 * 2) / 16))
# Le quitamos los primeros 2 valores porque son artificiales
plt.plot(rt, y[2:])
plt.plot(rt, ry)
D = 1
scaling_factor = ((fn / fs) * M) / D
signalDec = y
N = 5 # Con 6 anda muy bien
mean_filter = np.divide(np.ones(N), N)
filteredSignal = signal.fftconvolve(signalDec, mean_filter, mode="same")
plt.step(np.arange(len(filteredSignal)) / (scaling_factor * f),
filteredSignal,
color="black")
# plt.legend()
plt.title("TEST 10")
plt.show()
def test7():
# PRUEBA A FULL SCALE
sd = SigmaDelta()
f = 5e+2 # Frecuencia fundamental de la senoidal de prueba
mf = 2 * 12.5
fs = 25 * f # Frecuencia de sampleo de mi señal, con esto generamos las muestras
# El espaciado entre las muestras es función de la frecuencia de muestreo
time = np.arange(0, 8e-3, 1 / fs)
sine = 0.8 * np.sin(2 * np.pi * f * time)
# Por el momento sd.modulator devuelve la señal resampleada (con más samples) para poder plotear
M = 10
ry, rt, y = sd.modulator(time, sine, M)
# Le quitamos los primeros 2 valores porque son artificiales
plt.step(rt, y, label="Hola")
plt.plot(rt, ry)
plt.legend()
plt.show()
D = 1
scaling_factor = (mf * M) / D
signalDec = y
N = 64 # Con 6 anda muy bien
mean_filter = np.divide(np.ones(N), N)
filteredSignal = signal.fftconvolve(signalDec, mean_filter, mode="same")
# plt.step(np.arange(len(filteredSignal)),(scaling_factor*f), filteredSignal, color="black")
f, Pxx = signal.periodogram(y, fs=M * 25 * f, window="boxcar")
plt.plot(f, 10 * np.log(Pxx / 1e-3))
plt.xlim(0, (M / 2) * 25 * 500)
plt.show()
def test8():
# PRUEBA A FULL SCALE
sd = SigmaDelta()
f = 5e+2 # Frecuencia fundamental de la senoidal de prueba
mf = 2 * 12.5
fs = 25 * f # Frecuencia de sampleo de mi señal, con esto generamos las muestras
# El espaciado entre las muestras es función de la frecuencia de muestreo
time = np.arange(0, 8e-3, 1 / fs)
sine = 0.8 * np.sin(2 * np.pi * f * time)
# Por el momento sd.modulator devuelve la señal resampleada (con más samples) para poder plotear
M = 30
ry, rt, y = sd.modulator(time, sine, M)
# Le quitamos los primeros 2 valores porque son artificiales
plt.plot(rt, y)
plt.plot(rt, ry)
D = 50
decimatedSignal = signal.decimate(y[2:], D, ftype='fir')
# decimatedSignal = signal.decimate(decimatedSignal, 10)
scaling_factor = (mf * M) / D
plt.step(np.arange(len(decimatedSignal)) / (scaling_factor * f),
decimatedSignal,
label="dec",
color="yellow") # 75 = 25*30/10 oversampleado/decimacion
signalDec = decimatedSignal
# N = 64 # Con 6 anda muy bien
# mean_filter = np.divide(np.ones(N), N)
# filteredSignal = signal.fftconvolve(signalDec, mean_filter, mode="same")
# plt.step(np.arange(len(filteredSignal)) /
# (scaling_factor*f), filteredSignal, color="black")
plt.legend()
plt.title("TEST 8")
plt.show()
def test6():
# PRUEBA A FULL SCALE
sd = SigmaDelta()
f = 5e+2 # Frecuencia fundamental de la senoidal de prueba
fs = 25 * f # Frecuencia de sampleo de mi señal, con esto generamos las muestras
# El espaciado entre las muestras es función de la frecuencia de muestreo
time = np.arange(0, 8e-3, 1 / fs)
sine = 0.8 * np.sin(2 * np.pi * f * time)
# Por el momento sd.modulator devuelve la señal resampleada (con más samples) para poder plotear
ry, rt, y = sd.modulator(time, sine, 30)
# Le quitamos los primeros 2 valores porque son artificiales
# plt.plot(rt, y[2:])
plt.plot(rt, ry)
N = 64
mean_filter = np.divide(np.ones(N), N)
filteredSignal = signal.fftconvolve(y, mean_filter, mode="same")
plt.step(rt, filteredSignal, color="black")
decimatedSignal = signal.decimate(y, 10, ftype='fir')
# decimatedSignal = signal.decimate(decimatedSignal, 10)
plt.plot(np.arange(len(decimatedSignal)) / (75 * f),
decimatedSignal,
label="dec") # 75 = 25*30/10 oversampleado/decimacion
signalDec = decimatedSignal
plt.legend()
plt.title("TEST 6, inverted order from 5")
plt.show()
def noiseShapingDemo2(scale="dbm"):
"""
Parameters
----------
scale: str
type of yaxis scale, {"linear","dbm"}s
for close up looks of noise shapping effects dbm scale is prefered
"""
f0 = 500 # Sine wave fundamental frequency
T0 = 1 / f0
fs = 2.2 * f0 # Nyquist frecuency with some guard
Ts = 1 / fs # Time between samples
p = 3 # Ammount of periods to display
A = 0.5 # Sinewave amplitud
if scale != "linear" and scale != "dbm":
print("""Scale :{scale} is not supported
Please use "linear" or "dbm" """)
sd = SigmaDelta()
time = np.arange(0, p * T0, Ts)
sine1 = 0.5 * np.sin(2 * np.pi * f0 * time)
L1 = 16
L2 = 32
L3 = 64
L4 = 128
L5 = 256
Ls = [L5]
for os_factor in Ls:
resampled_y, resampled_t, out_binary_stream = sd.modulator(time,
sine1,
L=os_factor)
f, Pxx = signal.periodogram(out_binary_stream,
fs=os_factor * fs,
nfft=1024,
window="boxcar")
if scale == "dbm":
plt.plot(f, np.log10(Pxx / 1e-3), label=f"OS factor = {os_factor}")
plt.xlim(0, 27000)
plt.ylim(-5, 0)
elif scale == "linear":
plt.plot(f, Pxx * 1000, label=f"OS factor = {os_factor}")
plt.xlim(0, 15000)
plt.hlines(1.4, 0, 1000, linestyle="--")
plt.vlines(1000, 1.4, 0, linestyle="--")
plt.title(f"Noise Shaping $f_0$: {f0} Hz")
plt.xlabel('frequency [Hz]')
if scale == "dbm":
plt.ylabel('PSD dbm')
elif scale == "linear":
plt.ylabel('PSD $\\frac{V^2}{Hz}\\cdot 10^{-3}$')
plt.legend()
plt.show()
def bitStreamDemo():
f0 = 500 # Sine wave fundamental frequency
T0 = 1 / f0
fs = 2.2 * f0 # Nyquist frecuency with some guard
Ts = 1 / fs # Time between samples
p = 3 # Ammount of periods to display
L = 64 # Oversampling factor
A = 0.5 # Sinewave amplitud
sd = SigmaDelta()
time = np.arange(0, p * T0, Ts / L)
sine1 = A * np.sin(2 * np.pi * f0 * time)
resampled_y, resampled_t, out_binary_stream = sd.modulator(time,
sine1,
L=1)
plt.step(resampled_t, out_binary_stream, label="bit-stream")
plt.plot(resampled_t,
resampled_y,
label="Oversampled Input signal",
color="black")
plt.title(f"Salida del modulador OS factor L: {L}")
plt.xlabel("tiempo [segs]")
plt.ylabel("amplitud [V]")
plt.legend(loc="upper right")
plt.show()
def signalRecoveryDemo(L=256, D=16):
"""
Parameters
----------
L: int
Oversampling rate
D: int
Decimation factor
"""
f0 = 500 # Sine wave fundamental frequency
T0 = 1 / f0
nyquist_factor = 2.2
fs = nyquist_factor * f0 # Nyquist frecuency
Ts = 1 / fs # Time between samples
p = 1 # Ammount of periods to display
L = L # 256 # Oversampling factor
A = 0.5 # Sinewave amplitud
D = D # Decimation factor
sd = SigmaDelta()
time = np.arange(0, p * T0, Ts / L)
sine1 = A * np.sin(2 * np.pi * f0 * time)
resampled_y, resampled_t, out_binary_stream = sd.modulator(time, sine1)
plt.step(resampled_t,
out_binary_stream,
label="bit-stream",
color="magenta")
plt.plot(resampled_t,
resampled_y,
label="Oversampled Input signal",
color="black")
recoveredSignal = signal.decimate(resampled_y, q=D, ftype="fir")
scaling_factor = resampled_t[-1] / (len(recoveredSignal) - 1)
recoveredT = np.arange(0, len(recoveredSignal)) * scaling_factor
plt.stem(recoveredT, recoveredSignal, label="señal recuperada")
plt.step(recoveredT,
recoveredSignal,
label="señal recuperada",
color="yellow")
plt.title(
f"DEMO Salida del modulador OS factor L: {L}, D factor{D} $Fos$ = {fs*L}Hz "
)
plt.xlabel("tiempo [segs]")
plt.ylabel("amplitud [V]")
plt.legend(loc="upper right")
plt.show()
def test1():
# PRUEBA A FULL SCALE
sd = SigmaDelta()
f = 5e+2 # Frecuencia fundamental de la senoidal de prueba
fs = 25 * f # Frecuencia de sampleo de mi señal, con esto generamos las muestras
# El espaciado entre las muestras es función de la frecuencia de muestreo
time = np.arange(0, 2e-3, 1 / fs)
sine = 0.8 * np.sin(2 * np.pi * f * time)
# Por el momento sd.modulator devuelve la señal resampleada (con más samples) para poder plotear
ry, rt, y = sd.modulator(time, sine, 64)
# Le quitamos los primeros 2 valores porque son artificiales
plt.plot(rt, y[2:])
plt.plot(rt, ry)
plt.show()
def test3():
sd = SigmaDelta()
f = 5e+2 # Frecuencia fundamental de la senoidal de prueba
fs = 25 * f # Frecuencia de sampleo de mi señal, con esto generamos las muestras
# El espaciado entre las muestras es función de la frecuencia de muestreo
time = np.arange(0, 2e-3, 1 / fs)
sine = 0.5 * np.sin(2 * np.pi * f * time)
# Por el momento sd.modulator devuelve la señal resampleada (con más samples) para poder plotear
ry, rt, y = sd.modulator(time, sine, 64)
plt.title("Promedios Test3 Amplitud 0.5")
# Aca ploteamos el historial de promedios
plt.plot(rt, ry)
plt.plot(rt[:-1], sd.historyChannel)
plt.show()
def quantizationNoiseShapingDemo():
f0 = 500 # Sine wave fundamental frequency
T0 = 1 / f0
fs = 2.2 * f0 # Nyquist frecuency
Ts = 1 / fs # Time between samples
p = 1
sd = SigmaDelta()
# L1 = 16
# L2 = 32
# L3 = 64
# L4 = 128
L5 = 256
time = np.arange(0, p * T0, Ts)
zeros = np.zeros_like(time)
# Ls = [L1, L2, L3, L4, L5]
Ls = [L5]
for os_factor in Ls:
resampled_y, resampled_t, out_binary_stream = sd.modulator(time,
zeros,
L=os_factor)
# out_binary_stream = np.array(out_binary_stream, dtype=np.int) == 1
plt.title("Modulator response to Zero input")
plt.step(resampled_t, out_binary_stream)
plt.show()
f, Pxx = signal.periodogram(out_binary_stream,
fs=os_factor * fs,
nfft=1024)
plt.plot(f, np.log10(Pxx / 1e-3), label=f"OS factor = {os_factor}")
plt.xlim(0, 29090)
plt.ylim(-5.3, 0.3)
plt.title(f"Quantization Noise Shaping with no input")
plt.xlabel('frequency [Hz]')
plt.ylabel('PSD dbM')
plt.legend()
plt.show()
def test4():
# PRUEBA A FULL SCALE
sd = SigmaDelta()
f = 5e+2 # Frecuencia fundamental de la senoidal de prueba
fs = 25 * f # Frecuencia de sampleo de mi señal, con esto generamos las muestras
# El espaciado entre las muestras es función de la frecuencia de muestreo
time = np.arange(0, 4e-3, 1 / fs)
sine = 0.8 * np.sin(2 * np.pi * f * time)
# Por el momento sd.modulator devuelve la señal resampleada (con más samples) para poder plotear
ry, rt, y = sd.modulator(time, sine, 30)
# Le quitamos los primeros 2 valores porque son artificiales
plt.plot(rt, y)
plt.plot(rt, ry)
N = 8
mean_filter = np.divide(np.ones(N), N)
filteredSignal = signal.fftconvolve(y[2:], mean_filter, mode="same")
plt.step(rt, filteredSignal, color="black")
plt.legend()
plt.show()