Niemożność wyświetlenia wyniku kompilacji w metodzie ScrolledText okna Tkinter

0

Drodzy,
wykonałem kod, którego obliczenia działają w pętli.
Próbowałem różnymi metodami (to, co wyświetla się w konsoli, wrzucić do okna metody ScrolledText);
Przy pomocy:

  • insert
  • dataframe
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import fig as fig
import numpy as np
import pyaudio
import os
from matplotlib import pyplot as plt
from matplotlib import animation
from tkinter import scrolledtext
from tkinter import *
from PIL import ImageTk, Image
import pandas as pd

if __name__ == "__main__":


	window = Tk()
	window.title('Tuner Gitarowy')
	window.geometry('1380x855')

	img = ImageTk.PhotoImage(Image.open('z_gitara.png'))
	window = Label(window, background='NavajoWhite3', image=img)
	window.pack(side='right', fill='both', expand='yes')

	txt = scrolledtext.ScrolledText(window, width=60, height=53)
	txt.grid(column=0, row=1)

	window.mainloop()

	FSAMP = 22050  # czestotliwosc probkowania w Hz
	ROZMIAR_PROB = 2048  # ilosc probek
	KLATEK_NA_FFT = 16  # ilosc klatek zajmujacych srednio przez szybka transformate fouriera
	NOTKA_MIN = 40  # E2
	NOTKA_MAX = 64  # E4

	# dla wyswietlenia nazw dzwieku:

	NOTACJA = 'E F F# G G# A A# B C C# D D#'.split()

	# nowe dzwieki:
	PROBKI_NA_FFT = ROZMIAR_PROB * KLATEK_NA_FFT
	KROK_CZESTOTLIWOSCI = float(FSAMP) / PROBKI_NA_FFT


def nazwa_notki(n):
 	return NOTACJA[n % NOTKA_MIN % len(NOTACJA)] + str(int(n / 12 - 1))


def czestotliwosc_na_numer(f):
	return 64 + 12 * np.log2(f / 329.63)


def numer_na_czestotliwosc(n):
	return 329.63 * 2.0 ** ((n - 64) / 12.0)


# pobranie minumalnego\maksymalnego nr indeksu z szybkiej transformaty fouriera:
def notka_do_fftbin(n):
	return numer_na_czestotliwosc(n) / KROK_CZESTOTLIWOSCI


imin = max(0, int(np.floor(notka_do_fftbin(NOTKA_MIN - 1))))
imax = min(PROBKI_NA_FFT, int(np.ceil(notka_do_fftbin(NOTKA_MAX + 1))))

# Przydzial przestrzeni aby uruchomic szybka transformate fouriera:
buf = np.zeros(PROBKI_NA_FFT, dtype=np.float32)
numer_klatki = 0

# inicjalizacja dzwieku:
stream = pyaudio.PyAudio().open(format=pyaudio.paInt16, channels=1, rate=FSAMP, input=True, frames_per_buffer=ROZMIAR_PROB)
stream.start_stream()

# tworzenie funkcji Hanninga:
window = 0.5 * (1 - np.cos(np.linspace(0, 2 * np.pi, PROBKI_NA_FFT, False)))

# wypisanie poczatkowego tekstu:
print('pobieranie probek w:', FSAMP, 'Hz z maksymalna czestotliwoscia', KROK_CZESTOTLIWOSCI, 'Hz')


# otrzymywane dane w czasie:
while stream.is_active():

	# przesuwanie bufora i wprowadzenie nowych danych
	buf[:-ROZMIAR_PROB] = buf[ROZMIAR_PROB:]
	buf[-ROZMIAR_PROB:] = np.fromstring(stream.read(ROZMIAR_PROB), np.int16)

	# Uruchom szybka transformate fouriera na okiennym buforze
	fft = np.fft.rfft(buf * window)

	# pobierz czestotliwosc maksymalnej wartosci z zakresu
	czestotliwosc = (np.abs(fft[imin:imax]).argmax() + imin) * KROK_CZESTOTLIWOSCI

	# pobierz numer notatki i najblizsza notatke
	n = czestotliwosc_na_numer(czestotliwosc)
	n0 = int(round(n))

	# dane wyjsciowe konsoli, gdy mamy pelny bufor
	numer_klatki += 1



	nameCol = ('n', 'czestotliwosc', 'nazwa_notki(n0)', 'n - n0')
	x = n
	y = czestotliwosc
	z = nazwa_notki(n)
	v = (n - n0)
	data = pd.DataFrame(columns=nameCol)


	if numer_klatki >= KLATEK_NA_FFT:
		print('Numer {:7.2f}     Wysokosc: {:7.2f} Hz     Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0))

		# najpierw ustaw figure, os i element wykresu, ktory chcemy animowac
		def Okno(w):
			fig = plt.figure()
			ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
			line, = ax.plot([], [], lw=2)


		# funkcja inicjalizacji: wykresla tlo kazdej ramki
		def init():
			czestotliwosc.set_data([], [])
			return czestotliwosc,


		# funkcja animacji. Nazywa sie to sekwencyjnie
		def oblicz(i):
			x = np.linspace(0, 2, 1000)
			y = np.sin(2 * np.pi * (x - 0.01 * i))
			czestotliwosc.set_data(x, y)
			return czestotliwosc,
			anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)

	dataLoop = pd.DataFrame(columns=nameCol)
	dataLoop['n'] = (x)
	dataLoop['czestotliwosc'] = (y)
	dataLoop['nazwa_notki(n0)'] = (z)
	dataLoop['n - n0'] = (v)
	print(dataLoop)
	data = data.append(dataLoop, ignore_index=True)

Przypisałem zmienne do innym zmiennych, które realizują obliczenia.
Gdzieś robię błąd, bo nie wyrzuca tych wyników do okna.

Udostępniam cały kod, aktualny: https://megawrzuta.pl/download/6c42fee8422bc1dcfe07336af85658c6.html
i wyświetlający okno, a po jego zamknięciu printowanie wyników w konsoli: https://megawrzuta.pl/download/d7f580e8f1c06c9653f6ace83b08c1ff.html

Może czegoś się dopatrzycie.
Bardzo proszę o pomoc.

