def main(): print("Inicializando encoder") freqDeAmostragem = 44100 signal = sig.signalMeu() freqDeAmostragem = 44100 filename = 'oi-meu-chapa.wav' # Extract data and sampling rate from file data, fs = sf.read(filename, dtype='float32') time = len(data) / freqDeAmostragem # sd.play(data, fs) # status = sd.wait() # Wait until file is done playing ####### data = np.array(data) dataLeft = [] for i in range(len(data)): dataLeft.append(data[i][0]) dataLeft = np.array(dataLeft) div = max(abs(dataLeft)) norm = dataLeft / max(abs(dataLeft)) low_pass_normalized = signal.butter_lowpass_filter(norm, 4000, freqDeAmostragem) sin = signal.generateSin(7000, 1, time, freqDeAmostragem) signalAM = low_pass_normalized * sin[1] print(sin[1]) sd.play(signalAM, fs) status = sd.wait() print(status)
def main(): print("Inicializando encoder") #declare um objeto da classe da sua biblioteca de apoio (cedida) signal = signalMeu() #declare uma variavel com a frequencia de amostragem, sendo 44100 fs = 44100 #tempo em segundos que ira emitir o sinal acustico duration = 5 #relativo ao volume. Um ganho alto pode saturar sua placa... comece com .3 gainX = 0.3 gainY = 0.3 print("Gerando Tons base") #Lista com relação de frequências FREQS = { "1": (697, 1209), "2": (697, 1336), "3": (697, 1477), "A": (697, 1633), "4": (770, 1209), "5": (770, 1336), "6": (770, 1477), "B": (770, 1633), "7": (852, 1209), "8": (852, 1336), "9": (852, 1477), "C": (852, 1633), "X": (941, 1209), "0": (941, 1336), "#": (941, 1477), "D": (941, 1633) } #Input para seleção de frequências, apenas valores de 0 a 9 # Recusar outros valores while(True): NUM = input("Selecione um valor de 0 a 9 ou A, B, C, D, X e #: ") if NUM in FREQS: break else: print("Apenas valores mostrados podem ser selecionados") print("Gerando Tom referente ao símbolo : {}".format(NUM)) #gere duas senoides para cada frequencia da tabela DTMF ! Canal x e canal y #use para isso sua biblioteca (cedida) canalX = signal.generateSin(FREQS[NUM][0], 1*gainX, duration, fs) canalY = signal.generateSin(FREQS[NUM][1], 1*gainY, duration, fs) #obtenha o vetor tempo tempo = canalX[0] #construa o sinal a ser reproduzido. Nâo se esqueca de que é a soma das senoides sinal = canalX[1] + canalY[1] #printe o grafico no tempo do sinal a ser reproduzido plt.plot(tempo[0:1000], sinal[0:1000]) # reproduz o som sd.play(sinal, fs) # Exibe gráficos plt.show() # aguarda fim do audio sd.wait()
def main(): global digit global quer_log global quer_arquivo info('Inicializando encoder') signal = signalMeu() info('Aguardando usuário') dialPad() if quer_log == True: logging.basicConfig( filename=getfilename('log', digit), level=logging.INFO, format= '[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s', datefmt='%H:%M:%S') info(f'Gerando tons base referentes ao símbolo: {digit}') freq1, freq2 = tabelaDTMF(digit) info('Executando as senoides (emitindo o som)') fs = 44100 F = 1 T = 1 t = np.linspace(0, 2 * T, T * fs) sd.default.samplerate = fs sd.default.channels = 1 x1, y1 = signal.generateSin(freq1, F, T, fs) x2, y2 = signal.generateSin(freq2, F, T, fs) y3 = y1 + y2 info(f'Gerando tom referente ao símbolo: {digit}') sd.play(y3) info('Plotando os gráficos') plt.figure() plt.plot(t[:300], y1[:300], 'b--', alpha=0.5, label=(f'{freq1}Hz')) plt.plot(t[:300], y2[:300], 'g--', alpha=0.5, label=(f'{freq2}Hz')) plt.plot(t[:300], y3[:300], 'k', alpha=0.75, label=(f'Soma de {freq1}Hz e {freq2}Hz')) plt.legend() plt.title(f'Frequências do símbolo {digit}') plt.grid(True) plt.autoscale(enable=True, axis='both', tight=True) plt.show() sd.wait() if quer_arquivo == True: filename = getfilename('som', digit) info(f'Salvando o arquivo de som em: {filename}') sf.write(filename, y3, fs)
def moduleAM(self, pb): f = 14000 # freq a ser modulada em Hz b = bibSignal.signalMeu() Cx, Cs = b.generateSin(f, self.amplitude, self.duration, self.freqAmostra) # S = Cs*pb S = [] for m in range(len(pb)): S.append(Cs[m] * pb[m]) return S
def moduleAM(self, pb): f = 14000 # freq a ser modulada em Hz b = bibSignal.signalMeu() Cx, Cs = b.generateSin(14000, 1, 7, 44100) S = [] for m in range(len(pb)): S.append(Cs[m] * pb[m]) f = fpb.PassaBaixa(S, self.freqAmostra) pb = f.filtro() return pb
def main(self, sound): sound, samplerate = sf.read(sound) lista = self.getSoundWaveList(sound) b = bibSignal.signalMeu() # sd.play(lista, self.freqAmostra) # sd.wait() b.plotFFT(lista, self.freqAmostra, 'encodeFourier.png') pb = self.normalize(lista) b.plotFFT(pb, self.freqAmostra, 'encodeFourier+FiltroPassaBaixa.png') S = self.moduleAM(pb) b.plotFFT(S, self.freqAmostra, 'encodeFourierModulada.png') # b = bibSignal.signalMeu() #plt.show() print("\nO áudio modulado tocará em 5 segundos") t0 = time.time() t1 = time.time() while (t1 - t0 < 5): print(str(round(5 - (t1 - t0))) + str(" segundo(s)\r"), end='\r') t1 = time.time() time.sleep(1) print("") print("\n========================") print("Iniciando a tocar o áudio!") print("========================\n") sd.play(S, 44100) sd.wait() print("") print("\n====================") print(" Fim do áudio! ") print("====================\n") print("+++++++++++++++++++++++++++") print("Gráficos salvos em: ") print("./modulacao-sinal-audio.png") print("./fourier.png ") print("+++++++++++++++++++++++++++") b.plotFFT(S, self.freqAmostra, 'fourier-encode.png') plt.figure(num=None, figsize=(14, 14), dpi=80, facecolor='w', edgecolor='k') plt.subplot(3, 1, 1) self.graficoTempo(lista, 'Sinal de áudio original', 'orange') plt.subplot(3, 1, 2) self.graficoTempo(pb, 'Sinal de áudio normalizado', 'purple') plt.subplot(3, 1, 3) self.graficoTempo(S, 'Sinal de áudio modulado em AM', 'green') plt.savefig('modulacao-sinal-audio.png')
def main(): data, samplerate = sf.read("save.wav") sinal = signalMeu() f = 44100 dados = data t = np.linspace(0,10,len(dados)) plt.plot(t,dados) plt.title("Audio recebido x Tempo") plt.show() sinal.plotFFT(dados,f) plt.show() # desmodulando t, s = sinal.generateSin(14000, 1, 10, f) desmodulado = dados*s plt.plot(t,desmodulado) plt.title("Audio desmodulado x Tempo") plt.show() sinal.plotFFT(desmodulado,f) plt.show() # filtro nyq_rate = f/2 width = 5.0/nyq_rate ripple_db = 60.0 #dB N , beta = signal.kaiserord(ripple_db, width) cutoff_hz = 4000.0 taps = signal.firwin(N, cutoff_hz/nyq_rate, window=('kaiser', beta)) yFiltrado = signal.lfilter(taps, 1.0, desmodulado) plt.plot(t,yFiltrado) plt.title("Audio passa baixa x Tempo") plt.show() sinal.plotFFT(yFiltrado,f) plt.show() sd.play(yFiltrado) sd.wait()
def discagem(self): """ Método que salva as frequencias a serem utilizadas na discagem """ bib = bibSignal.signalMeu() self.printTeclado() print("Qual tecla você deseja discar?") num = str(input("> ")).upper() array = [['1', '2', '3', 'A'], ['4', '5', '6', 'B'], ['7', '8', '9', 'C'], ['X', '0', '#', 'D']] linha = [697, 770, 852, 941] coluna = [1209, 1336, 1477, 1633] counter = 0 i = 0 while (i <= len(array)): if (num in array[i]): self.freq1 = linha[i] self.freq2 = coluna[array[i].index(num)] print("\n-----------------------") print(f"Frequência 1: {self.freq1} Hz") print(f"Frequência 2: {self.freq2} Hz") print("-----------------------\n") break elif (counter == 3): print("Valor inválido") print("Digite outro valor:") num = str(input("> ")).upper() i = 0 counter = 0 continue i += 1 counter += 1 sine_freq1 = bib.generateSin(self.freq1, self.amplitude, self.duration, self.freqAmostra) sine_freq2 = bib.generateSin(self.freq2, self.amplitude, self.duration, self.freqAmostra) sine = sine_freq1[1] + sine_freq2[1] print("\n=====================================") print(f"Gerando Tom referente ao símbolo : {num}") print("=====================================\n") sd.play(sine, self.freqAmostra) plt.plot(sine_freq1[0], sine) plt.axis([0.165, 0.190, -2, 2]) plt.savefig('sinewave.png') #plt.show() sd.wait() sys.exit()
def main(): print("Inicializando encoder") freqDeAmostragem = 44100 duration = 3 signal = sig.signalMeu() print("Gerando Tons base") optList = [ '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'X', '#', 'A', 'B', 'C', 'D' ] NUM = None print("****** TABELA *******") print("* 1 2 3 A *") print("* 4 5 6 B *") print("* 7 8 9 C *") print("* X 0 # D *") print("*********************") while NUM not in optList: NUM = input('Selecione um valor da tabela: ') print("Gerando Tom referente ao símbolo : {}".format(NUM)) tone, f1, f2 = signal.makeTone(NUM) dt = 0.01 #solta o som sd.play(tone, freqDeAmostragem) # Exibe gráficos fig, axs = plt.subplots(2, 1) axs[0].plot(f1[0][0:400], f1[1][0:400], f2[0][0:400], f2[1][0:400]) axs[0].set_xlabel('time') axs[0].set_ylabel('f1 and f2') axs[0].grid(True) axs[1].plot(f1[0][0:400], tone[0:400]) axs[1].set_xlabel('time') axs[1].set_ylabel('Tone') axs[1].grid(True) fig.tight_layout() plt.show() # aguarda fim do audio sd.wait()
def main(): # Criando o objeto da biblioteca fornecida. bib = signalMeu() # Taxa de amostragem. sampleRate = 44100 # Tempo de duração por caracter. duration = 2 # Amplitude. amplitude = 1 # Pegando o número do usuário. number = input("Number: ") # Declarando o sinal a ser criado. signal = [] print("[LOG] Generating the sine waves.") # Passando por cada caracter do número. for char in number: # Passando por cada letra presente na tabela. for letter in dfmtTable: # Verificando se são iguais. if char == letter[0]: # Gerando as senoides. time, wave = bib.generateSin(letter[1], amplitude, duration, sampleRate) time, wave2 = bib.generateSin(letter[2], amplitude, duration, sampleRate) # Adicionando as senoides ao final do sinal. signal.extend(wave + wave2) plt.plot(time[:400], wave[:400] + wave2[:400]) _, noSound = bib.generateSin(10, 0, 0.1, sampleRate) signal.extend(noSound) print("[LOG] Playing the generated sound.") # Mostrando o áudio e esperando ele terminar. sd.play(signal, sampleRate) sd.wait() # Plotando a transformada do sinal. # bib.plotFFT(signal, sampleRate) plt.show()
def main(self): bib = bibSignal.signalMeu() self.recordAudio() plt.figure(num=None, figsize=(14, 14), dpi=80, facecolor='w', edgecolor='k') self.graficoTempo(self.sound, 'Sinal de áudio capitado', 'orange') bib.plotFFT(self.sound, self.freqAmostra, 'fourier-sinal gravado') # print(self.sound) # print(f'len = {len(self.sound)}') self.sound = self.normalize(self.sound) self.sound = self.moduleAM(self.sound) sd.play(self.sound, self.freqAmostra) sd.wait() bib.plotFFT(self.sound, self.freqAmostra, 'Demodulado e filtrado')
def main(): global som signal = signalMeu() sd.default.samplerate = fs sd.default.channels = 1 loadsound() sd.playrec(som) plt.plot(t[:200], som[:200]) plt.title("Som gravado") plt.autoscale(enable=True, axis='both', tight=True) plt.show() sd.wait() x, y = signal.calcFFT(som, fs) # signal.plotFFT(som, fs) index = peakutils.indexes(y, thres=0.2, min_dist=10) for freq in x[index]: if int(freq) in range(1100, 1700): freq1 = get_freq1(freq) index1 = int(freq) if int(freq) in range(500, 1000): freq2 = get_freq2(freq) index2 = int(freq) plt.plot(x, y) plt.title('Transformada de Fourier do som gravado') # plt.text(index1, y[index1]-0.5, f'Frequência de pico 1: {y[index1]}Hz') # plt.text(index2+1, y[index2]-1, f'Frequência de pico 2: {y[index2]}Hz') plt.autoscale(enable=True, axis='both', tight=True) plt.show() resultado(freq1, freq2)
def main(): print("Inicializando encoder") #declare um objeto da classe da sua biblioteca de apoio (cedida) #declare uma variavel com a frequencia de amostragem, sendo 44100 freq = 44100 signal = signalMeu() #voce importou a bilioteca sounddevice como, por exemplo, sd. entao # os seguintes parametros devem ser setados: duration = 2 #tempo em segundos que ira emitir o sinal acustico #relativo ao volume. Um ganho alto pode saturar sua placa... comece com .3 gainX = 0.3 gainY = 0.3 print("Gerando Tons base") #gere duas senoides para cada frequencia da tabela DTMF ! Canal x e canal y tabela_DTMF = {"1":[1209, 697], "2":[1336, 697], "3":[1477, 697], "A":[1633, 697], "4":[1209, 770], "5":[1336, 770], "6":[1477, 770], "B":[1633, 770], "7":[1209, 852], "8":[1336, 852], "9":[1477, 852], "C":[1633, 852], "X":[1209, 941], "0":[1336, 941], "#":[1477, 941], "D":[1633, 941]} #use para isso sua biblioteca (cedida) #obtenha o vetor tempo tb. #deixe tudo como array #printe a mensagem para o usuario teclar um numero de 0 a 9. #nao aceite outro valor de entrada. NUM = input("Número de 0 a 9: ") print("Gerando Tom referente ao símbolo : {}".format(NUM)) while NUM not in tabela_DTMF: print("{} não está nesse intervalo.".format(NUM)) NUM = input("Número de 0 a 9: ") print("Gerando Tom referente ao símbolo : {}".format(NUM)) #construa o sunal a ser reproduzido. nao se esqueca de que é a soma das senoides time1, signaX = signal.generateSin(tabela_DTMF[NUM][0], gainX, duration, freq) time2, signaY = signal.generateSin(tabela_DTMF[NUM][1], gainY, duration, freq) signalTotal=[] for i in range(len(signaX)): signalTotal.append(signaX[i]+signaY[i]) #printe o grafico no tempo do sinal a ser reproduzido # reproduz o som sd.play(signalTotal, freq) # Exibe gráficos plt.plot(time1, signalTotal) plt.xlabel("Tempo (s)") plt.ylabel("Amplitude") plt.title("Soma das senoides") plt.axis([0, 0.05, -0.8, 0.8]) plt.show() # aguarda fim do audio sd.wait()
import suaBibSignal as sbs import numpy as np import sounddevice as sd import matplotlib.pyplot as plt import soundfile as sf import time import peakutils mySignal = sbs.signalMeu() fs = 48000 sd.default.samplerate = fs sd.default.channels = 2 duration = 3 for e in range(3): print(f"Starting in {3-e}...") time.sleep(1) print("SENTÔ KAISHI!!!") nSamples = duration * fs myRec = sd.rec(int(nSamples), fs, channels=1, blocking=True, dtype="float64") sd.wait() print("Time's UP!") teste = 0 # for e in myRec: # if e[0] != e[1]: # teste += 1 # print(teste) # mySignal.plotFFT(myRec, fs)
def main(): FREQS = { "1": (697, 1209), "2": (697, 1336), "3": (697, 1477), "A": (697, 1633), "4": (770, 1209), "5": (770, 1336), "6": (770, 1477), "B": (770, 1633), "7": (852, 1209), "8": (852, 1336), "9": (852, 1477), "C": (852, 1633), "X": (941, 1209), "0": (941, 1336), "#": (941, 1477), "D": (941, 1633) } array = [[], [], [], []] print("Inicializando decoder") #declare um objeto da classe da sua biblioteca de apoio (cedida) signal = signalMeu() #declare uma variavel com a frequencia de amostragem, sendo 44100 fs = 44100 #voce importou a bilioteca sounddevice como, por exemplo, sd. entao # os seguintes parametros devem ser setados: #taxa de amostragem #sd.default.samplerate = 1 #voce pode ter que alterar isso dependendo da sua placa #sd.default.channels = 2 #tempo em segundos que ira aquisitar o sinal acustico captado pelo mic # faca um printo na tela dizendo que a captacao comecará em n segundos. e entao #use um time.sleep para a espera wait = 5 print("A captura de som começará em {} segundos".format(wait)) time.sleep(wait) #faca um print informando que a gravacao foi inicializada print("Gravação inicializada!") #declare uma variavel "duracao" com a duracao em segundos da gravacao. poucos segundos ... duracao = 3 #calcule o numero de amostras "numAmostras" que serao feitas (numero de aquisicoes) numAmostras = duracao * fs audio = sd.rec(int(numAmostras), samplerate=fs, channels=2) sd.wait() print("... FIM") #grave uma variavel com apenas a parte que interessa (dados) sinal = [] for u in audio: sinal.append(u[0]) # use a funcao linspace e crie o vetor tempo. Um instante correspondente a cada amostra! tempo = np.linspace(0, duracao, numAmostras) # plot do gravico áudio vs tempo! plt.plot(tempo, sinal) ## Calcula e exibe o Fourier do sinal audio. como saida tem-se a amplitude e as frequencias xf, yf = signal.calcFFT(sinal, fs) plt.figure("F(y)") plt.plot(xf, yf) plt.grid() plt.title('Fourier audio') #esta funcao analisa o fourier e encontra os picos #voce deve aprender a usa-la. ha como ajustar a sensibilidade, ou seja, o que é um pico? #voce deve tambem evitar que dois picos proximos sejam identificados, pois pequenas variacoes na #frequencia do sinal podem gerar mais de um pico, e na verdade tempos apenas 1. indexes = peakutils.indexes(yf, thres=0.4, min_dist=100) #printe os picos encontrados! x_max = [] for index in indexes: if xf[index] < 1800 and xf[index] > 500: math.isclose(2.547, 2.0048, abs_tol=0.5) x_max.append(xf[index]) print(xf[index]) for e in FREQS: if math.isclose(FREQS[e][0], x_max[0], abs_tol=0.5) and math.isclose( FREQS[e][1], x_max[1], abs_tol=0.5): print("A tecla apertada foi: {}".format(e)) else: pass #encontre na tabela duas frequencias proximas às frequencias de pico encontradas e descubra qual foi a tecla #print a tecla. ## Exibe gráficos plt.show()
def main(): # declare um objeto da classe da sua biblioteca de apoio (cedida) signal = sig.signalMeu() # declare uma variavel com a frequencia de amostragem, sendo 44100 freqDeAmostragem = 44100 # voce importou a bilioteca sounddevice como, por exemplo, sd. entao # os seguintes parametros devem ser setados: sd.default.samplerate = freqDeAmostragem # taxa de amostragem sd.default.channels = 2 # voce pode ter que alterar isso dependendo da sua placa duration = 5 # tempo em segundos que ira aquisitar o sinal acustico captado pelo mic # faca um printo na tela dizendo que a captacao comecará em n segundos. e entao # use um time.sleep para a espera for i in range(6): print('A captação começará em ', i, ' segundos. \r') time.sleep(1) # faca um print informando que a gravacao foi inicializada print("A gravação foi inicializada.") # declare uma variavel "duracao" com a duracao em segundos da gravacao. poucos segundos ... start = time.time() # calcule o numero de amostras "numAmostras" que serao feitas (numero de aquisicoes) numAmostras = duration * freqDeAmostragem audio = sd.rec(int(numAmostras), freqDeAmostragem, channels=1) sd.wait() end = time.time() print("... FIM") dt = end - start print("Durou: ", dt, " segundos") # analise sua variavel "audio". pode ser um vetor com 1 ou 2 colunas, lista .. print("Audio recebido: ", audio) # grave uma variavel com apenas a parte que interessa (dados) audio_graf = [] for i in range(len(audio)): audio_graf.append(audio[i][0]) # use a funcao linspace e crie o vetor tempo. Um instante correspondente a cada amostra! t = np.linspace(0.0, dt, len(audio_graf)) # plot do gravico áudio vs tempo! # Calcula e exibe o Fourier do sinal audio. como saida tem-se a amplitude e as frequencias xf, yf = signal.calcFFT(audio_graf, freqDeAmostragem) # xf, yf = signal.calcFFT(y, fs) fig, axs = plt.subplots(2, 1) axs[0].plot(t, audio_graf) axs[0].set_xlabel('time') axs[0].set_ylabel('Tone Recived') axs[0].grid(True) # esta funcao analisa o fourier e encontra os picos # voce deve aprender a usa-la. ha como ajustar a sensibilidade, ou seja, o que é um pico? # voce deve tambem evitar que dois picos proximos sejam identificados, pois pequenas variacoes na # frequencia do sinal podem gerar mais de um pico, e na verdade tempos apenas 1. # probpeaks = [] # print(len(probpeaks)) # for i in range(len(yf)): # if yf[i]<1800 and yf[i]>600: # probpeaks.append(yf[i]) # probpeaks = np.array(probpeaks) # print(probpeaks) index = peakutils.indexes(yf, thres=0.2, min_dist=30) pplot(xf, yf, index) axs[1].set_ylabel('Fourier/Peaks') axs[1].grid(True) # for x,y in index: # label = "{:.2f}".format(y) # plt.annotate(label, # this is the text # (x,y), # this is the point to label # textcoords="offset points", # how to position the text # xytext=(0,10), # distance from text to points (x,y) # ha='center') # horizontal alignment can be left, right or center fig.tight_layout() plt.show() # print(index) value = xf[index] print(value) if value[0] <= 710: if value[1] <= 1250: print("1") elif value[1] <= 1390: print("2") elif value[1] <= 1490: print("3") else: print("A") elif value[0] <= 790: if value[1] <= 1250: print("4") elif value[1] <= 1390: print("5") elif value[1] <= 1490: print("6") else: print("B") elif value[0] <= 890: if value[1] <= 1250: print("7") elif value[1] <= 1390: print("8") elif value[1] <= 1490: print("9") else: print("C") else: if value[1] <= 1250: print("X") elif value[1] <= 1390: print("0") elif value[1] <= 1490: print("#") else: print("D")
def main(): data, samplerate = sf.read( "10convert.com_High-School-Musical-1-We-re-All-in-This-Together-Lyrics-1080pHD_iFu8Z-cV0Xk (online-audio-converter.com).wav" ) sinal = signalMeu() f = 44100 audio = data[0:10 * samplerate] dados = [] for e in audio[:, 0]: dados.append(e) t = np.linspace(0, 10, len(dados)) # 5a plt.plot(t, dados) plt.title("Audio original x Tempo") plt.show() sinal.plotFFT(dados, f) plt.show() # 5b dados = np.asarray(dados) normal = dados / max(dados) plt.plot(t, normal) plt.title("Audio normalizado x Tempo") plt.show() sinal.plotFFT(normal, f) plt.show() # 5c # exemplo de filtragem do sinal yAudioNormalizado # https://scipy.github.io/old-wiki/pages/Cookbook/FIRFilter.html nyq_rate = f / 2 width = 5.0 / nyq_rate ripple_db = 60.0 #dB N, beta = signal.kaiserord(ripple_db, width) cutoff_hz = 4000.0 taps = signal.firwin(N, cutoff_hz / nyq_rate, window=('kaiser', beta)) yFiltrado = signal.lfilter(taps, 1.0, normal) plt.plot(t, yFiltrado) plt.title("Audio passa baixa x Tempo") plt.show() sinal.plotFFT(yFiltrado, f) plt.show() # 5d t, s = sinal.generateSin(14000, 1, 10, f) modulado = yFiltrado * s plt.plot(t, modulado) plt.title("Audio modulado x Tempo") plt.show() sinal.plotFFT(modulado, f) plt.show() sf.write("save.wav", modulado, f)
def main(): try: print("Inicializando o Emissor\n") mySignal = signalMeu() number = int(input("Digite o número de transmissão: ")) f1, f2 = mySignal.sayTheFrequency(number) print("As frequências a enviar: {} e {}".format(f1, f2)) # Gerando os sinais x, sin1 = mySignal.generateSin(f1, A, T, fs) x, sin2 = mySignal.generateSin(f2, A, T, fs) # Somando as senoides sin = sin1 + sin2 # Tocando o som sound = sd.playrec(sin, fs) sd.wait() audio_captado = sound[:, 0] print("Áudio tocado e recebido") # Fourier X, Y = mySignal.calcFFT(audio_captado, fs) # Pegando as frequências de maior influência thres = 0.3 index = peakutils.indexes(np.abs(Y), thres=thres, min_dist=20) if len(index != 2): while len(index) > 2: thres += 0.005 index = peakutils.indexes(np.abs(Y), thres=thres, min_dist=50) while len(index) < 2: thres -= 0.005 index = peakutils.indexes(np.abs(Y), thres=thres, min_dist=50) frequencies = list() for freq in X[index]: if freq > 0: frequencies.append(freq) print("As frequências que mais aparecem são: {}".format(frequencies)) # Aproxima o número para a frequência mais próxima change_first = aproxima_number(frequencies, frequencies_1, index=0) second = aproxima_number(change_first, frequencies_2, index=1) print("\nAproximando, temos as frequências: {}".format(second)) # Descobre qual era o número number_received = mySignal.sayTheNumber(second) print("O número dessa frequência é o: {}".format(number_received)) # Plotando o gráfico temporal do sinal tocado plt.figure() plt.title("Soma dos senos enviadas [Sinal Tocado]") plt.plot(sin) plt.xlim(0, 1000) plt.savefig('somaDosSenos.png', format='png') plt.show() # Plotando o gráfico temporal do sinal recebido plt.figure() plt.plot(audio_captado) plt.title("Sinal Ouvido") plt.savefig('signalReceived.png', format='png') plt.show() # Plotando o Fourier do sinal recebido plt.figure() plt.plot(X, np.abs(Y)) plt.title("FFT do sinal ouvido") plt.savefig('FFTReceived.png', format='png') plt.show() except Exception as ex: print(ex)
def plotDemoduleGraph(self): bib = bibSignal.signalMeu() xf, yf = bib.calcFFT(self.sound, self.freqAmostra) plt.title('Fourier - Demodule') plt.plot(xf, yf) plt.savefig('Sinal de áudio capitado.png')
import soundfile as sf import sounddevice as sd import suaBibSignal as bib import numpy as np import matplotlib.pyplot as plt fs = 44100 # pontos por segundo (frequência de amostragem) A = 1.5 # Amplitude F = 1 # Hz T = 4 # Tempo em que o seno será gerado t = np.linspace(-T / 2, T / 2, T * fs) my_signal = bib.signalMeu() """ STEP -> 1 <- """ my_recording, samplerate = sf.read('camFis.wav') yAudio = my_recording[:, 1] samplesAudio = len(yAudio) # Sem Filtro X, Y = my_signal.calcFFT(yAudio, samplerate) plt.figure("Fourier (Sinal de áudio original)") plt.plot(X, np.abs(Y)) plt.ylabel('Amplitude (m)') plt.xlabel('Frequencie (Hz)') plt.grid() plt.title('Fourier (Sinal de áudio original)') plt.show() sd.play(yAudio, fs) sd.wait() """ STEP -> 2 <- """
def main(): # Criando o objeto da biblioteca fornecida. bib = signalMeu() # Tempo de duração da gravação. duration = 3 # Taxa de amostragem. sampleRate = 44100 # Número de canais a serem gravados. channels = 1 time.sleep(1) print("3...") time.sleep(1) print("2...") time.sleep(1) print("1...") print("Recording...") # Gravando o áudio. audio = sd.rec(int(duration * sampleRate), channels=channels) sd.wait() # audio2 = [a[0] for a in audio] # Calculando FFT. xf, yf = bib.calcFFT(audio2, sampleRate) # Plotando o gráfico do FFT. plt.title("Fourier Audio") plt.figure("F(y)") plt.plot(xf, yf) plt.grid() plt.show() # Pegando o índice de cada pico (onde está na lista). indexes = peakutils.indexes(yf, 0.05, min_dist=100) # Pegando os picos de acorco com os índices encontrados. # Ignoramos os índices que não estão entre 600Hz e 2000Hz. peaks = [xf[i] for i in indexes if xf[i] > 600 and xf[i] < 2000] # Printando os picos. print(f"Peaks: {peaks}") # Verificando se os picos estão dentro da tabela de números, incluindo a margem de erro. margin = 10 for entry in dfmtTable: number = entry[0] first = False second = False for peak in peaks: if (entry[1] - margin <= peak <= entry[1] + margin): first = True if (entry[2] - margin <= peak <= entry[2] + margin): second = True if (first and second): print(f"Number is: {number}")
def getEncodedWave(self, encodedStr): """ Adquire a onda de áudio do sinal encodado em bits """ b = bibSignal.signalMeu() b.generateSin()
def getSignal(self): """ Método que pega o sinal enviado por áudio pelo emissor e trata-o para adquirir a tecla que foi enviada """ bib = bibSignal.signalMeu() sd.default.samplerate = self.freqAmostra sd.default.channels = 2 print("\nA captura de áudio iniciará em 5 segundos") t0 = time.time() t1 = time.time() while (t1 - t0 < 5): print(str(round(5 - (t1 - t0))) + str(" segundo(s)\r"), end='\r') t1 = time.time() time.sleep(1) print("") print("\n====================") print("Começando a gravar!") print("====================\n") audio1 = sd.rec(int(self.duration * self.freqAmostra), self.freqAmostra, channels=1) sd.wait() audio = [] for sublist in audio1: for item in sublist: audio.append(item) print("") print("\n======================") print("Finalizando gravação!") print("======================\n") #print(audio) t = np.linspace(0, self.duration, self.duration * self.freqAmostra) #print(f"t = {t}") #print(f'len(t) = {len(t)}') xf, yf = bib.calcFFT(audio, self.freqAmostra) # print(f'xf = {xf}') # print(f'yf = {yf}') indexes = peakutils.indexes(yf, thres=0.2, min_dist=100) linha = [697, 770, 852, 941] coluna = [1209, 1336, 1477, 1633] array = [['1', '2', '3', 'A'], ['4', '5', '6', 'B'], ['7', '8', '9', 'C'], ['X', '0', '#', 'D']] pico1 = 0 pico2 = 0 for i in linha: if (math.isclose(i, xf[indexes[0]], abs_tol=10)): pico1 = i for j in coluna: if (math.isclose(j, xf[indexes[1]], abs_tol=10)): pico2 = j l1 = linha.index(pico1) c1 = coluna.index(pico2) tecla = array[l1][c1] print('\n---------------') print(f'Pico 1 = {pico1} Hz\nPico 2 = {pico2} Hz') print('---------------\n') print('\n==========================') print(f"Foi teclado a entrada: [{tecla}]") print('==========================\n') bib.plotFFT(audio, self.freqAmostra) sys.exit()
def main(): f1 = Figlet(font='slant') print(f1.renderText('Projeto 7 - receptor')) print("\n[+]---Inicializando decoder\n\n") signal = signalMeu() duration = 2 #tempo em segundos que ira aquisitar o sinal acustico captado pelo mic sd.default.channels = 1 sd.default.samplerate = 44100 numAmostras = 44100 * duration print("\n[+]---A captação do som começará em 5 segundos...") time.sleep(5) print("\n[+]---Gravação inicializada!") audio = sd.rec(int(2 * 44100), 44100, channels=1) sd.wait() print("\n[+]---Fim da gravação.") tempo = np.linspace(0, 2, 88200) arrayAudio = np.ndarray(shape=(88200, ), dtype=np.float32) for i in range(0, arrayAudio.shape[0]): arrayAudio[i] = audio[i][0] # # plot do gravico áudio gravado (dados) vs tempo! print("\n[+]---Plotando gráfico do áudio gravado.") plt.figure("Senoide") plt.plot(tempo[:400], arrayAudio[:400]) plt.grid(True) plt.title("Áudio gravado x Tempo") plt.autoscale(enable=True, axis="both", tight=True) plt.savefig("img/senoidesAudioGravado.png", format="png") plt.show() # ## Calcula e exibe o Fourier do sinal audio. como saida tem-se a amplitude e as frequencias print("\n[+]---Realizando a transformada de Fourier.") xf, yf = signal.calcFFT(arrayAudio, 44100) print("\n[+]---Plotando gráfico da transformada de Fourier.") plt.figure("Fourier") plt.plot(xf, yf) plt.grid(True) plt.title('Transformada de Fourier - Áudio gravado') plt.autoscale(enable=True, axis="both", tight=True) plt.savefig("img/transformadaFourier.png", format="png") plt.show() ## Adquirindo a tecla a partir do som obtido e da transformada de fourier print("\n[+]---Identificando picos.") index = peakutils.indexes(yf, thres=0.3, min_dist=1000) frqObtidaLista = [[], []] for frequencia in xf[index]: #Linha if int(frequencia) in range(640, 990): frqObtidaLista[0].append(int(frequencia)) #Coluna elif int(frequencia) in range(1160, 1680): frqObtidaLista[1].append(int(frequencia)) tabelaDTMF = { "1": [697, 1209], "2": [697, 1336], "3": [697, 1477], "A": [697, 1633], "4": [770, 1209], "5": [770, 1336], "6": [770, 1477], "B": [770, 1633], "7": [852, 1209], "8": [852, 1336], "9": [852, 1477], "C": [852, 1633], "X": [941, 1209], "0": [941, 1336], "#": [941, 1477], "D": [941, 1633] } character = "None" resolucao = 30 for tecla, frequencias in tabelaDTMF.items(): if frqObtidaLista[0][ 0] <= frequencias[0] + resolucao and frqObtidaLista[0][ 0] >= frequencias[0] - resolucao and frqObtidaLista[1][ 0] <= frequencias[1] + resolucao and frqObtidaLista[1][ 0] >= frequencias[1] - resolucao: character = tecla print(f"\n[+]---Tecla referente ao som gravado: {character}")
def butter_lowpass(cutoff, fs, order=5): nyq = 0.5 * fs normal_cutoff = cutoff / nyq b, a = butter(order, normal_cutoff, btype='low', analog=False) return b, a def butter_lowpass_filter(data, cutoff, fs, order=5): b, a = butter_lowpass(cutoff, fs, order=order) y = lfilter(b, a, data) return y if __name__ == "__main__": # Criando o objeto da biblioteca fornecida. bib = signalMeu() # Tempo de duração da gravação. duration = 10 # Taxa de amostragem. fs = 44100 # Número de canais a serem gravados. channels = 1 time.sleep(1) print("3...") time.sleep(1) print("2...")
def main(): # declare um objeto da classe da sua biblioteca de apoio (cedida) signal = sig.signalMeu() # declare uma variavel com a frequencia de amostragem, sendo 44100 freqDeAmostragem = 44100 # freq de porte ch = 7000 # voce importou a bilioteca sounddevice como, por exemplo, sd. entao # os seguintes parametros devem ser setados: sd.default.samplerate = freqDeAmostragem # taxa de amostragem sd.default.channels = 2 # voce pode ter que alterar isso dependendo da sua placa duration = 5 # tempo em segundos que ira aquisitar o sinal acustico captado pelo mic # faca um printo na tela dizendo que a captacao comecará em n segundos. e entao # use um time.sleep para a espera for i in range(6): print('A captação começará em ', 5 - i, ' segundos. \r', end="\r") time.sleep(1) print('') # faca um print informando que a gravacao foi inicializada print("A gravação foi inicializada.") start = time.time() # calcule o numero de amostras "numAmostras" que serao feitas (numero de aquisicoes) numAmostras = duration * freqDeAmostragem audio = sd.rec(int(numAmostras), freqDeAmostragem, channels=1) sd.wait() end = time.time() print("... FIM") dt = end - start print("Durou: ", dt, " segundos") portadora = signal.generateSin(ch, 1, duration, freqDeAmostragem) # analise sua variavel "audio". pode ser um vetor com 1 ou 2 colunas, lista .. # print("Audio recebido: ",audio) audio_graf = [] for i in range(len(audio)): audio_graf.append(audio[i][0]) # use a funcao linspace e crie o vetor tempo. Um instante correspondente a cada amostra! t = np.linspace(0.0, dt, len(audio_graf)) recebido = portadora[1] * np.array(audio_graf) recebidoFiltradao = signal.butter_lowpass_filter(recebido, ch / 10, freqDeAmostragem) sd.play(recebidoFiltradao) xf, yf = signal.calcFFT(audio_graf, freqDeAmostragem) fig, axs = plt.subplots(2, 1) axs[0].plot(t, recebidoFiltradao) axs[0].set_xlabel('time') axs[0].set_ylabel('Tone Recived') axs[0].grid(True) index = peakutils.indexes(yf, thres=0.2, min_dist=30) pplot(xf, yf, index) axs[1].set_ylabel('Fourier/Peaks') axs[1].grid(True) fig.tight_layout() plt.show()
def pipeline(): yAudio, samplerate = signalMeu().read("camFis.wav") samplesAudio = len(yAudio) generate_graphic( t := np.arange(0, samplesAudio / samplerate, 1 / samplerate)[:-1], amplitude := yAudio[:, 1], "Tempo em segundos", "Amplitude", "Amplitude por tempo do áudio original", ) sound = [[x, y] for x, y in zip(t, amplitude)] signalMeu().play_sound(sound, fs) normalized_amplitude = normalize(yAudio[:, 1]) generate_graphic( t, normalized_amplitude, "Tempo em segundos", "Amplitude normalizada", "Amplitude por tempo do áudio normalizado", ) sound_normalized = [[x, y] for x, y in zip(t, normalized_amplitude)] signalMeu().play_sound(sound_normalized, fs) filtered_amplitude = LPF(normalized_amplitude, 4000, fs) sound_filtered = [[x, y] for x, y in zip(t, filtered_amplitude)] generate_graphic( t, filtered_amplitude, "Tempo em segundos", "Amplitude normalizada", "Amplitude por tempo do áudio filtado até 4000 Hz", ) signalMeu().play_sound(sound_filtered, fs) sin_x, sin_amp = generateSin(14000, 5, fs) am_amplitude = sin_amp[:len(filtered_amplitude)] * filtered_amplitude fequencie_four, amplitude_four = signalMeu().calcFFT(am_amplitude, fs) generate_graphic( fequencie_four, amplitude_four, "frequência em Hz", "Amplitude", "Amplitude por freqência da onda modulada em 14000 Hz", ) sound_am = [[x, y] for x, y in zip(t, am_amplitude)] signalMeu().play_sound(sound_am, fs) demodulated_amplitude = [ x / y if y != 0 else x / 0.001 for x, y in zip(am_amplitude, sin_amp[:len(am_amplitude)]) ] generate_graphic( t, demodulated_amplitude, "Tempo em segundos", "Amplitude", "Amplitude por tempo desmodulada", ) fequencie_four_dem, amplitude_four_dem = signalMeu().calcFFT( demodulated_amplitude, fs) generate_graphic( fequencie_four_dem, amplitude_four_dem, "frequência em Hz", "Amplitude", "Amplitude por freqência desmodulada", ) sound_demodulated = [[x, y] for x, y in zip(t, demodulated_amplitude)] signalMeu().play_sound(sound_demodulated, fs)
def main(): #declare um objeto da classe da sua biblioteca de apoio (cedida) #declare uma variavel com a frequencia de amostragem, sendo 44100 signal = signalMeu() freqDeAmostragem = 44100 #voce importou a bilioteca sounddevice como, por exemplo, sd. entao # os seguintes parametros devem ser setados: sd.default.samplerate = freqDeAmostragem #taxa de amostragem sd.default.channels = 1 #voce pode ter que alterar isso dependendo da sua placa duration = 2 #tempo em segundos que ira aquisitar o sinal acustico captado pelo mic # faca um print na tela dizendo que a captacao comecará em n segundos. e entao n = 1 print("A captaçao comecara em {} segundos ".format(n)) time.sleep(n) #use um time.sleep para a espera #faca um print informando que a gravacao foi inicializada print("A gravaçao foi inicializada") #declare uma variavel "duracao" com a duracao em segundos da gravacao. poucos segundos ... numAmostras = freqDeAmostragem * duration #calcule o numero de amostras "numAmostras" que serao feitas (numero de aquisicoes) audio = sd.rec(int(numAmostras), freqDeAmostragem, channels=1) sd.wait() print("... FIM") #analise sua variavel "audio". pode ser um vetor com 1 ou 2 colunas, lista ... #grave uma variavel com apenas a parte que interessa (dados) dados = [] for e in audio[:,0]: dados.append(e) # use a funcao linspace e crie o vetor tempo. Um instante correspondente a cada amostra! t = np.linspace(0,duration,int(numAmostras)) #plot do gravico áudio vs tempo! plt.plot(dados,t) plt.grid() plt.title('audio vs tempo') plt.show() ## Calcula e exibe o Fourier do sinal audio. como saida tem-se a amplitude e as frequencias xf, yf = signal.calcFFT(dados, freqDeAmostragem) plt.figure("F(y)") plt.plot(xf,yf) plt.grid() plt.title('Fourier audio') plt.show() #esta funcao analisa o fourier e encontra os picos #voce deve aprender a usa-la. ha como ajustar a sensibilidade, ou seja, o que é um pico? #voce deve tambem evitar que dois picos proximos sejam identificados, pois pequenas variacoes na #frequencia do sinal podem gerar mais de um pico, e na verdade tempos apenas 1. #index = peakutils.indexes(,,) #printe os picos encontrados! index = peakutils.indexes(yf, thres=0.1, min_dist=50) picos = [xf[i] for i in index if xf[i] > 600 and xf[i] < 1800] maxi = max(picos, key=int) minn = min(picos, key=int) delta = 10 print("Picos : {} ".format(picos)) tabela_DTMF = {"1":[1209, 697], "2":[1336, 697], "3":[1477, 697], "A":[1633, 697], "4":[1209, 770], "5":[1336, 770], "6":[1477, 770], "B":[1633, 770], "7":[1209, 852], "8":[1336, 852], "9":[1477, 852], "C":[1633, 852], "X":[1209, 941], "0":[1336, 941], "#":[1477, 941], "D":[1633, 941]} if 1209 + delta >= maxi >= 1209 - delta : if 697 + delta >= minn >= 697 - delta: print("A tecla encontrada foi a : 1 ") if 1336 + delta >= maxi >= 1336 - delta: if 697 + delta >= minn >= 697 - delta: print("A tecla encontrada foi a : 2 ") if 1477 + delta >= maxi >= 1477 - delta: if 697 + delta >= minn >= 697 - delta : print("A tecla encontrada foi a : 3 ") if 1633 + delta >= maxi >= 1633 - delta: if 697 + delta >= minn >= 697 - delta : print("A tecla encontrada foi a : A ") if 1209 + delta >= maxi >= 1209 - delta : if 770 + delta >= minn >= 770 - delta : print("A tecla encontrada foi a : 4 ") if 1336 + delta >= maxi >= 1336 - delta : if 770 + delta >= minn >= 770 - delta: print("A tecla encontrada foi a : 5 ") if 1477 + delta >= maxi >= 1477 - delta: if 770 + delta >= minn >= 770 - delta: print("A tecla encontrada foi a : 6 ") if 1633 + delta >= maxi >= 1633 - delta: if 770 + delta >= minn >= 770 - delta : print("A tecla encontrada foi a : B ") if 1209 + delta >= maxi >= 1209 - delta: if 852 + delta >= minn >= 852 - delta : print("A tecla encontrada foi a : 7 ") if 1336 + delta >= maxi >= 1336 - delta: if 852 + delta >= minn >= 852 - delta : print("A tecla encontrada foi a : 8 ") if 1477 + delta >= maxi >= 1477 - delta : if 852 + delta >= minn >= 852 - delta : print("A tecla encontrada foi a : 9 ") if 1633 + delta >= maxi >= 1633 - delta : if 852 + delta >= minn >= 852 - delta : print("A tecla encontrada foi a : C ") if 1209 + delta >= maxi >= 1209 - delta : if 941 + delta >= minn >= 941 - delta : print("A tecla encontrada foi a : X ") if 1336 + delta >= maxi >= 1336 - delta: if 941 + delta >= minn >= 941 - delta : print("A tecla encontrada foi a : 0 ") if 1477 + delta >= maxi >= 1477 - delta: if 941 + delta >= minn >= 941 - delta : print("A tecla encontrada foi a : # ") if 1633 + delta >= maxi >= 1633 - delta: if 941 + delta >= minn >= 941 - delta : print("A tecla encontrada foi a : D ")