Tôi có phải lọc toàn bộ (hoặc ít nhất một chút rất lớn) tín hiệu mỗi khi có một vài mẫu mới xuất hiện hoặc có cách nào (như DFT trượt) trong đó có thể xác định hiệu quả phần mới của bộ lọc tín hiệu?
Các bộ lọc kỹ thuật số không hoạt động như vậy - về cơ bản, FIR hoặc IIR cổ điển có thể hoạt động trên mọi mẫu mới . Bạn thực sự nên đọc về những bộ lọc này là gì và cách mọi người mô hình hóa chúng.
Tôi muốn sử dụng bộ lọc butterworth
Vâng, có rất nhiều triển khai đó,
Tôi hiện đang sử dụng bơ và lfilter của scipy
trong đó bạn đã biết một!
Bây giờ, bộ lọc butterworth là một thứ đệ quy, vì vậy để tính phần tiếp theo của tín hiệu được lấy mẫu của bạn, bạn sẽ cần trạng thái cuối cùng. Đó chính xác là "trạng thái trễ của bộ lọc zi" lfiltertrả về và có thể thực hiện cuộc gọi tiếp theo dưới dạng zitham số.
nhưng tôi không biết làm thế nào để sử dụng nó để có được tín hiệu liên tục.
Tôi nghĩ bạn có nghĩa là "để đạt được lọc liên tục".
Bây giờ, điều đó đang được nói, vấn đề là bạn đang tự thiết lập để viết kiến trúc phát trực tuyến của riêng bạn. Tôi sẽ không làm điều đó. Sử dụng một khung hiện có. Ví dụ, có GNU Radio, cho phép bạn xác định biểu đồ luồng xử lý tín hiệu trong Python và cũng là đa luồng, sử dụng các triển khai thuật toán được tối ưu hóa cao, có nhiều phương tiện đầu vào và đầu ra, đi kèm với một thư viện khối xử lý tín hiệu khổng lồ , có thể được viết bằng Python hoặc C ++, nếu bạn cần phải làm điều đó.
Ví dụ: biểu đồ luồng lấy mẫu từ card âm thanh, butterworth lọc chúng và ghi chúng vào tệp là:
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
##################################################
# GNU Radio Python Flow Graph
# Title: Butterworth Test
# Generated: Mon Feb 8 16:17:18 2016
##################################################
from gnuradio import audio
from gnuradio import blocks
from gnuradio import eng_notation
from gnuradio import filter
from gnuradio import gr
from gnuradio.eng_option import eng_option
from gnuradio.filter import firdes
from optparse import OptionParser
class butterworth_test(gr.top_block):
def __init__(self):
gr.top_block.__init__(self, "Butterworth Test")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 48000
##################################################
# Blocks
##################################################
# taps from scipy.butter!
self.iir_filter_xxx_0 = filter.iir_filter_ffd(([1.0952627450621233e-05, 0.00013143152940745496, 0.0007228734117410033, 0.0024095780391366808, 0.005421550588057537, 0.008674480940892064, 0.010120227764374086, 0.008674480940892081, 0.005421550588057554, 0.0024095780391366955, 0.0007228734117410089, 0.00013143152940745594, 1.0952627450621367e-05]), ([1.0, -4.4363862740719835, 10.215121830052535, -15.374408118154847, 16.57333784740102, -13.325056987818655, 8.133543488903097, -3.77641064765334, 1.3181452681671835, -0.3361758629961047, 0.05930166356243964, -0.0064815521348275, 0.00033130678123743994]), False)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*1, "", False)
self.blocks_file_sink_0.set_unbuffered(False)
self.audio_source_0 = audio.source(samp_rate, "", True)
##################################################
# Connections
##################################################
self.connect((self.audio_source_0, 0), (self.iir_filter_xxx_0, 0))
self.connect((self.iir_filter_xxx_0, 0), (self.blocks_file_sink_0, 0))
def main(top_block_cls=butterworth_test, options=None):
tb = top_block_cls()
tb.start()
try:
raw_input('Press Enter to quit: ')
except EOFError:
pass
tb.stop()
tb.wait()
if __name__ == '__main__':
main()
Lưu ý rằng mã này được tạo tự động từ biểu đồ luồng đồ họa mà tôi vừa nhấp vào bằng gnuradio-companionchương trình:
Nếu bạn muốn biết thêm về cách triển khai biểu đồ luồng xử lý tín hiệu trong Python, hãy tìm Hướng dẫn có hướng dẫn của Radio Radio .
EDIT : Tôi thích câu trả lời của @ Fat32 khá nhiều! Những gì ông mô tả là một kiến trúc bộ đệm đôi khá gần với những gì GNU Radio làm:
Một khối ngược dòng tạo ra các mẫu trong các khối mẫu có kích thước tùy ý, ghi chúng vào bộ đệm vòng đầu ra (được biểu thị như một mũi tên trong hình trên) và thông báo cho các khối xuôi dòng của nó có dữ liệu mới.
Khối hạ lưu được thông báo, kiểm tra xem có đủ không gian trong bộ đệm đầu ra để xử lý các mẫu trong bộ đệm vòng đầu vào của nó không (giống như bộ đệm đầu ra của khối ngược dòng), xử lý các mẫu này. Khi kết thúc, nó thông báo cho (các) khối ngược dòng rằng nó đã sử dụng hết bộ đệm vòng đầu vào (sau đó có thể được các khối ngược dòng sử dụng làm đầu ra) và các khối hạ lưu về các mẫu mới có sẵn.
Bây giờ, GNU Radio là đa luồng, khối ngược dòng có thể đã tạo ra các mẫu một lần nữa; trong một ứng dụng GNU Radio bình thường, gần như tất cả các khối đều "hoạt động" đồng thời và mọi thứ có quy mô khá tốt trên các máy đa CPU.
Vì vậy, công việc chính của GNU Radio là cung cấp cho bạn cơ sở hạ tầng bộ đệm này, thông báo và quản lý luồng, API khối xử lý tín hiệu rõ ràng và một cái gì đó để xác định cách mọi thứ được kết nối, vì vậy bạn không phải viết những gì Fat32 mô tả trong anh ấy / anh ấy tự đăng bài! Lưu ý rằng thực hiện việc sắp xếp luồng mẫu không dễ thực hiện đúng cách và GNU Radio sẽ loại bỏ độ cứng của nó và cho phép bạn tập trung vào những gì bạn muốn làm: DSP.