0
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import os
import fig as fig
import numpy as np
import pyaudio
from matplotlib import pyplot as plt
from matplotlib import animation
from tkinter import scrolledtext
from tkinter import *
from PIL import ImageTk, Image
import pandas as pd


if __name__ == "__main__":

	FSAMP = 22050  # czestotliwosc probkowania w Hz
	ROZMIAR_PROB = 2048  # ilosc probek
	KLATEK_NA_FFT = 16  # ilosc klatek zajmujacych srednio przez szybka transformate fouriera
	NOTKA_MIN = 40  # E2
	NOTKA_MAX = 64  # E4

	# dla wyswietlenia nazw dzwieku

	NOTACJA = 'E F F# G G# A A# B C C# D D#'.split()

# nowe dzwieki
PROBKI_NA_FFT = ROZMIAR_PROB * KLATEK_NA_FFT
KROK_CZESTOTLIWOSCI = float(FSAMP) / PROBKI_NA_FFT


def nazwa_notki(n):
	return NOTACJA[n % NOTKA_MIN % len(NOTACJA)] + str(int(n / 12 - 1))


def czestotliwosc_na_numer(f):
	return 64 + 12 * np.log2(f / 329.63)


def numer_na_czestotliwosc(n):
	return 329.63 * 2.0 ** ((n - 64) / 12.0)


# pobranie minumalnego\maksymalnego nr indeksu z szybkiej transformaty fouriera
# widocznosc dokumentacji dla numpy.rfftfreq()


def notka_do_fftbin(n):
	return numer_na_czestotliwosc(n) / KROK_CZESTOTLIWOSCI


imin = max(0, int(np.floor(notka_do_fftbin(NOTKA_MIN - 1))))
imax = min(PROBKI_NA_FFT, int(np.ceil(notka_do_fftbin(NOTKA_MAX + 1))))

# Przydzial przestrzeni aby uruchomic szybka transformate fouriera
buf = np.zeros(PROBKI_NA_FFT, dtype=np.float32)
numer_klatki = 0

# inicjalizacja dzwieku
stream = pyaudio.PyAudio().open(format=pyaudio.paInt16, channels=1, rate=FSAMP, input=True, frames_per_buffer=ROZMIAR_PROB)
stream.start_stream()

# tworzenie funkcji Hanninga
window = 0.5 * (1 - np.cos(np.linspace(0, 2 * np.pi, PROBKI_NA_FFT, False)))

# wypisanie poczatkowego tekstu
print('pobieranie probek w:', FSAMP, 'Hz z maksymalna rozdzielczoscia', KROK_CZESTOTLIWOSCI, 'Hz')

# otrzymywane dane w czasie:
while stream.is_active():

	# przesuwanie bufora i wprowadzenie nowych danych
	buf[:-ROZMIAR_PROB] = buf[ROZMIAR_PROB:]
	buf[-ROZMIAR_PROB:] = np.fromstring(stream.read(ROZMIAR_PROB), np.int16)

	# Uruchom szybka transformate fouriera na okiennym buforze
	fft = np.fft.rfft(buf * window)

	# pobierz czestotliwosc maksymalnej wartosci z zakresu
	czestotliwosc = (np.abs(fft[imin:imax]).argmax() + imin) * KROK_CZESTOTLIWOSCI

	# pobierz numer notatki i najblizsza notatke
	n = czestotliwosc_na_numer(czestotliwosc)
	n0 = int(round(n))

	# dane wyjsciowe konsoli, gdy mamy pelny bufor
	numer_klatki += 1

	if numer_klatki >= KLATEK_NA_FFT:

		window1 = Tk()
		window1.title('Tuner Gitarowy')
		window1.geometry('1380x855')

		img = ImageTk.PhotoImage(Image.open('z_gitara.png'))
		window1 = Label(window1, background='NavajoWhite3', image=img)
		window1.pack(side='right', fill='both', expand='yes')

		txt = scrolledtext.ScrolledText(window1, width=60, height=53)
		txt.grid(column=0, row=1)
		
		txt.insert(INSERT, ('Numer {:7.2f}     Wysokosc: {:7.2f} Hz     Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0)))


		# najpierw ustaw figure, os i element wykresu, ktory chcemy animowac
		def Okno(w):
			fig = plt.figure()
			ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
			line, = ax.plot([], [], lw=2)


		# funkcja inicjalizacji: wykresla tlo kazdej ramki
		def init():
			czestotliwosc.set_data([], [])
			return czestotliwosc,


		# funkcja animacji. Nazywa sie to sekwencyjnie
		def oblicz(i):
			x = np.linspace(0, 2, 1000)
			y = np.sin(2 * np.pi * (x - 0.01 * i))
			czestotliwosc.set_data(x, y)
			return czestotliwosc,
			anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)

		window1.mainloop()

Dobre wieści, program, działa, jak powinien. Zostało zapętlanie.

1

Deklariujesz funkcje w pętli typu def Okno(w): (czemu nie poza pętlą?) ale nie widzę byś gdzieś je wywoływał. Tj:

def f():

def f2():

while stream.is_active():
    f()
    f2()

zamiast

while stream.is_active():
    def f():

    def f2():

Plus zapisy typu :

return czestotliwosc,
            anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)

lepiej

anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)
return czestotliwosc, anim
0
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import os
import fig as fig
import numpy as np
import pyaudio
from matplotlib import pyplot as plt
from matplotlib import animation
from tkinter import scrolledtext
from tkinter import *
from PIL import ImageTk, Image
import pandas as pd

if __name__ == "__main__":
	FSAMP = 22050  # czestotliwosc probkowania w Hz
	ROZMIAR_PROB = 2048  # ilosc probek
	KLATEK_NA_FFT = 16  # ilosc klatek zajmujacych srednio przez szybka transformate fouriera
	NOTKA_MIN = 40  # E2
	NOTKA_MAX = 64  # E4

	# dla wyswietlenia nazw dzwieku

	NOTACJA = 'E F F# G G# A A# B C C# D D#'.split()

# nowe dzwieki
PROBKI_NA_FFT = ROZMIAR_PROB * KLATEK_NA_FFT
KROK_CZESTOTLIWOSCI = float(FSAMP) / PROBKI_NA_FFT


# najpierw ustaw figure, os i element wykresu, ktory chcemy animowac
def okno(w):
	fig = plt.figure()
	ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
	line, = ax.plot([], [], lw=2)


