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 ")
