Esempio n. 1
0
fftpadding01 = np.zeros(int(M[1]) + N, complex)
fftpadding1  = np.zeros(int(M[2]) + N, complex)
fftpadding10 = np.zeros(int(M[3]) + N, complex)

signal_padding01 = np.zeros(int(M[1]) + N, float)
signal_padding1  = np.zeros(int(M[2]) + N, float)
signal_padding10 = np.zeros(int(M[3]) + N, float)

aux_padding01 = np.zeros(int(M[1]), float)
aux_padding1  = np.zeros(int(M[2]), float)
aux_padding10 = np.zeros(int(M[3]), float)


#%% generacion y muestreo de las senoidal

tt, signal = sg.seno(fs, f0, N, a0, p0)
  
#%% concateno los ceros
signal_padding01 = np.concatenate((signal, aux_padding01), axis=0) 
signal_padding1  = np.concatenate((signal, aux_padding1), axis=0) 
signal_padding10 = np.concatenate((signal, aux_padding10), axis=0) 

del aux_padding01
del aux_padding1
del aux_padding10

#%% Gŕaficos de las señales frecuenciales
fftsignal    = np.fft.fft(signal)
fftpadding01 = np.fft.fft(signal_padding01)
fftpadding1  = np.fft.fft(signal_padding1)
fftpadding10 = np.fft.fft(signal_padding10)
Esempio n. 2
0
a2 = 3  # Volts
p0 = 0  # radianes
f0 = 9 * df  # Hz

#%% Genero las variables necesarias

signal = np.zeros(N)
fftsignal = np.zeros(N, complex)

energia_temporal = 0
energia_frecuencia = 0
energia_frecuencia_puntual = 0
energia_max_frecuencia = 0
#%% generacion y muestreo de las senoidal
N0 = round((1 / f0) * 1000)
tt, aux_signal0 = sg.seno(fs, f0, N0, a0, p0)
tt, aux_signal1 = sg.seno(fs, f0, N0, a1, p0)
tt, aux_signal2 = sg.seno(fs, f0, N0, a2, p0)

aux = np.zeros(2 * N0)
aux = np.concatenate((aux_signal0, aux_signal1), axis=0)
aux2 = np.zeros(3 * N0)
aux2 = np.concatenate((aux, aux_signal2), axis=0)
aux3 = aux = np.zeros(6 * N0)
aux3 = np.concatenate((aux2, aux2), axis=0)
aux4 = np.concatenate((aux3, aux2), axis=0)
aux5 = np.zeros((1))
signal = np.concatenate((aux4, aux5), axis=0)

del tt, aux, aux2, aux3, aux4, aux5, aux_signal0, aux_signal1, aux_signal2
tt = np.linspace(0, (N - 1) / fs, N)
Esempio n. 3
0
f0 = fs / 4
w = 2 * np.pi * f0
duty = 50
width = 100
varianza = 1
SNR = 10

fd = np.array([0, 0.01, 0.25, 0.5], float)
fd1 = np.array(['f0', '0.01', '0.25', '0.5'])

signal = []
signal = np.zeros((N, 4))
fftsignal = []
fftsignal = np.zeros((N, 4))

tt, signal[:, 0] = sg.seno(fs, f0 + fd[0], N, a0, p0)

energia = 0
for ii in range(0, N):
    energia += signal[ii, 0]**2

energia = energia / N
print("la energía termporal es: ", energia)

fftsignal = np.fft.fft(signal[:, 0])
mod_fftsignal = np.abs(fftsignal)

energia2 = 0
for ii in range(0, N):
    energia2 += mod_fftsignal[ii]**2
Esempio n. 4
0
p1 = np.pi # radianes
f0 = 9*df# Hz

#%% Genero las variables necesarias

signal    = np.zeros(N)
fftsignal = np.zeros(N, complex)

energia_temporal = 0
energia_frecuencia = 0
energia_frecuencia_puntual = 0
energia_max_frecuencia = 0

#%% generacion y muestreo de las senoidal
N0= round((1/f0)*1000)
tt, aux_signal1 = sg.seno(fs, f0, N0, a0, p0)
tt, aux_signal2 = sg.seno(fs, f0, N0, a0, p1)
aux = np.zeros(2*N0)
aux = np.concatenate((aux_signal1, aux_signal2), axis=0) 
aux2 = np.zeros(N - 2*N0)
signal = np.concatenate((aux, aux2), axis=0) 