# funkcja inicjalizacji: wykresla tlo kazdej ramki
def init():
	czestotliwosc.set_data([], [])
	return czestotliwosc


# funkcja animacji. Nazywa sie to sekwencyjnie
def oblicz(i):
	x = np.linspace(0, 2, 1000)
	y = np.sin(2 * np.pi * (x - 0.01 * i))
	czestotliwosc.set_data(x, y)
	anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)
	return czestotliwosc







def nazwa_notki(n):
	return NOTACJA[n % NOTKA_MIN % len(NOTACJA)] + str(int(n / 12 - 1))


def czestotliwosc_na_numer(f):
	return 64 + 12 * np.log2(f / 329.63)


def numer_na_czestotliwosc(n):
	return 329.63 * 2.0 ** ((n - 64) / 12.0)


# pobranie minumalnego\maksymalnego nr indeksu z szybkiej transformaty fouriera
# widocznosc dokumentacji dla numpy.rfftfreq()

def notka_do_fftbin(n):
	return numer_na_czestotliwosc(n) / KROK_CZESTOTLIWOSCI


imin = max(0, int(np.floor(notka_do_fftbin(NOTKA_MIN - 1))))
imax = min(PROBKI_NA_FFT, int(np.ceil(notka_do_fftbin(NOTKA_MAX + 1))))

# Przydzial przestrzeni aby uruchomic szybka transformate fouriera
buf = np.zeros(PROBKI_NA_FFT, dtype=np.float32)
numer_klatki = 0

# inicjalizacja dzwieku
stream = pyaudio.PyAudio().open(format=pyaudio.paInt16, channels=1, rate=FSAMP, input=True, frames_per_buffer=ROZMIAR_PROB)
stream.start_stream()

# tworzenie funkcji Hanninga
window = 0.5 * (1 - np.cos(np.linspace(0, 2 * np.pi, PROBKI_NA_FFT, False)))

# wypisanie poczatkowego tekstu
print('pobieranie probek w:', FSAMP, 'Hz z maksymalna rozdzielczoscia', KROK_CZESTOTLIWOSCI, 'Hz')

# otrzymywane dane w czasie:
while stream.is_active():

	# przesuwanie bufora i wprowadzenie nowych danych
	buf[:-ROZMIAR_PROB] = buf[ROZMIAR_PROB:]
	buf[-ROZMIAR_PROB:] = np.fromstring(stream.read(ROZMIAR_PROB), np.int16)

	# Uruchom szybka transformate fouriera na okiennym buforze
	fft = np.fft.rfft(buf * window)

	# pobierz czestotliwosc maksymalnej wartosci z zakresu
	czestotliwosc = (np.abs(fft[imin:imax]).argmax() + imin) * KROK_CZESTOTLIWOSCI

	# pobierz numer notatki i najblizsza notatke
	n = czestotliwosc_na_numer(czestotliwosc)
	n0 = int(round(n))

	# dane wyjsciowe konsoli, gdy mamy pelny bufor
	numer_klatki += 1

	if numer_klatki >= KLATEK_NA_FFT:
		window1 = Tk()
		window1.title('Tuner Gitarowy')
		window1.geometry('1380x855')

		img = ImageTk.PhotoImage(Image.open('z_gitara.png'))
		window1 = Label(window1, background='NavajoWhite3', image=img)
		window1.pack(side='right', fill='both', expand='yes')

		txt = scrolledtext.ScrolledText(window1, width=60, height=53)
		txt.grid(column=0, row=1)

		txt.insert(INSERT, ('Numer {:7.2f}     Wysokosc: {:7.2f} Hz     Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0)))


		wywolaj1.okno()

		wywolaj2.init()

		wywolaj3.oblicz()



		window1.mainloop()

Deklaracja:

  • def okno
  • def init
  • def oblicz

Nad pętlą while, a w if'ie (zagnieżdżonym w while'u), wywoływać tylko instancję tej klasy.

Pytanie, jak to zrobić, bo:
wywolaj1.okno()

a także:
wywolaj1 = okno()

nie działają

1

A co to wywołaj1, wywołaj2? Jakaś klasa? Jak zdefiniowałeś funkcje init, okno, oblicz to po prostu wywołuj je init(), okno(), oblicz(). No i pamiętaj, że używasz obiektu czestotliwosc, który najlepiej przekazywać do funkcji jako parametr (unikaj globalnych zmiennych). Tj np. def init(i, czestotliwosc):

Problemów w tym kodzie jest wiele swoją drogą ale najpierw trzeba się zająć rażącymi błędami ;)

0

Chyba rozumiem.
Zamiast:

# najpierw ustaw figure, os i element wykresu, ktory chcemy animowac
def okno(w):
	fig = plt.figure()
	ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
	line, = ax.plot([], [], lw=2)


# funkcja inicjalizacji: wykresla tlo kazdej ramki
def init():
	czestotliwosc.set_data([], [])
	return czestotliwosc


# funkcja animacji. Nazywa sie to sekwencyjnie
def oblicz(i):
	x = np.linspace(0, 2, 1000)
	y = np.sin(2 * np.pi * (x - 0.01 * i))
	czestotliwosc.set_data(x, y)
	anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)
	return czestotliwosc

dać:

# najpierw ustaw figure, os i element wykresu, ktory chcemy animowac
def okno(w):
	fig = plt.figure()
	ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
	line, = ax.plot([], [], lw=2)


# funkcja inicjalizacji: wykresla tlo kazdej ramki
def init(czestotliwosc):
	czestotliwosc.set_data([], [])
	return czestotliwosc


# funkcja animacji. Nazywa sie to sekwencyjnie
def oblicz(i, czestotliwosc):
	x = np.linspace(0, 2, 1000)
	y = np.sin(2 * np.pi * (x - 0.01 * i))
	czestotliwosc.set_data(x, y)
	anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)
	return czestotliwosc

Tak?
Bo jeżeli to jest poprawna deklaracja, to return czestotliwosc nie powinien byc potrzebny.

Aha, przepraszam, że kod jest "po polsku", po prostu chcę zrozumieć, co się tu dzieje.

Aktualnie kod wygląda:

#! /usr/bin/env python
# -*- coding: utf-8 -*-
import os
import fig as fig
import numpy as np
import pyaudio
from matplotlib import pyplot as plt
from matplotlib import animation
from tkinter import scrolledtext
from tkinter import *
from PIL import ImageTk, Image
import pandas as pd

if __name__ == "__main__":
	FSAMP = 22050  # czestotliwosc probkowania w Hz
	ROZMIAR_PROB = 2048  # ilosc probek
	KLATEK_NA_FFT = 16  # ilosc klatek zajmujacych srednio przez szybka transformate fouriera
	NOTKA_MIN = 40  # E2
	NOTKA_MAX = 64  # E4

	# dla wyswietlenia nazw dzwieku

	NOTACJA = 'E F F# G G# A A# B C C# D D#'.split()

# nowe dzwieki
PROBKI_NA_FFT = ROZMIAR_PROB * KLATEK_NA_FFT
KROK_CZESTOTLIWOSCI = float(FSAMP) / PROBKI_NA_FFT







# najpierw ustaw figure, os i element wykresu, ktory chcemy animowac
def okno(w):
	fig = plt.figure()
	ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
	line, = ax.plot([], [], lw=2)


# funkcja inicjalizacji: wykresla tlo kazdej ramki
def init(czestotliwosc):
	czestotliwosc.set_data([], [])
	return czestotliwosc


# funkcja animacji. Nazywa sie to sekwencyjnie
def oblicz(i, czestotliwosc):
	x = np.linspace(0, 2, 1000)
	y = np.sin(2 * np.pi * (x - 0.01 * i))
	czestotliwosc.set_data(x, y)
	anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)
	return czestotliwosc




def nazwa_notki(n):
	return NOTACJA[n % NOTKA_MIN % len(NOTACJA)] + str(int(n / 12 - 1))


def czestotliwosc_na_numer(f):
	return 64 + 12 * np.log2(f / 329.63)


def numer_na_czestotliwosc(n):
	return 329.63 * 2.0 ** ((n - 64) / 12.0)


# pobranie minumalnego\maksymalnego nr indeksu z szybkiej transformaty fouriera
# widocznosc dokumentacji dla numpy.rfftfreq()

def notka_do_fftbin(n):
	return numer_na_czestotliwosc(n) / KROK_CZESTOTLIWOSCI


imin = max(0, int(np.floor(notka_do_fftbin(NOTKA_MIN - 1))))
imax = min(PROBKI_NA_FFT, int(np.ceil(notka_do_fftbin(NOTKA_MAX + 1))))

# Przydzial przestrzeni aby uruchomic szybka transformate fouriera
buf = np.zeros(PROBKI_NA_FFT, dtype=np.float32)
numer_klatki = 0

# inicjalizacja dzwieku
stream = pyaudio.PyAudio().open(format=pyaudio.paInt16, channels=1, rate=FSAMP, input=True, frames_per_buffer=ROZMIAR_PROB)
stream.start_stream()

# tworzenie funkcji Hanninga
window = 0.5 * (1 - np.cos(np.linspace(0, 2 * np.pi, PROBKI_NA_FFT, False)))

# wypisanie poczatkowego tekstu
print('pobieranie probek w:', FSAMP, 'Hz z maksymalna rozdzielczoscia', KROK_CZESTOTLIWOSCI, 'Hz')