del tt, aux, aux2, aux_signal1, aux_signal2
tt = np.linspace(0, (N-1)/fs, N)

fftsignal    = np.fft.fft(signal)
mod_fftsignal = np.abs(fftsignal)


#%% Gŕaficos de las señales en tiempo y en frecuenciales
plt.figure("Gráfico de la señal temporal")
Esempio n. 5
0
p0 = 0  # radianes
f0 = 9 * df  # Hz

#%% Genero las variables necesarias

signal = np.zeros(N)
fftsignal = np.zeros(N, complex)

energia_temporal = 0
energia_frecuencia = 0
energia_frecuencia_puntual = 0
energia_max_frecuencia = 0

#%% generacion y muestreo de las senoidal
N0 = round((1 / f0) * 1000)
tt, aux_signal = sg.seno(fs, f0, N0, a0, p0)

aux = np.zeros(2 * N0)
aux2 = np.zeros((N - 3 * N0))
aux3 = np.concatenate((aux, aux_signal), axis=0)
signal = np.concatenate((aux3, aux2), axis=0)

del tt, aux, aux2, aux3, aux_signal
tt = np.linspace(0, (N - 1) / fs, N)

fftsignal = np.fft.fft(signal)
mod_fftsignal = np.abs(fftsignal)

#%% Gŕaficos de las señales en tiempo y en frecuenciales
plt.figure("Gráfico de la señal temporal")
plt.plot(tt, signal, 'b', label='f0 = 9d.f')
Esempio n. 6
0
p0 = 0  # radianes
f0 = 100  # Hz
w = 2 * np.pi * f0
duty = 50
width = 100

lsignal = ['seno', 'cuadrada', 'Dientes de cierra']

signal = []
signal = np.zeros((N, 3), dtype='complex')
fftsignal = []
fftsignal = np.zeros((N, 3), dtype='complex')
fftsignal1 = []
fftsignal1 = np.zeros((N, 3), dtype='complex')

tt, signal[:, 0] = sg.seno(fs, f0, N, a0, p0)
tt, signal[:, 1] = sg.square(fs, f0, N, a0, p0, duty)
tt, signal[:, 2] = sg.sawtooth(fs, f0, N, a0, p0, width)

ii = 0
while ii < 3:
    fftsignal[:, ii] = np.fft.fft(signal[:, ii])
    FFT.plotFFT(fftsignal[:, ii],
                fs,
                N,
                tp='FFT',
                c=ii,
                db='off',
                l=lsignal[ii])
    fftsignal1[:, ii] = FFT.myDFT(signal[:, ii])
    FFT.plotFFT(fftsignal1[:, ii],
Esempio n. 7
0
duty = 50
width = 100
varianza = 1
SNR = 10
fd = np.array([0.01, 0.25, 0.5],float)
fd1 = np.array(['0.01', '0.25', '0.5'])

signal = []
signal = np.zeros((N,3))
fftsignal= []
fftsignal= np.zeros((N,3))


#%% generacion y muestreo de senoidal
for ii in range(0,3):
    tt, signal[:,ii] = sg.seno(fs, f0 + fd[ii], N, a0, p0)



#tt, signal = sg.seno(fs, f0 + fd[2], N, a0, p0)
#ax = plt.figure("Funcion  senoidal")
#plt.plot(tt, signal,color='blue',label='sin(wt)')
#plt.xlabel('tiempo [segundos]')
#plt.ylabel('Amplitud [UA] ')
#plt.axhline(0, color="black")
#plt.axvline(0, color="black")
#plt.grid()
#plt.title('Funcion senoidal')
#plt.legend(loc = 'upper right')
#plt.show()
Esempio n. 8
0
fs = 1000  # Hz
a0 = 1  # Volts
p0 = 0  # radianes
f0 = 100  # Hz
w = 2 * np.pi * f0

N = np.array([16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192])

tiempofft = np.zeros(10)
tiempodft = np.zeros(10)

#%% Generacion de la señal senoidal

ii = 0
while ii < 8:
    tt, signal = sg.seno(fs, f0, N[ii], a0, p0)
    the_start = time()
    np.fft.fft(signal)
    the_end = time()
    tiempofft[ii] = the_end - the_start
    ii += 1

#%% calculando el tiempo de mi DFT
ii = 0
while ii < 8:
    tt, signal = sg.seno(fs, f0, N[ii], a0, p0)
    the_start = time()
    FFT.myDFT(signal)
    the_end = time()
    tiempodft[ii] = the_end - the_start
    ii += 1