# otrzymywane dane w czasie:
while stream.is_active():

	# przesuwanie bufora i wprowadzenie nowych danych
	buf[:-ROZMIAR_PROB] = buf[ROZMIAR_PROB:]
	buf[-ROZMIAR_PROB:] = np.fromstring(stream.read(ROZMIAR_PROB), np.int16)

	# Uruchom szybka transformate fouriera na okiennym buforze
	fft = np.fft.rfft(buf * window)

	# pobierz czestotliwosc maksymalnej wartosci z zakresu
	czestotliwosc = (np.abs(fft[imin:imax]).argmax() + imin) * KROK_CZESTOTLIWOSCI

	# pobierz numer notatki i najblizsza notatke
	n = czestotliwosc_na_numer(czestotliwosc)
	n0 = int(round(n))

	# dane wyjsciowe konsoli, gdy mamy pelny bufor
	numer_klatki += 1

	if numer_klatki >= KLATEK_NA_FFT:
		window1 = Tk()
		window1.title('Tuner Gitarowy')
		window1.geometry('1380x855')

		img = ImageTk.PhotoImage(Image.open('z_gitara.png'))
		window1 = Label(window1, background='NavajoWhite3', image=img)
		window1.pack(side='right', fill='both', expand='yes')

		txt = scrolledtext.ScrolledText(window1, width=60, height=53)
		txt.grid(column=0, row=1)

		txt.insert(INSERT, ('Numer {:7.2f}     Wysokosc: {:7.2f} Hz     Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0)))


		okno(), init(), oblicz()


		window1.mainloop()
0

Niestety, nie działa, bo prosi o zestaw informacji.
https://stackoverflow.com/questions/51007008/typeerror-sportcategory-takes-exactly-1-argument-0-given
Np. w def Okno, wewnątrz jest zadeklarowane (w), daję do kodu, ale nie działa.

0

Bo zadeklarowałeś okno(w) a wywołujesz okno(). Więc nie przekazujesz parametru w. W ogole po co parametr w? Nie wykorzystujesz go w funkcji okno(). I tak samo z init i oblicz (musisz przekazac i oraz czestottliwosc do funkcjI)

0

screenshot-20190205100426.png

Typ zmiennej mu nie odpowiada.
Kurczę, ile tu błędów.

1

Bo wykorzystujesz w tej funkcji metody i parametry, które nie przekazujesz nigdzie. Ja bym od początku prześledził co kod ma robić, co potrzebuje itp i to rozrysował sobie. Bo starasz się spiąć wszystko w całość popełniając elementarne błędy (jak nie przekazywanie odpowiednich parametrów). Może zdefiniuj swój problem i co chcesz zrobić na nowo. Łatwiej jest rozwiązywać konkretne problemy niż ogólne - a nikt nie poświęci więcej czasu bo czas to pieniądz ;)

Ewentualnie wrzuć kod na gita i ułatw innym pobranie i analizę w wolnym czasie.

0

https://gist.github.com/bartek9405/e1ca7210f1cec69c5cebe619a0b7a0dc

  1. Import bibliotek
  2. po if name == "main":
    mamy zadeklarowane stałe wartości, które są przekazywane niżej.
  3. Za pomocą stałych, określamy ilość próbek i częstotliwość przebiegu transformaty fouriera.
  4. Bez używania wcięcia, definiujemy funckje:
  • okno() - tutaj widzę, że zmienne fig oraz line zdają się być pomijane

  • init() - funkcja inicjalizacji: wykresla tlo kazdej ramki, listy przechowują określony typ zmiennych - Występuje krzak niemożności odnalezienia atrybutu 'set_data' w kodzie.

  • oblicz() - funkcja animacji przebiegu wyliczeń

  • nazwa_notki() - tutaj nie wiem dokładnie, ale gdy program działa w konsoli, wyprintowuje jakieś liczby z zakresu 55 - 63, zmiennoprzecinkowe.

  • czestotliwosc_na_numer() - tu jest sens całej aplikacji.szybka transformata fouriera

  • numer_na_czestotliwosc() - odwrotność poprzedniego zapisu

  • notka_do_ffftbin() - wynik zwracany do konsoli. Wyrażenie wysokości granej struny. Cały sens aplikacji.

imin, imax = Nie wiem dokładnie; Chodzi chyba o określenie zakresu wyprintowanych liczb metody notka_do_fftbin()

  • I poniżej jest przydział przestrzeni w pamięci, aby uruchomić transformatę
  • Inicjalizacja dźwięku - aktywacja strumienia, mikrofon lub linia USB
  • Tworzenie funkcji hanninga - jest potrzebną funkcją, bo transformatę mierzymy w określonym, skończonym okresie czasowym dla lepszego, dokładniejszego sprawdzenia wyniku.
  • Printowanie początkowego tekstu. Zbiór stałych, na podstawie, których badamy przebieg.

W While'u aktywujemy stream, pobieramy nowe dane, aktywujemy transformatę, pobieramy częstotliwość maksymalnej wartości z zakresu, pobieramy numer notacji + notatkę i określenie określenie numeru klatki (coś, jak inkrementacja).

A pod tym wszystkim, na sam koniec, w if'ie deklaracja okna, w którym to wszystko powinno się odbywać.
Po określeniu podstawowych informacji z okna, niżej są zadeklarowane trzy metody: okno(), init(), oblicz()

Robię jeszcze kod, drugą metodą:

#! /usr/bin/env python
# -*- coding: utf-8 -*-
import os
import pandas as pd
import fig as fig
import numpy as np
import pyaudio
from matplotlib import pyplot as plt
from matplotlib import animation
from tkinter import scrolledtext
from tkinter import *
from PIL import ImageTk, Image
from pandas import *


if __name__ == "__main__":

	FSAMP = 22050  # czestotliwosc probkowania w Hz
	ROZMIAR_PROB = 2048  # ilosc probek
	KLATEK_NA_FFT = 16  # ilosc klatek zajmujacych srednio przez szybka transformate fouriera
	NOTKA_MIN = 40  # E2
	NOTKA_MAX = 64  # E4

	# dla wyswietlenia nazw dzwieku

	NOTACJA = 'E F F# G G# A A# B C C# D D#'.split()

# nowe dzwieki
PROBKI_NA_FFT = ROZMIAR_PROB * KLATEK_NA_FFT
KROK_CZESTOTLIWOSCI = float(FSAMP) / PROBKI_NA_FFT


def nazwa_notki(n):
	return NOTACJA[n % NOTKA_MIN % len(NOTACJA)] + str(int(n / 12 - 1))


def czestotliwosc_na_numer(f):
	return 64 + 12 * np.log2(f / 329.63)


def numer_na_czestotliwosc(n):
	return 329.63 * 2.0 ** ((n - 64) / 12.0)


# pobranie minumalnego\maksymalnego nr indeksu z szybkiej transformaty fouriera
# widocznosc dokumentacji dla numpy.rfftfreq()


def notka_do_fftbin(n):
	return numer_na_czestotliwosc(n) / KROK_CZESTOTLIWOSCI


imin = max(0, int(np.floor(notka_do_fftbin(NOTKA_MIN - 1))))
imax = min(PROBKI_NA_FFT, int(np.ceil(notka_do_fftbin(NOTKA_MAX + 1))))

# Przydzial przestrzeni aby uruchomic szybka transformate fouriera
buf = np.zeros(PROBKI_NA_FFT, dtype=np.float32)
numer_klatki = 0

# inicjalizacja dzwieku
stream = pyaudio.PyAudio().open(format=pyaudio.paInt16, channels=1, rate=FSAMP, input=True, frames_per_buffer=ROZMIAR_PROB)
stream.start_stream()

# tworzenie funkcji Hanninga
window = 0.5 * (1 - np.cos(np.linspace(0, 2 * np.pi, PROBKI_NA_FFT, False)))

# wypisanie poczatkowego tekstu
print('pobieranie probek w:', FSAMP, 'Hz z maksymalna czestotliwoscia', KROK_CZESTOTLIWOSCI, 'Hz')



# otrzymywane dane w czasie:
while stream.is_active():

	# przesuwanie bufora i wprowadzenie nowych danych
	buf[:-ROZMIAR_PROB] = buf[ROZMIAR_PROB:]
	buf[-ROZMIAR_PROB:] = np.fromstring(stream.read(ROZMIAR_PROB), np.int16)

	# Uruchom szybka transformate fouriera na okiennym buforze
	fft = np.fft.rfft(buf * window)

	# pobierz czestotliwosc maksymalnej wartosci z zakresu
	czestotliwosc = (np.abs(fft[imin:imax]).argmax() + imin) * KROK_CZESTOTLIWOSCI

	# pobierz numer notatki i najblizsza notatke
	n = czestotliwosc_na_numer(czestotliwosc)
	n0 = int(round(n))

	# dane wyjsciowe konsoli, gdy mamy pelny bufor
	numer_klatki += 1


	zmienna1 = ('Numer {:7.2f}     Wysokosc: {:7.2f} Hz     Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0))


	if numer_klatki >= KLATEK_NA_FFT:

		# najpierw ustaw figure, os i element wykresu, ktory chcemy animowac
		def Okno(w):
			fig = plt.figure()
			ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
			line, = ax.plot([], [], lw=2)


		# funkcja inicjalizacji: wykresla tlo kazdej ramki
		def init():
			czestotliwosc.set_data([], [])
			return czestotliwosc,


		# funkcja animacji. Nazywa sie to sekwencyjnie
		def oblicz(i):
			x = np.linspace(0, 2, 1000)
			y = np.sin(2 * np.pi * (x - 0.01 * i))
			czestotliwosc.set_data(x, y)
			return czestotliwosc,
			anim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=20, blit=True)


	nameCol = ((n), (czestotliwosc), (nazwa_notki(n0)), (n - n0))
	data = pd.DataFrame(columns=nameCol)


	ww = n
	xx = czestotliwosc
	yy = nazwa_notki(n0)
	zz = n - n0

	dataLoop = pd.DataFrame(columns=nameCol)
	dataLoop['n'] = ww
	dataLoop['czestotliwosc'] = xx
	dataLoop['nazwa_notki(n0)'] = yy
	dataLoop['n - n0'] = zz
	value1 = data.append(dataLoop, ignore_index=True)





window1 = Tk()
window1.title('Tuner Gitarowy')
window1.geometry('1380x855')

img = ImageTk.PhotoImage(Image.open('z_gitara.png'))
window1 = Label(window1, background='NavajoWhite3', image=img)
window1.pack(side='right', fill='both', expand='yes')

txt = scrolledtext.ScrolledText(window1, width=60, height=53)
txt.grid(column=0, row=1)

txt.insert(INSERT, dataLoop)
print(dataLoop)
window1.mainloop()

Korzystając z DataFrame, przekazuję te informacje.
Problem jest tutaj jednak taki:

FutureWarning: Sorting because non-concatenation axis is not aligned. A future version
of pandas will change to not sort by default.
To accept the future behavior, pass 'sort=False'.
To retain the current behavior and silence the warning, pass 'sort=True'.

Aktualizowałem DataFrame, ale nic to nie dało.
'sort=True' i 'sort=False' też dałem w różnych miejscach w kodzie.

0
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
import pyaudio
from tkinter import scrolledtext
from tkinter import *
from PIL import ImageTk, Image

if __name__ == "__main__":
	FSAMP = 22050  # czestotliwosc probkowania w Hz
	ROZMIAR_PROB = 2048  # ilosc probek
	KLATEK_NA_FFT = 16  # ilosc klatek zajmujacych srednio przez szybka transformate fouriera
	NOTKA_MIN = 40  # E2
	NOTKA_MAX = 64  # E4

	# dla wyswietlenia nazw dzwieku

	NOTACJA = 'E F F# G G# A A# B C C# D D#'.split()

# Deklaracja okna
window1 = Tk()
window1.title('Tuner Gitarowy')
window1.geometry('1380x855')

img = ImageTk.PhotoImage(Image.open('z_gitara.png'))
window1 = Label(window1, background='NavajoWhite3', image=img)
window1.pack(side='right', fill='both', expand='yes')

txt = scrolledtext.ScrolledText(window1, width=60, height=53)
txt.grid(column=0, row=1)

# nowe dzwieki
PROBKI_NA_FFT = ROZMIAR_PROB * KLATEK_NA_FFT
KROK_CZESTOTLIWOSCI = float(FSAMP) / PROBKI_NA_FFT


def nazwa_notki(n):
	return NOTACJA[n % NOTKA_MIN % len(NOTACJA)] + str(int(n / 12 - 1))


def czestotliwosc_na_numer(f):
	return 64 + 12 * np.log2(f / 329.63)


def numer_na_czestotliwosc(n):
	return 329.63 * 2.0 ** ((n - 64) / 12.0)


# pobranie minumalnego\maksymalnego nr indeksu z szybkiej transformaty fouriera
# widocznosc dokumentacji dla numpy.rfftfreq()

def notka_do_fftbin(n):
	return numer_na_czestotliwosc(n) / KROK_CZESTOTLIWOSCI



imin = max(0, int(np.floor(notka_do_fftbin(NOTKA_MIN - 1))))
imax = min(PROBKI_NA_FFT, int(np.ceil(notka_do_fftbin(NOTKA_MAX + 1))))

# Przydzial przestrzeni aby uruchomic szybka transformate fouriera
buf = np.zeros(PROBKI_NA_FFT, dtype=np.float32)
numer_klatki = 0

# inicjalizacja dzwieku
stream = pyaudio.PyAudio().open(format=pyaudio.paInt16, channels=1, rate=FSAMP, input=True, frames_per_buffer=ROZMIAR_PROB)
stream.start_stream()

# tworzenie funkcji Hanninga
window = 0.5 * (1 - np.cos(np.linspace(0, 2 * np.pi, PROBKI_NA_FFT, False)))



# wypisanie poczatkowego tekstu
print('pobieranie probek w:', FSAMP, 'Hz z maksymalna rozdzielczoscia', KROK_CZESTOTLIWOSCI, 'Hz')

# otrzymywane dane w czasie:
while stream.is_active():

	# przesuwanie bufora i wprowadzenie nowych danych
	buf[:-ROZMIAR_PROB] = buf[ROZMIAR_PROB:]
	buf[-ROZMIAR_PROB:] = np.fromstring(stream.read(ROZMIAR_PROB), np.int16)

	# Uruchom szybka transformate fouriera na okiennym buforze
	fft = np.fft.rfft(buf * window)

	# pobierz czestotliwosc maksymalnej wartosci z zakresu
	czestotliwosc = (np.abs(fft[imin:imax]).argmax() + imin) * KROK_CZESTOTLIWOSCI

	# pobierz numer notatki i najblizsza notatke
	n = czestotliwosc_na_numer(czestotliwosc)
	n0 = int(round(n))

	# dane wyjsciowe konsoli, gdy mamy pelny bufor
	numer_klatki += 1



	if numer_klatki >= KLATEK_NA_FFT:

		jj = txt.insert(INSERT, 'Numer {:7.2f}     Wysokosc: {:7.2f} Hz     Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0))

		print jj

	window1.mainloop()

Dokonałem pewnego rodzaju refaktoryzacji i mam niemal 90% pewności, że kod powinien już działać w pętli, wewnątrz okna Tkinter, metody ScrolledText

Kod błędu:

File "C:/Users/lenovo/Desktop/Tuner_Gitarowy/dzialajacy.py", line 100, in <module>
jj = txt.insert(INSERT, 'Numer {:7.2f} Wysokosc: {:7.2f} Hz Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0))
File "C:\Python27\Lib\lib-tk\Tkinter.py", line 3109, in insert
self.tk.call((self._w, 'insert', index, chars) + args)
_tkinter.TclError: invalid command name ".80354952L.83357960L.83358024L"

Process finished with exit code 1

Niestety, nie rozumiem tego błędu.
Czy jemu chodzi o zastosowane znaki?

0

screenshot-20190206000509.png

Niestety, ale nawet w przypadku: txt.insert(tkinter.INSERT, 'string')
Występuje błąd:

File "C:/Users/lenovo/Desktop/Tuner_Gitarowy/dzialajacy.py", line 94, in <module>
txt.insert(tkinter.INSERT, 'string')
File "C:\Python27\Lib\lib-tk\Tkinter.py", line 3109, in insert
self.tk.call((self._w, 'insert', index, chars) + args)
_tkinter.TclError: invalid command name ".339501640L.342618184L.342619080L"

0

W wyniku kompilacji, wyświetla nam stringa:
screenshot-20190206091738.png

Po zamknięciu aplikacji, program psuje się i wyprintowuje błąd:
screenshot-20190206091829.png

File "C:/Users/lenovo/Desktop/Tuner_Gitarowy/dzialajacy.py", line 94, in <module>
txt = tkinter.scrolledtext.ScrolledText(window1, width=60, height=53)
File "C:\Python27\Lib\lib-tk\ScrolledText.py", line 21, in init
self.frame = Frame(master)
File "C:\Python27\Lib\lib-tk\Tkinter.py", line 2574, in init
Widget.init(self, master, 'frame', cnf, {}, extra)
File "C:\Python27\Lib\lib-tk\Tkinter.py", line 2095, in init
(widgetName, self._w) + extra + self._options(cnf))
_tkinter.TclError: can't invoke "frame" command: application has been destroyed
Process finished with exit code 1

z kolei samo umieszczenie:
W while:
txt = scrolledtext.ScrolledText(window1, width=60, height=53) txt.grid(column=0, row=1)
i w,
if numer_klatki >= KLATEK_NA_FFT:
wywoływanie stringa
Daje skutek możności kompilacji bez błędów, z zastrzeżeniem na niewyświetlanie przebiegu w oknie.

#! /usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
import pyaudio
import tkinter
from tkinter import scrolledtext
from PIL import ImageTk, Image

if __name__ == "__main__":
    FSAMP = 22050  # czestotliwosc probkowania w Hz
    ROZMIAR_PROB = 2048  # ilosc probek
    KLATEK_NA_FFT = 16  # ilosc klatek zajmujacych srednio przez szybka transformate fouriera
    NOTKA_MIN = 40  # E2
    NOTKA_MAX = 64  # E4

    # dla wyswietlenia nazw dzwieku

    NOTACJA = 'E F F# G G# A A# B C C# D D#'.split()

# Deklaracja okna
window1 = tkinter.Tk()
window1.title('Tuner Gitarowy')
window1.geometry('1380x855')

img = ImageTk.PhotoImage(Image.open('z_gitara.png'))
window1 = tkinter.Label(window1, background='NavajoWhite3', image=img)
window1.pack(side='right', fill='both', expand='yes')




# nowe dzwieki
PROBKI_NA_FFT = ROZMIAR_PROB * KLATEK_NA_FFT
KROK_CZESTOTLIWOSCI = float(FSAMP) / PROBKI_NA_FFT


def nazwa_notki(n):
    return NOTACJA[n % NOTKA_MIN % len(NOTACJA)] + str(int(n / 12 - 1))

def czestotliwosc_na_numer(f):
    return 64 + 12 * np.log2(f / 329.63)

def numer_na_czestotliwosc(n):
    return 329.63 * 2.0 ** ((n - 64) / 12.0)


# pobranie minumalnego\maksymalnego nr indeksu z szybkiej transformaty fouriera
# widocznosc dokumentacji dla numpy.rfftfreq()


def notka_do_fftbin(n):
    return numer_na_czestotliwosc(n) / KROK_CZESTOTLIWOSCI

imin = max(0, int(np.floor(notka_do_fftbin(NOTKA_MIN - 1))))
imax = min(PROBKI_NA_FFT, int(np.ceil(notka_do_fftbin(NOTKA_MAX + 1))))

# Przydzial przestrzeni aby uruchomic szybka transformate fouriera
buf = np.zeros(PROBKI_NA_FFT, dtype=np.float32)
numer_klatki = 0

# inicjalizacja dzwieku
stream = pyaudio.PyAudio().open(format=pyaudio.paInt16, channels=1, rate=FSAMP, input=True, frames_per_buffer=ROZMIAR_PROB)
stream.start_stream()

# tworzenie funkcji Hanninga
window = 0.5 * (1 - np.cos(np.linspace(0, 2 * np.pi, PROBKI_NA_FFT, False)))

# wypisanie poczatkowego tekstu
print('pobieranie probek w:', FSAMP, 'Hz z maksymalna rozdzielczoscia', KROK_CZESTOTLIWOSCI, 'Hz')

# otrzymywane dane w czasie:
while stream.is_active():

    # przesuwanie bufora i wprowadzenie nowych danych
    buf[:-ROZMIAR_PROB] = buf[ROZMIAR_PROB:]
    buf[-ROZMIAR_PROB:] = np.fromstring(stream.read(ROZMIAR_PROB), np.int16)

    # Uruchom szybka transformate fouriera na okiennym buforze
    fft = np.fft.rfft(buf * window)

    # pobierz czestotliwosc maksymalnej wartosci z zakresu
    czestotliwosc = (np.abs(fft[imin:imax]).argmax() + imin) * KROK_CZESTOTLIWOSCI

    # pobierz numer notatki i najblizsza notatke
    n = czestotliwosc_na_numer(czestotliwosc)
    n0 = int(round(n))

    # dane wyjsciowe konsoli, gdy mamy pelny bufor
    numer_klatki += 1

    txt = tkinter.scrolledtext.ScrolledText(window1, width=60, height=53)
    txt.grid(column=0, row=1)


    if numer_klatki >= KLATEK_NA_FFT:
		txt.insert(tkinter.INSERT, 'string')

window1.mainloop()
0

window1.mainloop() powinien być chyba bez wcięć, bo deklaracja okna również taka jest.

Jeżeli ustawię go na 'wysokości' while'a:
File "C:/Users/lenovo/Desktop/Tuner_Gitarowy/dzialajacy.py", line 98
window1.mainloop()
^
IndentationError: unindent does not match any outer indentation level

Na wysokości if'a:
screenshot-20190206093624.png

Włączy się program. I taka treść błędu, gdy wyłaczymy:

Traceback (most recent call last):
File "C:\Program Files\JetBrains\PyCharm Community Edition 2018.3.3\helpers\pydev\pydevd.py", line 1741, in <module>
main()
File "C:\Program Files\JetBrains\PyCharm Community Edition 2018.3.3\helpers\pydev\pydevd.py", line 1735, in main
globals = debugger.run(setup['file'], None, None, is_module)
File "C:\Program Files\JetBrains\PyCharm Community Edition 2018.3.3\helpers\pydev\pydevd.py", line 1135, in run
pydev_imports.execfile(file, globals, locals) # execute the script
File "C:/Users/lenovo/Desktop/Tuner_Gitarowy/dzialajacy.py", line 91, in <module>
txt = tkinter.scrolledtext.ScrolledText(window1, width=60, height=53)
File "C:\Python27\Lib\lib-tk\ScrolledText.py", line 21, in init
self.frame = Frame(master)
File "C:\Python27\Lib\lib-tk\Tkinter.py", line 2574, in init
Widget.init(self, master, 'frame', cnf, {}, extra)
File "C:\Python27\Lib\lib-tk\Tkinter.py", line 2095, in init
(widgetName, self._w) + extra + self._options(cnf))
_tkinter.TclError: can't invoke "frame" command: application has been destroyed

0
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import numpy as np
import pyaudio
from tkinter import scrolledtext
from tkinter import *
from PIL import ImageTk, Image

class Okieneczko():

	window1 = Tk()
	window1.title('Tuner Gitarowy')
	window1.geometry('1380x855')

	img = ImageTk.PhotoImage(Image.open('z_gitara.png'))
	window1 = Label(window1, background='NavajoWhite3', image=img)
	window1.pack(side='right', fill='both', expand='yes')

	txt = scrolledtext.ScrolledText(window1, width=60, height=53)
	txt.grid(column=0, row=1)

	def operacja(self, txt):
		FSAMP = 22050  # czestotliwosc probkowania w Hz
		ROZMIAR_PROB = 2048  # ilosc probek
		KLATEK_NA_FFT = 16  # ilosc klatek zajmujacych srednio przez szybka transformate fouriera
		NOTKA_MIN = 40  # E2
		NOTKA_MAX = 64  # E4

		# dla wyswietlenia nazw dzwieku
		NOTACJA = 'E F F# G G# A A# B C C# D D#'.split()

		# nowe dzwieki
		PROBKI_NA_FFT = ROZMIAR_PROB * KLATEK_NA_FFT
		KROK_CZESTOTLIWOSCI = float(FSAMP) / PROBKI_NA_FFT

		def nazwa_notki(n):
			return NOTACJA[n % NOTKA_MIN % len(NOTACJA)] + str(int(n / 12 - 1))

		def czestotliwosc_na_numer(f):
			return 64 + 12 * np.log2(f / 329.63)

		def numer_na_czestotliwosc(n):
			return 329.63 * 2.0 ** ((n - 64) / 12.0)

		# pobranie minumalnego\maksymalnego nr indeksu z szybkiej transformaty fouriera
		def notka_do_fftbin(n):
			return numer_na_czestotliwosc(n) / KROK_CZESTOTLIWOSCI

		imin = max(0, int(np.floor(notka_do_fftbin(NOTKA_MIN - 1))))
		imax = min(PROBKI_NA_FFT, int(np.ceil(notka_do_fftbin(NOTKA_MAX + 1))))

		# Przydzial przestrzeni aby uruchomic szybka transformate fouriera
		buf = np.zeros(PROBKI_NA_FFT, dtype=np.float32)
		numer_klatki = 0

		# inicjalizacja dzwieku
		stream = pyaudio.PyAudio().open(format=pyaudio.paInt16, channels=1, rate=FSAMP, input=True, frames_per_buffer=ROZMIAR_PROB)
		stream.start_stream()

		# tworzenie funkcji Hanninga
		window = 0.5 * (1 - np.cos(np.linspace(0, 2 * np.pi, PROBKI_NA_FFT, False)))

		# wypisanie poczatkowego tekstu
		print('pobieranie probek w:', FSAMP, 'Hz z maksymalna rozdzielczoscia', KROK_CZESTOTLIWOSCI, 'Hz')


		# otrzymywane dane w czasie:
		while stream.is_active(txt):
			# przesuwanie bufora i wprowadzenie nowych danych
			buf[:-ROZMIAR_PROB] = buf[ROZMIAR_PROB:]
			buf[-ROZMIAR_PROB:] = np.fromstring(stream.read(ROZMIAR_PROB), np.int16)

			# Uruchom szybka transformate fouriera na okiennym buforze
			fft = np.fft.rfft(buf * window)

			# pobierz czestotliwosc maksymalnej wartosci z zakresu
			czestotliwosc = (np.abs(fft[imin:imax]).argmax() + imin) * KROK_CZESTOTLIWOSCI

			# pobierz numer notatki i najblizsza notatke
			n = czestotliwosc_na_numer(czestotliwosc)
			n0 = int(round(n))

			# dane wyjsciowe konsoli, gdy mamy pelny bufor
			numer_klatki += 1
			txt.insert(INSERT, 'Numer: {:7.2f}     Wysokosc: {:7.2f} Hz     Nota: {:>3s} {:+.2f}'.format(n, czestotliwosc, nazwa_notki(n0), n - n0))

	window1.mainloop()

Zrefaktoryzowałem maksymalnie, jak się dało. If był zbędny.
Włącza się, nie ma błędów, ale nie printuje wewnątrz okna tkinter tych wyników, dlaczego?

1 użytkowników online, w tym zalogowanych: 0, gości: 1