MATLAB vs Python để xử lý tín hiệu

Lưu ý của tác giả. Bài viết này ban đầu được gọi là Những cuộc phiêu lưu trong xử lý tín hiệu với Python (MATLAB? Chúng tôi không cần MATLAB bốc mùi. ) — sự ám chỉ đến Kho báu của Sierra Madre đã bị xóa, để tôn trọng việc trở thành hàng xóm tốt của The MathWorks. Mặc dù tôi không giấu giếm việc mình không thích nhiều khía cạnh của MATLAB — mà tôi sẽ đề cập ở phần sau của bài viết này — nhưng tôi hy vọng họ có thể cải thiện phần mềm của mình và giảm giá thành. Xin lưu ý rằng điều này thể hiện quan điểm của riêng tôi và không phản ánh quan điểm của chủ lao động của tôi hoặc của nhà xuất bản trang web này

OK, bây giờ quay lại một số chủ đề thực tế sau trò giải trí triết học cuối cùng đó. Bài đăng này sẽ là một chuyến tham quan ngắn về PyLab và là bàn đạp cho một số chủ đề khác - bao gồm cả phần tiếp theo được chờ đợi từ lâu để ước tính tốc độ bộ mã hóa

Tại nơi làm việc, chúng tôi sử dụng MATLAB làm phần mềm phân tích và hiển thị dữ liệu. Nhưng nhóm của tôi chỉ có nó trên một máy tính xách tay dùng chung. Và tôi mệt mỏi vì phải chia sẻ. . –) Vì vậy, tôi bắt đầu xem xét các lựa chọn thay thế

Scilab, Octave, Sage… tất cả đều không ổn định và dường như không có các tính năng và sự phong phú mà tôi muốn. Sau đó, tôi phát hiện ra PyLab

PyLab là một môi trường Python để tính toán khoa học bao gồm các gói sau

• matplotlib để vẽ đồ thị và trực quan hóa dữ liệu
• numpy để phân tích số cơ bản (vectơ, ma trận và các hàm khoa học hoạt động trên chúng)
• scipy cho các ứng dụng khoa học và kỹ thuật

Đợi một chút - đây là một blog hệ thống nhúng, phải không?. Python sẽ không chạy trên hệ thống nhúng bị giới hạn tài nguyên và trên thực tế, Python là một trong ba tiêu chí của tôi…

Dấu hiệu bạn không làm việc trên một hệ thống nhúng có tài nguyên hạn chế

1. Bạn có một hệ điều hành với trình bao lệnh
2. Bạn có thể chạy Python
3. Có một trình biên dịch chạy trên hệ thống của bạn, vì vậy bạn không cần một trình biên dịch chéo

Vì vậy, nếu bạn đang sử dụng Python, bạn không thực sự phát triển hệ thống nhúng. Nhưng nó ổn. Bởi vì bạn cần mở rộng tầm nhìn của mình. Đừng là một con ngựa một mánh và bị mắc kẹt trong C và phát triển lắp ráp cho bộ xử lý yêu thích của bạn mà bạn chọn

Dù sao đi nữa, có rất nhiều lúc tôi phải ngừng lập trình và thử lý thuyết về một ý tưởng nào đó mà tôi có. Và gần đây PyLab đã giúp ích rất nhiều

Dưới đây là một số ví dụ về những gì nó có thể làm. Nhưng trước tiên, một lời cảnh báo

Chúng ta cần MATLAB bốc mùi?

Tôi cần làm rõ rằng bài đăng này dành cho các kỹ sư (đặc biệt là các nhà phát triển hệ thống nhúng), những người có công việc xử lý tín hiệu, phân tích dữ liệu và trực quan hóa như một phần phụ trong công việc của họ

Đối với những bạn đang thiết kế hệ thống điều khiển hoặc xử lý tín hiệu chuyên sâu, toàn thời gian, MATLAB có lẽ là công cụ phù hợp cho công việc. Nếu công ty của bạn có thể trả cho bạn 40 giờ một tuần, họ cũng có thể trả cho MATLAB

Nếu chi phí không phải là vấn đề, thì tôi thích sử dụng MATLAB và tôi sẽ nhận được tất cả các hộp công cụ có thể

Tôi cũng sẽ không thảo luận sâu về các thuật toán hệ thống điều khiển hoặc xử lý tín hiệu (biến đổi z, FFT, sơ đồ quỹ tích nghiệm, biểu đồ Nichols, v.v. ). Và tôi sẽ không nói cho bạn biết hướng dẫn từng bước để sử dụng Python và PyLab. Đây chỉ đơn thuần là một chuyến tham quan PyLab để khơi gợi sự quan tâm của bạn

ứng dụng ví dụ

Giả sử bạn cần hiểu dòng điện gợn trong cầu H có tải cảm ứng, trong điều chế độ rộng xung được căn chỉnh theo cạnh và căn giữa

Đây là một số biểu đồ của dòng điện gợn, cùng với một đoạn mã Python ngắn mà tôi đã sử dụng để tạo ra chúng

PWM căn chỉnh cạnh.

PWM căn giữa.

import matplotlib.pyplot as plt
import numpy
import scipy.integrate

t = numpy.arange(0,4,0.001)

# duty cycle on phase A and B
Da = 0.70
Db = 0.40

def extendrange(ra,rb):
  if ra is None:
    return rb
  elif rb is None:
    return ra
  else:
    return (min(ra[0],rb[0]),max(ra[1],rb[1]))

def createLimits(margin, *args):
    r = None
    for x in args:
        r = extendrange(r, (numpy.min(x),numpy.max(x)))
    rmargin = (r[1]-r[0])*margin/2.0
    return (r[0]-rmargin,r[1]+rmargin)

def showripple(centeralign=False):
    # voltage waveforms on phases A and B

    if centeralign:
      sawtooth = abs(2*(t % 1) - 1)
      Va = sawtooth < Da
      Vb = sawtooth < Db
    else:
      ramp = t % 1
      Va = ramp < Da
      Vb = ramp < Db

    Vab = Va - Vb

    def ripple(x,t):
      T = t[-1]-t[0]
      meanval = numpy.mean(x)
      # cumtrapz produces a vector of length N-1
      # so we need to add one element back in
      return numpy.append([0],scipy.integrate.cumtrapz(x - meanval,t))

    Iab = ripple(Vab, t)

    # plot results
    margin = 0.1
    fig = plt.figure(figsize=(8, 6), dpi=80)
    ax = fig.add_subplot(3,1,1)
    y = [Va*0.8, Vb*0.8+1]
    ax.plot(t,y[0],t,y[1])
    ax.set_yticks([0.4,1.4])
    ax.set_yticklabels(['A','B'])
    ax.set_ylim(createLimits(margin,y[0],y[1]))
    ax.set_ylabel('Phase duty cycles')

    ax = fig.add_subplot(3,1,2)
    ax.plot(t,Vab)
    ax.set_ylim(createLimits(margin,Vab))
    ax.set_ylabel('Load voltage')

    ax = fig.add_subplot(3,1,3)
    ax.plot(t,Iab)
    ax.set_ylim(createLimits(margin,Iab))
    ax.set_ylabel('Ripple current')
    savefile = 'pwm-%s-1.png' % ('center' if centeralign else 'edge')
    fig.savefig(savefile, dpi=fig.dpi)

showripple(centeralign=False)
showripple(centeralign=True)
plt.show()

Hoặc so sánh 2 bộ lọc RC 2 tầng, một có RC giống hệt nhau và một có trở kháng ở tầng 2 tăng 10 để giảm tải (chú ý. sơ đồ bên dưới không phải từ Python mà được vẽ thủ công trong CircuitLab)

Một lần nữa, đây là mã nguồn ngắn

import matplotlib.pyplot as plt
import numpy
import itertools

# array version of the zip() function
def azip(*args):
  iters = [iter(arg) for arg in args]
  for i in itertools.count():
    yield tuple([it.next() for it in iters])      

# special case for 2 args
def azip2(a1,a2):
  it1 = iter(a1)
  it2 = iter(a2)
  for i in itertools.count():
    yield (it1.next(), it2.next())      

def rcfilt(t,Vin,R,C):
  N = len(C)
  Vc = [0]*N
  tprev = None
  for (tj,Vj) in azip2(t,Vin):
    if tprev is not None:
      I = [(Vj-Vc[0])/R[0]] + [(Vc[k-1]-Vc[k])/R[k] for k in range(1,N)] + [0]
      dt = tj - tprev
      for k in range(N):
        Vc[k] += (I[k]-I[k+1])/C[k]*dt
    tprev = tj
    yield numpy.array(Vc)


# 0-100 microseconds
t = numpy.arange(0,100,0.1)*1e-6
tus = t*1e6
Vin = (tus >= 10) * 1.0

# R1 = 1kohm,  C1 = 10nF
# R2 = 10kohm, C2 = 1nF
R = [1000, 10000]
C = [10e-9, 1e-9]
Vc_a = numpy.array(list(rcfilt(t,Vin,R,C)))

R = [1000, 1000]
C = [10e-9, 10e-9]
Vc_b = numpy.array(list(rcfilt(t,Vin,R,C)))

fig = plt.figure(figsize=[8,6], dpi=80)
ylabels = ['Vc_a', 'Vc_b']
for (k,Vc) in enumerate([Vc_a,Vc_b]):
    ax = fig.add_subplot(3,1,k+1)
    ax.plot(tus,Vin,tus,Vc)
    ax.legend(['Vin','Vc1','Vc2'])
    ax.set_ylabel(ylabels[k])
    ax.grid('on')

ax = fig.add_subplot(3,1,3)
ax.plot(tus,Vc_a[:,-1],tus,Vc_b[:,-1])
ax.legend(['Vc2_a','Vc2_b'])
ax.set_ylabel('Vc2')
ax.grid('on')

fig.suptitle('2-pole RC filters: Vc_a = 1K,10nF,10K,1nF; Vc_b = 1K,10nF,1K,10nF')
fig.savefig('rcfilt1.png',dpi=fig.dpi)
plt.show()  

Hoặc sử dụng gói đại số ký hiệu sympy cho Python để tính giá trị bình phương trung bình của một đoạn tuyến tính theo từng đoạn

from sympy import *
x0,x1,y0,y1,m,h = symbols('x0 x1 y0 y1 m h')
simplify(integrate((m*(x-x0)+y0)**2,(x,x0,x0+h)).subs(m,(y1-y0)/h))

Bạn thậm chí có thể tự mình thử điều này trên máy chủ SymPy Live

Cài đặt

Việc cài đặt Python cốt lõi khá dễ dàng; . tổ chức. Mọi thứ trở nên phức tạp hơn một chút nếu bạn muốn cài đặt các thư viện scipy/numpy/matplotlib mà không phụ thuộc vào việc cài đặt đúng môi trường trình biên dịch

Có một số giải pháp tốt được liệt kê trên scipy. trang web tổ chức; . Tôi không có kinh nghiệm sử dụng Linux nên hãy kiểm tra scipy. trang tổ chức

các cửa sổ

Có ba phiên bản đóng gói sẵn miễn phí của PyLab mà tôi đã sử dụng

PortablePython có thời gian cài đặt/chạy đáng tin cậy nhất. PythonXY có bộ tính năng lớn nhất (và kích thước cài đặt lớn nhất). Enth think Canopy rất đẹp;

Ngoài ra còn có Anaconda, mà tôi mới bắt đầu sử dụng trên Mac OSX, nhưng chưa thử trên Windows

Mac OS X

Tôi đang chạy Snow Leopard (OSX 10. 6) trên máy Mac của tôi ở nhà. Tôi chưa tìm thấy giải pháp tuyệt vời nào cho PyLab nhưng tôi đang nghiên cứu nó

Cài đặt miễn phí dễ dàng nhất cho PyLab dường như là Anaconda. từ Phân tích liên tục. Quá trình cài đặt rất dễ dàng và nó hoạt động bình thường… ngoại trừ việc tôi nhận được một số cảnh báo về việc cấp phát bộ nhớ khi chạy các tập lệnh mà tôi đã viết cho bài đăng này (tuy nhiên, các tập lệnh đã hoạt động bình thường) và khi tôi chạy bản cài đặt Python thông thường của mình, . ừm. Hy vọng rằng những nút thắt này sẽ được giải quyết;

Quy trình phần mềm miễn phí thông thường trên máy Mac sử dụng trình quản lý gói như fink hoặc MacPorts;

Enth think Canopy cũng có các phiên bản OSX và Linux, nhưng tôi chưa dùng thử

Cũng có thể sử dụng các tệp nhị phân được biên dịch sẵn cho các gói khác nhau. Mặc dù Python được cài đặt sẵn trên máy Mac nhưng hãy đảm bảo rằng phiên bản Python của bạn tương thích với các thư viện bạn cài đặt. Tôi cũng khuyên bạn nên cài đặt phiên bản cập nhật của Python. Ở mức tối thiểu, đây là những gì bạn cần

MATLAB so với. con trăn

Lý do nên sử dụng MATLAB

• Đó là phần mềm được đánh giá cao, vượt lên trên các đối thủ cạnh tranh khác
• Simulink không có lựa chọn thay thế thực sự
• Nó có phép toán ma trận nhanh, trình sửa lỗi tốt và cú pháp đặc biệt để hỗ trợ phân tích số
  • lát mảng.

    import matplotlib.pyplot as plt
    import numpy
    import itertools
    
    # array version of the zip() function
    def azip(*args):
      iters = [iter(arg) for arg in args]
      for i in itertools.count():
        yield tuple([it.next() for it in iters])      
    
    # special case for 2 args
    def azip2(a1,a2):
      it1 = iter(a1)
      it2 = iter(a2)
      for i in itertools.count():
        yield (it1.next(), it2.next())      
    
    def rcfilt(t,Vin,R,C):
      N = len(C)
      Vc = [0]*N
      tprev = None
      for (tj,Vj) in azip2(t,Vin):
        if tprev is not None:
          I = [(Vj-Vc[0])/R[0]] + [(Vc[k-1]-Vc[k])/R[k] for k in range(1,N)] + [0]
          dt = tj - tprev
          for k in range(N):
            Vc[k] += (I[k]-I[k+1])/C[k]*dt
        tprev = tj
        yield numpy.array(Vc)
    
    
    # 0-100 microseconds
    t = numpy.arange(0,100,0.1)*1e-6
    tus = t*1e6
    Vin = (tus >= 10) * 1.0
    
    # R1 = 1kohm,  C1 = 10nF
    # R2 = 10kohm, C2 = 1nF
    R = [1000, 10000]
    C = [10e-9, 1e-9]
    Vc_a = numpy.array(list(rcfilt(t,Vin,R,C)))
    
    R = [1000, 1000]
    C = [10e-9, 10e-9]
    Vc_b = numpy.array(list(rcfilt(t,Vin,R,C)))
    
    fig = plt.figure(figsize=[8,6], dpi=80)
    ylabels = ['Vc_a', 'Vc_b']
    for (k,Vc) in enumerate([Vc_a,Vc_b]):
        ax = fig.add_subplot(3,1,k+1)
        ax.plot(tus,Vin,tus,Vc)
        ax.legend(['Vin','Vc1','Vc2'])
        ax.set_ylabel(ylabels[k])
        ax.grid('on')
    
    ax = fig.add_subplot(3,1,3)
    ax.plot(tus,Vc_a[:,-1],tus,Vc_b[:,-1])
    ax.legend(['Vc2_a','Vc2_b'])
    ax.set_ylabel('Vc2')
    ax.grid('on')
    
    fig.suptitle('2-pole RC filters: Vc_a = 1K,10nF,10K,1nF; Vc_b = 1K,10nF,1K,10nF')
    fig.savefig('rcfilt1.png',dpi=fig.dpi)
    plt.show()  
    

    5
  • tạo trình tự.

    import matplotlib.pyplot as plt
    import numpy
    import itertools
    
    # array version of the zip() function
    def azip(*args):
      iters = [iter(arg) for arg in args]
      for i in itertools.count():
        yield tuple([it.next() for it in iters])      
    
    # special case for 2 args
    def azip2(a1,a2):
      it1 = iter(a1)
      it2 = iter(a2)
      for i in itertools.count():
        yield (it1.next(), it2.next())      
    
    def rcfilt(t,Vin,R,C):
      N = len(C)
      Vc = [0]*N
      tprev = None
      for (tj,Vj) in azip2(t,Vin):
        if tprev is not None:
          I = [(Vj-Vc[0])/R[0]] + [(Vc[k-1]-Vc[k])/R[k] for k in range(1,N)] + [0]
          dt = tj - tprev
          for k in range(N):
            Vc[k] += (I[k]-I[k+1])/C[k]*dt
        tprev = tj
        yield numpy.array(Vc)
    
    
    # 0-100 microseconds
    t = numpy.arange(0,100,0.1)*1e-6
    tus = t*1e6
    Vin = (tus >= 10) * 1.0
    
    # R1 = 1kohm,  C1 = 10nF
    # R2 = 10kohm, C2 = 1nF
    R = [1000, 10000]
    C = [10e-9, 1e-9]
    Vc_a = numpy.array(list(rcfilt(t,Vin,R,C)))
    
    R = [1000, 1000]
    C = [10e-9, 10e-9]
    Vc_b = numpy.array(list(rcfilt(t,Vin,R,C)))
    
    fig = plt.figure(figsize=[8,6], dpi=80)
    ylabels = ['Vc_a', 'Vc_b']
    for (k,Vc) in enumerate([Vc_a,Vc_b]):
        ax = fig.add_subplot(3,1,k+1)
        ax.plot(tus,Vin,tus,Vc)
        ax.legend(['Vin','Vc1','Vc2'])
        ax.set_ylabel(ylabels[k])
        ax.grid('on')
    
    ax = fig.add_subplot(3,1,3)
    ax.plot(tus,Vc_a[:,-1],tus,Vc_b[:,-1])
    ax.legend(['Vc2_a','Vc2_b'])
    ax.set_ylabel('Vc2')
    ax.grid('on')
    
    fig.suptitle('2-pole RC filters: Vc_a = 1K,10nF,10K,1nF; Vc_b = 1K,10nF,1K,10nF')
    fig.savefig('rcfilt1.png',dpi=fig.dpi)
    plt.show()  
    

    6
  • nối mảng.

    import matplotlib.pyplot as plt
    import numpy
    import itertools
    
    # array version of the zip() function
    def azip(*args):
      iters = [iter(arg) for arg in args]
      for i in itertools.count():
        yield tuple([it.next() for it in iters])      
    
    # special case for 2 args
    def azip2(a1,a2):
      it1 = iter(a1)
      it2 = iter(a2)
      for i in itertools.count():
        yield (it1.next(), it2.next())      
    
    def rcfilt(t,Vin,R,C):
      N = len(C)
      Vc = [0]*N
      tprev = None
      for (tj,Vj) in azip2(t,Vin):
        if tprev is not None:
          I = [(Vj-Vc[0])/R[0]] + [(Vc[k-1]-Vc[k])/R[k] for k in range(1,N)] + [0]
          dt = tj - tprev
          for k in range(N):
            Vc[k] += (I[k]-I[k+1])/C[k]*dt
        tprev = tj
        yield numpy.array(Vc)
    
    
    # 0-100 microseconds
    t = numpy.arange(0,100,0.1)*1e-6
    tus = t*1e6
    Vin = (tus >= 10) * 1.0
    
    # R1 = 1kohm,  C1 = 10nF
    # R2 = 10kohm, C2 = 1nF
    R = [1000, 10000]
    C = [10e-9, 1e-9]
    Vc_a = numpy.array(list(rcfilt(t,Vin,R,C)))
    
    R = [1000, 1000]
    C = [10e-9, 10e-9]
    Vc_b = numpy.array(list(rcfilt(t,Vin,R,C)))
    
    fig = plt.figure(figsize=[8,6], dpi=80)
    ylabels = ['Vc_a', 'Vc_b']
    for (k,Vc) in enumerate([Vc_a,Vc_b]):
        ax = fig.add_subplot(3,1,k+1)
        ax.plot(tus,Vin,tus,Vc)
        ax.legend(['Vin','Vc1','Vc2'])
        ax.set_ylabel(ylabels[k])
        ax.grid('on')
    
    ax = fig.add_subplot(3,1,3)
    ax.plot(tus,Vc_a[:,-1],tus,Vc_b[:,-1])
    ax.legend(['Vc2_a','Vc2_b'])
    ax.set_ylabel('Vc2')
    ax.grid('on')
    
    fig.suptitle('2-pole RC filters: Vc_a = 1K,10nF,10K,1nF; Vc_b = 1K,10nF,1K,10nF')
    fig.savefig('rcfilt1.png',dpi=fig.dpi)
    plt.show()  
    

    7
• Các công cụ GUI như SPTool (để hiển thị và lọc tín hiệu chung) hoặc FDATool (để thiết kế bộ lọc kỹ thuật số)
• Đối với thiết kế hệ thống điều khiển và xử lý tín hiệu cấp chuyên nghiệp chất lượng cao

Lý do không sử dụng MATLAB

• Nó đắt đối với giấy phép cá nhân. Một bản sao của MATLAB cốt lõi là US\$2150 tại thời điểm viết bài này. Điều đó không quá tệ trong môi trường doanh nghiệp, nhưng nhân số đó với số người cần sử dụng nó, và tất cả các hộp công cụ khác của họ đều được bán theo kiểu gọi món
• Nó đắt đối với giấy phép nhóm. Phiên bản MATLAB được cấp phép mạng hoặc bất kỳ hộp công cụ nào của nó có giá gấp 4 lần giấy phép cho một PC riêng lẻ. Tôi không thể nói rằng tôi đã từng thấy một chiếc cưa vòng hoặc máy tiện được rao bán với hai mức giá, một loại dành cho cá nhân sử dụng và một loại có giá gấp 4 lần nếu bạn muốn chia sẻ với nhiều người. Tại công ty cũ của tôi, chúng tôi có 7 giấy phép mạng của MATLAB, với khoảng 40 người sử dụng nó trong nhiều dịp khác nhau — vì vậy đối với chương trình MATLAB cốt lõi, nó đáng giá, nhưng các hộp công cụ hiếm khi được sử dụng, vì vậy chúng tôi không thể biện minh cho việc mua . Tôi rất thích có thể sử dụng trình biên dịch Matlab, nhưng giấy phép mạng quá đắt. Các chương trình phần mềm khác cung cấp giấy phép mạng với số nhân trong 1. 25-2. 0, để biện minh cho sự tiện lợi bổ sung của việc có thể chia sẻ nó với nhiều người miễn là họ không sử dụng giấy phép đồng thời, nhưng MathWorks là công ty duy nhất tôi từng thấy sử dụng hệ số nhân 4x
• Thật tốn kém khi mua các hộp công cụ chỉ để sử dụng một tính năng trong những trường hợp hiếm hoi. Vì vậy, bạn cần một số công cụ điều chỉnh đường cong hai hoặc ba lần một năm? . Tôi nghĩ điều làm tôi khó chịu nhất là thái độ của MathWorks đối với các hộp công cụ của họ. Họ dường như đối xử với khách hàng của mình như thể tất cả họ đều có hầu bao rủng rỉnh. Tất cả các hội thảo trên web và các buổi đào tạo của họ đều quảng cáo hộp công cụ - phần đó không sao, nhưng họ không bao giờ đưa ra chi phí trừ khi bạn hỏi họ và họ không đưa ra lời biện minh rằng nhân viên kỹ thuật có thể sử dụng với ban quản lý để sao lưu yêu cầu mua một . Và thường có những chức năng thông thường nằm trong các hộp công cụ thực sự nên có trong bản phân phối MATLAB cốt lõi. Đây là một ví dụ. chức năng

  import matplotlib.pyplot as plt
  import numpy
  import itertools
  
  # array version of the zip() function
  def azip(*args):
    iters = [iter(arg) for arg in args]
    for i in itertools.count():
      yield tuple([it.next() for it in iters])      
  
  # special case for 2 args
  def azip2(a1,a2):
    it1 = iter(a1)
    it2 = iter(a2)
    for i in itertools.count():
      yield (it1.next(), it2.next())      
  
  def rcfilt(t,Vin,R,C):
    N = len(C)
    Vc = [0]*N
    tprev = None
    for (tj,Vj) in azip2(t,Vin):
      if tprev is not None:
        I = [(Vj-Vc[0])/R[0]] + [(Vc[k-1]-Vc[k])/R[k] for k in range(1,N)] + [0]
        dt = tj - tprev
        for k in range(N):
          Vc[k] += (I[k]-I[k+1])/C[k]*dt
      tprev = tj
      yield numpy.array(Vc)
  
  
  # 0-100 microseconds
  t = numpy.arange(0,100,0.1)*1e-6
  tus = t*1e6
  Vin = (tus >= 10) * 1.0
  
  # R1 = 1kohm,  C1 = 10nF
  # R2 = 10kohm, C2 = 1nF
  R = [1000, 10000]
  C = [10e-9, 1e-9]
  Vc_a = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  R = [1000, 1000]
  C = [10e-9, 10e-9]
  Vc_b = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  fig = plt.figure(figsize=[8,6], dpi=80)
  ylabels = ['Vc_a', 'Vc_b']
  for (k,Vc) in enumerate([Vc_a,Vc_b]):
      ax = fig.add_subplot(3,1,k+1)
      ax.plot(tus,Vin,tus,Vc)
      ax.legend(['Vin','Vc1','Vc2'])
      ax.set_ylabel(ylabels[k])
      ax.grid('on')
  
  ax = fig.add_subplot(3,1,3)
  ax.plot(tus,Vc_a[:,-1],tus,Vc_b[:,-1])
  ax.legend(['Vc2_a','Vc2_b'])
  ax.set_ylabel('Vc2')
  ax.grid('on')
  
  fig.suptitle('2-pole RC filters: Vc_a = 1K,10nF,10K,1nF; Vc_b = 1K,10nF,1K,10nF')
  fig.savefig('rcfilt1.png',dpi=fig.dpi)
  plt.show()  
  

  8 nằm trong Hộp công cụ thống kê; . Nhưng nếu ai đó làm việc với bạn đưa

  import matplotlib.pyplot as plt
  import numpy
  import itertools
  
  # array version of the zip() function
  def azip(*args):
    iters = [iter(arg) for arg in args]
    for i in itertools.count():
      yield tuple([it.next() for it in iters])      
  
  # special case for 2 args
  def azip2(a1,a2):
    it1 = iter(a1)
    it2 = iter(a2)
    for i in itertools.count():
      yield (it1.next(), it2.next())      
  
  def rcfilt(t,Vin,R,C):
    N = len(C)
    Vc = [0]*N
    tprev = None
    for (tj,Vj) in azip2(t,Vin):
      if tprev is not None:
        I = [(Vj-Vc[0])/R[0]] + [(Vc[k-1]-Vc[k])/R[k] for k in range(1,N)] + [0]
        dt = tj - tprev
        for k in range(N):
          Vc[k] += (I[k]-I[k+1])/C[k]*dt
      tprev = tj
      yield numpy.array(Vc)
  
  
  # 0-100 microseconds
  t = numpy.arange(0,100,0.1)*1e-6
  tus = t*1e6
  Vin = (tus >= 10) * 1.0
  
  # R1 = 1kohm,  C1 = 10nF
  # R2 = 10kohm, C2 = 1nF
  R = [1000, 10000]
  C = [10e-9, 1e-9]
  Vc_a = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  R = [1000, 1000]
  C = [10e-9, 10e-9]
  Vc_b = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  fig = plt.figure(figsize=[8,6], dpi=80)
  ylabels = ['Vc_a', 'Vc_b']
  for (k,Vc) in enumerate([Vc_a,Vc_b]):
      ax = fig.add_subplot(3,1,k+1)
      ax.plot(tus,Vin,tus,Vc)
      ax.legend(['Vin','Vc1','Vc2'])
      ax.set_ylabel(ylabels[k])
      ax.grid('on')
  
  ax = fig.add_subplot(3,1,3)
  ax.plot(tus,Vc_a[:,-1],tus,Vc_b[:,-1])
  ax.legend(['Vc2_a','Vc2_b'])
  ax.set_ylabel('Vc2')
  ax.grid('on')
  
  fig.suptitle('2-pole RC filters: Vc_a = 1K,10nF,10K,1nF; Vc_b = 1K,10nF,1K,10nF')
  fig.savefig('rcfilt1.png',dpi=fig.dpi)
  plt.show()  
  

  8 vào tập lệnh của họ vì họ có giấy phép cho Hộp công cụ thống kê, thì bạn phải lấy Hộp công cụ thống kê hoặc viết lại tập lệnh của họ để sử dụng

  import matplotlib.pyplot as plt
  import numpy
  import itertools
  
  # array version of the zip() function
  def azip(*args):
    iters = [iter(arg) for arg in args]
    for i in itertools.count():
      yield tuple([it.next() for it in iters])      
  
  # special case for 2 args
  def azip2(a1,a2):
    it1 = iter(a1)
    it2 = iter(a2)
    for i in itertools.count():
      yield (it1.next(), it2.next())      
  
  def rcfilt(t,Vin,R,C):
    N = len(C)
    Vc = [0]*N
    tprev = None
    for (tj,Vj) in azip2(t,Vin):
      if tprev is not None:
        I = [(Vj-Vc[0])/R[0]] + [(Vc[k-1]-Vc[k])/R[k] for k in range(1,N)] + [0]
        dt = tj - tprev
        for k in range(N):
          Vc[k] += (I[k]-I[k+1])/C[k]*dt
      tprev = tj
      yield numpy.array(Vc)
  
  
  # 0-100 microseconds
  t = numpy.arange(0,100,0.1)*1e-6
  tus = t*1e6
  Vin = (tus >= 10) * 1.0
  
  # R1 = 1kohm,  C1 = 10nF
  # R2 = 10kohm, C2 = 1nF
  R = [1000, 10000]
  C = [10e-9, 1e-9]
  Vc_a = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  R = [1000, 1000]
  C = [10e-9, 10e-9]
  Vc_b = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  fig = plt.figure(figsize=[8,6], dpi=80)
  ylabels = ['Vc_a', 'Vc_b']
  for (k,Vc) in enumerate([Vc_a,Vc_b]):
      ax = fig.add_subplot(3,1,k+1)
      ax.plot(tus,Vin,tus,Vc)
      ax.legend(['Vin','Vc1','Vc2'])
      ax.set_ylabel(ylabels[k])
      ax.grid('on')
  
  ax = fig.add_subplot(3,1,3)
  ax.plot(tus,Vc_a[:,-1],tus,Vc_b[:,-1])
  ax.legend(['Vc2_a','Vc2_b'])
  ax.set_ylabel('Vc2')
  ax.grid('on')
  
  fig.suptitle('2-pole RC filters: Vc_a = 1K,10nF,10K,1nF; Vc_b = 1K,10nF,1K,10nF')
  fig.savefig('rcfilt1.png',dpi=fig.dpi)
  plt.show()  
  

  9
• Cú pháp đôi khi hơi kỳ quặc. Đánh số mảng bắt đầu từ 1. Bạn có các lựa chọn về tệp tập lệnh (. m) hoặc một hàm (. m) có hậu quả. Các tệp tập lệnh không thể có chức năng con và sửa đổi môi trường chung; . Nếu bạn quên kết thúc một dòng bằng dấu chấm phẩy, đó không phải là lỗi, nhưng trình thông dịch MATLAB sẽ in ra một giá trị và tôi không thể nói cho bạn biết tôi đã lãng phí 30 phút bao nhiêu lần để tìm ra chỗ thiếu sót chết tiệt đó. . strcmp() trả về 0 nếu không khớp và 1 nếu khớp, không tương thích với phiên bản C thông thường của strcmp() trả về -1,0,1 tùy thuộc vào chuỗi nào đầu tiên theo thứ tự. Tôi có thể tiếp tục nhưng tôi sẽ dừng lại
• Quản lý không gian tên hút. Bạn muốn giữ cho hệ thống điều khiển của mình đạt được lợi ích từ các mô hình Simulink (tương tự như giữ các hằng số được mã hóa cứng ra khỏi mã C và trong một. tập tin h)? . Bạn có thể hack lệnh

  import matplotlib.pyplot as plt
  import numpy
  import itertools
  
  # array version of the zip() function
  def azip(*args):
    iters = [iter(arg) for arg in args]
    for i in itertools.count():
      yield tuple([it.next() for it in iters])      
  
  # special case for 2 args
  def azip2(a1,a2):
    it1 = iter(a1)
    it2 = iter(a2)
    for i in itertools.count():
      yield (it1.next(), it2.next())      
  
  def rcfilt(t,Vin,R,C):
    N = len(C)
    Vc = [0]*N
    tprev = None
    for (tj,Vj) in azip2(t,Vin):
      if tprev is not None:
        I = [(Vj-Vc[0])/R[0]] + [(Vc[k-1]-Vc[k])/R[k] for k in range(1,N)] + [0]
        dt = tj - tprev
        for k in range(N):
          Vc[k] += (I[k]-I[k+1])/C[k]*dt
      tprev = tj
      yield numpy.array(Vc)
  
  
  # 0-100 microseconds
  t = numpy.arange(0,100,0.1)*1e-6
  tus = t*1e6
  Vin = (tus >= 10) * 1.0
  
  # R1 = 1kohm,  C1 = 10nF
  # R2 = 10kohm, C2 = 1nF
  R = [1000, 10000]
  C = [10e-9, 1e-9]
  Vc_a = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  R = [1000, 1000]
  C = [10e-9, 10e-9]
  Vc_b = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  fig = plt.figure(figsize=[8,6], dpi=80)
  ylabels = ['Vc_a', 'Vc_b']
  for (k,Vc) in enumerate([Vc_a,Vc_b]):
      ax = fig.add_subplot(3,1,k+1)
      ax.plot(tus,Vin,tus,Vc)
      ax.legend(['Vin','Vc1','Vc2'])
      ax.set_ylabel(ylabels[k])
      ax.grid('on')
  
  ax = fig.add_subplot(3,1,3)
  ax.plot(tus,Vc_a[:,-1],tus,Vc_b[:,-1])
  ax.legend(['Vc2_a','Vc2_b'])
  ax.set_ylabel('Vc2')
  ax.grid('on')
  
  fig.suptitle('2-pole RC filters: Vc_a = 1K,10nF,10K,1nF; Vc_b = 1K,10nF,1K,10nF')
  fig.savefig('rcfilt1.png',dpi=fig.dpi)
  plt.show()  
  

  1 để sử dụng không gian làm việc của chức năng gọi, nhưng nó khá khó và không tương thích với các tính năng khác của Simulink. Sẽ thật dễ dàng nếu MathWorks cho phép chuyển một cấu trúc làm đối số cho Simulink, được sử dụng làm nguồn cho tất cả các tra cứu hằng số được đặt tên và các khối “Từ không gian làm việc”. Than ôi, bạn không thể làm điều đó. Điều tương tự với các khối “To Workspace” trong Simulink, nó chỉ đưa kết quả vào không gian làm việc cấp cao nhất, ghi đè bất kỳ biến nào bạn có thể có cùng tên. MATLAB có chức năng

  import matplotlib.pyplot as plt
  import numpy
  import itertools
  
  # array version of the zip() function
  def azip(*args):
    iters = [iter(arg) for arg in args]
    for i in itertools.count():
      yield tuple([it.next() for it in iters])      
  
  # special case for 2 args
  def azip2(a1,a2):
    it1 = iter(a1)
    it2 = iter(a2)
    for i in itertools.count():
      yield (it1.next(), it2.next())      
  
  def rcfilt(t,Vin,R,C):
    N = len(C)
    Vc = [0]*N
    tprev = None
    for (tj,Vj) in azip2(t,Vin):
      if tprev is not None:
        I = [(Vj-Vc[0])/R[0]] + [(Vc[k-1]-Vc[k])/R[k] for k in range(1,N)] + [0]
        dt = tj - tprev
        for k in range(N):
          Vc[k] += (I[k]-I[k+1])/C[k]*dt
      tprev = tj
      yield numpy.array(Vc)
  
  
  # 0-100 microseconds
  t = numpy.arange(0,100,0.1)*1e-6
  tus = t*1e6
  Vin = (tus >= 10) * 1.0
  
  # R1 = 1kohm,  C1 = 10nF
  # R2 = 10kohm, C2 = 1nF
  R = [1000, 10000]
  C = [10e-9, 1e-9]
  Vc_a = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  R = [1000, 1000]
  C = [10e-9, 10e-9]
  Vc_b = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  fig = plt.figure(figsize=[8,6], dpi=80)
  ylabels = ['Vc_a', 'Vc_b']
  for (k,Vc) in enumerate([Vc_a,Vc_b]):
      ax = fig.add_subplot(3,1,k+1)
      ax.plot(tus,Vin,tus,Vc)
      ax.legend(['Vin','Vc1','Vc2'])
      ax.set_ylabel(ylabels[k])
      ax.grid('on')
  
  ax = fig.add_subplot(3,1,3)
  ax.plot(tus,Vc_a[:,-1],tus,Vc_b[:,-1])
  ax.legend(['Vc2_a','Vc2_b'])
  ax.set_ylabel('Vc2')
  ax.grid('on')
  
  fig.suptitle('2-pole RC filters: Vc_a = 1K,10nF,10K,1nF; Vc_b = 1K,10nF,1K,10nF')
  fig.savefig('rcfilt1.png',dpi=fig.dpi)
  plt.show()  
  

  2, nhưng nó chỉ có một số không gian làm việc được lựa chọn hạn chế và không có hỗ trợ không gian làm việc hạng nhất

Lý do nên sử dụng Python

• Đó là một ngôn ngữ đẹp, được sử dụng rộng rãi. Đánh số mảng bắt đầu từ 0, cú pháp ngôn ngữ được nghĩ ra tốt hơn nhiều, cũng như hệ thống lớp. Hệ thống mô-đun/đóng gói trong Python tốt hơn nhiều so với đường dẫn của MATLAB. Và tôi tình cờ thích các trình vòng lặp và trình tạo trong Python, không có trong MATLAB
• Matplotlib giống như tiện ích vẽ đồ thị của MATLAB, nhưng được cải tiến và dễ sử dụng hơn
• Bạn cũng nhận được tất cả các thư viện Python tiện lợi. Mở tệp, lặp qua thư mục, v.v. tất cả đều dễ dàng hơn
• Nếu bạn muốn có một môi trường giống như MATLAB, bạn có thể sử dụng trình bao IPython (Python tương tác), bao gồm các tiện ích như hoàn thành tab, gỡ lỗi khi có lỗi và “sổ ghi chép” để ghi lại quá trình khám phá của bạn
• Các thư viện numpy/scipy/pandas có thể so sánh với MATLAB cộng với một loạt các hộp công cụ. Chẳng hạn, gần đây tôi đã có thể làm việc với một số chức năng khớp khối-spline của scipy. Tôi sẽ không thể làm điều tương tự trong MATLAB trừ khi tôi có Hộp công cụ khớp đường cong
• Nó miễn phí

Những điều bạn từ bỏ khi sử dụng Python

Tất cả các vấn đề sau đây là do numpy là một thư viện bổ sung cho Python, so với. một tính năng hạng nhất của ngôn ngữ

• Các ký tự mảng không dễ dàng, bạn phải sử dụng

  import matplotlib.pyplot as plt
  import numpy
  import itertools
  
  # array version of the zip() function
  def azip(*args):
    iters = [iter(arg) for arg in args]
    for i in itertools.count():
      yield tuple([it.next() for it in iters])      
  
  # special case for 2 args
  def azip2(a1,a2):
    it1 = iter(a1)
    it2 = iter(a2)
    for i in itertools.count():
      yield (it1.next(), it2.next())      
  
  def rcfilt(t,Vin,R,C):
    N = len(C)
    Vc = [0]*N
    tprev = None
    for (tj,Vj) in azip2(t,Vin):
      if tprev is not None:
        I = [(Vj-Vc[0])/R[0]] + [(Vc[k-1]-Vc[k])/R[k] for k in range(1,N)] + [0]
        dt = tj - tprev
        for k in range(N):
          Vc[k] += (I[k]-I[k+1])/C[k]*dt
      tprev = tj
      yield numpy.array(Vc)
  
  
  # 0-100 microseconds
  t = numpy.arange(0,100,0.1)*1e-6
  tus = t*1e6
  Vin = (tus >= 10) * 1.0
  
  # R1 = 1kohm,  C1 = 10nF
  # R2 = 10kohm, C2 = 1nF
  R = [1000, 10000]
  C = [10e-9, 1e-9]
  Vc_a = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  R = [1000, 1000]
  C = [10e-9, 10e-9]
  Vc_b = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  fig = plt.figure(figsize=[8,6], dpi=80)
  ylabels = ['Vc_a', 'Vc_b']
  for (k,Vc) in enumerate([Vc_a,Vc_b]):
      ax = fig.add_subplot(3,1,k+1)
      ax.plot(tus,Vin,tus,Vc)
      ax.legend(['Vin','Vc1','Vc2'])
      ax.set_ylabel(ylabels[k])
      ax.grid('on')
  
  ax = fig.add_subplot(3,1,3)
  ax.plot(tus,Vc_a[:,-1],tus,Vc_b[:,-1])
  ax.legend(['Vc2_a','Vc2_b'])
  ax.set_ylabel('Vc2')
  ax.grid('on')
  
  fig.suptitle('2-pole RC filters: Vc_a = 1K,10nF,10K,1nF; Vc_b = 1K,10nF,1K,10nF')
  fig.savefig('rcfilt1.png',dpi=fig.dpi)
  plt.show()  
  

  3 thay vì

  import matplotlib.pyplot as plt
  import numpy
  import itertools
  
  # array version of the zip() function
  def azip(*args):
    iters = [iter(arg) for arg in args]
    for i in itertools.count():
      yield tuple([it.next() for it in iters])      
  
  # special case for 2 args
  def azip2(a1,a2):
    it1 = iter(a1)
    it2 = iter(a2)
    for i in itertools.count():
      yield (it1.next(), it2.next())      
  
  def rcfilt(t,Vin,R,C):
    N = len(C)
    Vc = [0]*N
    tprev = None
    for (tj,Vj) in azip2(t,Vin):
      if tprev is not None:
        I = [(Vj-Vc[0])/R[0]] + [(Vc[k-1]-Vc[k])/R[k] for k in range(1,N)] + [0]
        dt = tj - tprev
        for k in range(N):
          Vc[k] += (I[k]-I[k+1])/C[k]*dt
      tprev = tj
      yield numpy.array(Vc)
  
  
  # 0-100 microseconds
  t = numpy.arange(0,100,0.1)*1e-6
  tus = t*1e6
  Vin = (tus >= 10) * 1.0
  
  # R1 = 1kohm,  C1 = 10nF
  # R2 = 10kohm, C2 = 1nF
  R = [1000, 10000]
  C = [10e-9, 1e-9]
  Vc_a = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  R = [1000, 1000]
  C = [10e-9, 10e-9]
  Vc_b = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  fig = plt.figure(figsize=[8,6], dpi=80)
  ylabels = ['Vc_a', 'Vc_b']
  for (k,Vc) in enumerate([Vc_a,Vc_b]):
      ax = fig.add_subplot(3,1,k+1)
      ax.plot(tus,Vin,tus,Vc)
      ax.legend(['Vin','Vc1','Vc2'])
      ax.set_ylabel(ylabels[k])
      ax.grid('on')
  
  ax = fig.add_subplot(3,1,3)
  ax.plot(tus,Vc_a[:,-1],tus,Vc_b[:,-1])
  ax.legend(['Vc2_a','Vc2_b'])
  ax.set_ylabel('Vc2')
  ax.grid('on')
  
  fig.suptitle('2-pole RC filters: Vc_a = 1K,10nF,10K,1nF; Vc_b = 1K,10nF,1K,10nF')
  fig.savefig('rcfilt1.png',dpi=fig.dpi)
  plt.show()  
  

  4 nếu bạn muốn tính toán nhận biết ma trận đầy đủ
• Để hoạt động trên các mảng có nhiều mảng với các hàm cơ bản như

  import matplotlib.pyplot as plt
  import numpy
  import itertools
  
  # array version of the zip() function
  def azip(*args):
    iters = [iter(arg) for arg in args]
    for i in itertools.count():
      yield tuple([it.next() for it in iters])      
  
  # special case for 2 args
  def azip2(a1,a2):
    it1 = iter(a1)
    it2 = iter(a2)
    for i in itertools.count():
      yield (it1.next(), it2.next())      
  
  def rcfilt(t,Vin,R,C):
    N = len(C)
    Vc = [0]*N
    tprev = None
    for (tj,Vj) in azip2(t,Vin):
      if tprev is not None:
        I = [(Vj-Vc[0])/R[0]] + [(Vc[k-1]-Vc[k])/R[k] for k in range(1,N)] + [0]
        dt = tj - tprev
        for k in range(N):
          Vc[k] += (I[k]-I[k+1])/C[k]*dt
      tprev = tj
      yield numpy.array(Vc)
  
  
  # 0-100 microseconds
  t = numpy.arange(0,100,0.1)*1e-6
  tus = t*1e6
  Vin = (tus >= 10) * 1.0
  
  # R1 = 1kohm,  C1 = 10nF
  # R2 = 10kohm, C2 = 1nF
  R = [1000, 10000]
  C = [10e-9, 1e-9]
  Vc_a = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  R = [1000, 1000]
  C = [10e-9, 10e-9]
  Vc_b = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  fig = plt.figure(figsize=[8,6], dpi=80)
  ylabels = ['Vc_a', 'Vc_b']
  for (k,Vc) in enumerate([Vc_a,Vc_b]):
      ax = fig.add_subplot(3,1,k+1)
      ax.plot(tus,Vin,tus,Vc)
      ax.legend(['Vin','Vc1','Vc2'])
      ax.set_ylabel(ylabels[k])
      ax.grid('on')
  
  ax = fig.add_subplot(3,1,3)
  ax.plot(tus,Vc_a[:,-1],tus,Vc_b[:,-1])
  ax.legend(['Vc2_a','Vc2_b'])
  ax.set_ylabel('Vc2')
  ax.grid('on')
  
  fig.suptitle('2-pole RC filters: Vc_a = 1K,10nF,10K,1nF; Vc_b = 1K,10nF,1K,10nF')
  fig.savefig('rcfilt1.png',dpi=fig.dpi)
  plt.show()  
  

  5 và

  import matplotlib.pyplot as plt
  import numpy
  import itertools
  
  # array version of the zip() function
  def azip(*args):
    iters = [iter(arg) for arg in args]
    for i in itertools.count():
      yield tuple([it.next() for it in iters])      
  
  # special case for 2 args
  def azip2(a1,a2):
    it1 = iter(a1)
    it2 = iter(a2)
    for i in itertools.count():
      yield (it1.next(), it2.next())      
  
  def rcfilt(t,Vin,R,C):
    N = len(C)
    Vc = [0]*N
    tprev = None
    for (tj,Vj) in azip2(t,Vin):
      if tprev is not None:
        I = [(Vj-Vc[0])/R[0]] + [(Vc[k-1]-Vc[k])/R[k] for k in range(1,N)] + [0]
        dt = tj - tprev
        for k in range(N):
          Vc[k] += (I[k]-I[k+1])/C[k]*dt
      tprev = tj
      yield numpy.array(Vc)
  
  
  # 0-100 microseconds
  t = numpy.arange(0,100,0.1)*1e-6
  tus = t*1e6
  Vin = (tus >= 10) * 1.0
  
  # R1 = 1kohm,  C1 = 10nF
  # R2 = 10kohm, C2 = 1nF
  R = [1000, 10000]
  C = [10e-9, 1e-9]
  Vc_a = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  R = [1000, 1000]
  C = [10e-9, 10e-9]
  Vc_b = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  fig = plt.figure(figsize=[8,6], dpi=80)
  ylabels = ['Vc_a', 'Vc_b']
  for (k,Vc) in enumerate([Vc_a,Vc_b]):
      ax = fig.add_subplot(3,1,k+1)
      ax.plot(tus,Vin,tus,Vc)
      ax.legend(['Vin','Vc1','Vc2'])
      ax.set_ylabel(ylabels[k])
      ax.grid('on')
  
  ax = fig.add_subplot(3,1,3)
  ax.plot(tus,Vc_a[:,-1],tus,Vc_b[:,-1])
  ax.legend(['Vc2_a','Vc2_b'])
  ax.set_ylabel('Vc2')
  ax.grid('on')
  
  fig.suptitle('2-pole RC filters: Vc_a = 1K,10nF,10K,1nF; Vc_b = 1K,10nF,1K,10nF')
  fig.savefig('rcfilt1.png',dpi=fig.dpi)
  plt.show()  
  

  6, bạn cần sử dụng rõ ràng các phiên bản có nhiều mảng của các hàm này
• Nối mảng không dễ dàng, bạn phải sử dụng

  import matplotlib.pyplot as plt
  import numpy
  import itertools
  
  # array version of the zip() function
  def azip(*args):
    iters = [iter(arg) for arg in args]
    for i in itertools.count():
      yield tuple([it.next() for it in iters])      
  
  # special case for 2 args
  def azip2(a1,a2):
    it1 = iter(a1)
    it2 = iter(a2)
    for i in itertools.count():
      yield (it1.next(), it2.next())      
  
  def rcfilt(t,Vin,R,C):
    N = len(C)
    Vc = [0]*N
    tprev = None
    for (tj,Vj) in azip2(t,Vin):
      if tprev is not None:
        I = [(Vj-Vc[0])/R[0]] + [(Vc[k-1]-Vc[k])/R[k] for k in range(1,N)] + [0]
        dt = tj - tprev
        for k in range(N):
          Vc[k] += (I[k]-I[k+1])/C[k]*dt
      tprev = tj
      yield numpy.array(Vc)
  
  
  # 0-100 microseconds
  t = numpy.arange(0,100,0.1)*1e-6
  tus = t*1e6
  Vin = (tus >= 10) * 1.0
  
  # R1 = 1kohm,  C1 = 10nF
  # R2 = 10kohm, C2 = 1nF
  R = [1000, 10000]
  C = [10e-9, 1e-9]
  Vc_a = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  R = [1000, 1000]
  C = [10e-9, 10e-9]
  Vc_b = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  fig = plt.figure(figsize=[8,6], dpi=80)
  ylabels = ['Vc_a', 'Vc_b']
  for (k,Vc) in enumerate([Vc_a,Vc_b]):
      ax = fig.add_subplot(3,1,k+1)
      ax.plot(tus,Vin,tus,Vc)
      ax.legend(['Vin','Vc1','Vc2'])
      ax.set_ylabel(ylabels[k])
      ax.grid('on')
  
  ax = fig.add_subplot(3,1,3)
  ax.plot(tus,Vc_a[:,-1],tus,Vc_b[:,-1])
  ax.legend(['Vc2_a','Vc2_b'])
  ax.set_ylabel('Vc2')
  ax.grid('on')
  
  fig.suptitle('2-pole RC filters: Vc_a = 1K,10nF,10K,1nF; Vc_b = 1K,10nF,1K,10nF')
  fig.savefig('rcfilt1.png',dpi=fig.dpi)
  plt.show()  
  

  7 và

  import matplotlib.pyplot as plt
  import numpy
  import itertools
  
  # array version of the zip() function
  def azip(*args):
    iters = [iter(arg) for arg in args]
    for i in itertools.count():
      yield tuple([it.next() for it in iters])      
  
  # special case for 2 args
  def azip2(a1,a2):
    it1 = iter(a1)
    it2 = iter(a2)
    for i in itertools.count():
      yield (it1.next(), it2.next())      
  
  def rcfilt(t,Vin,R,C):
    N = len(C)
    Vc = [0]*N
    tprev = None
    for (tj,Vj) in azip2(t,Vin):
      if tprev is not None:
        I = [(Vj-Vc[0])/R[0]] + [(Vc[k-1]-Vc[k])/R[k] for k in range(1,N)] + [0]
        dt = tj - tprev
        for k in range(N):
          Vc[k] += (I[k]-I[k+1])/C[k]*dt
      tprev = tj
      yield numpy.array(Vc)
  
  
  # 0-100 microseconds
  t = numpy.arange(0,100,0.1)*1e-6
  tus = t*1e6
  Vin = (tus >= 10) * 1.0
  
  # R1 = 1kohm,  C1 = 10nF
  # R2 = 10kohm, C2 = 1nF
  R = [1000, 10000]
  C = [10e-9, 1e-9]
  Vc_a = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  R = [1000, 1000]
  C = [10e-9, 10e-9]
  Vc_b = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  fig = plt.figure(figsize=[8,6], dpi=80)
  ylabels = ['Vc_a', 'Vc_b']
  for (k,Vc) in enumerate([Vc_a,Vc_b]):
      ax = fig.add_subplot(3,1,k+1)
      ax.plot(tus,Vin,tus,Vc)
      ax.legend(['Vin','Vc1','Vc2'])
      ax.set_ylabel(ylabels[k])
      ax.grid('on')
  
  ax = fig.add_subplot(3,1,3)
  ax.plot(tus,Vc_a[:,-1],tus,Vc_b[:,-1])
  ax.legend(['Vc2_a','Vc2_b'])
  ax.set_ylabel('Vc2')
  ax.grid('on')
  
  fig.suptitle('2-pole RC filters: Vc_a = 1K,10nF,10K,1nF; Vc_b = 1K,10nF,1K,10nF')
  fig.savefig('rcfilt1.png',dpi=fig.dpi)
  plt.show()  
  

  8 thay vì

  import matplotlib.pyplot as plt
  import numpy
  import itertools
  
  # array version of the zip() function
  def azip(*args):
    iters = [iter(arg) for arg in args]
    for i in itertools.count():
      yield tuple([it.next() for it in iters])      
  
  # special case for 2 args
  def azip2(a1,a2):
    it1 = iter(a1)
    it2 = iter(a2)
    for i in itertools.count():
      yield (it1.next(), it2.next())      
  
  def rcfilt(t,Vin,R,C):
    N = len(C)
    Vc = [0]*N
    tprev = None
    for (tj,Vj) in azip2(t,Vin):
      if tprev is not None:
        I = [(Vj-Vc[0])/R[0]] + [(Vc[k-1]-Vc[k])/R[k] for k in range(1,N)] + [0]
        dt = tj - tprev
        for k in range(N):
          Vc[k] += (I[k]-I[k+1])/C[k]*dt
      tprev = tj
      yield numpy.array(Vc)
  
  
  # 0-100 microseconds
  t = numpy.arange(0,100,0.1)*1e-6
  tus = t*1e6
  Vin = (tus >= 10) * 1.0
  
  # R1 = 1kohm,  C1 = 10nF
  # R2 = 10kohm, C2 = 1nF
  R = [1000, 10000]
  C = [10e-9, 1e-9]
  Vc_a = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  R = [1000, 1000]
  C = [10e-9, 10e-9]
  Vc_b = numpy.array(list(rcfilt(t,Vin,R,C)))
  
  fig = plt.figure(figsize=[8,6], dpi=80)
  ylabels = ['Vc_a', 'Vc_b']
  for (k,Vc) in enumerate([Vc_a,Vc_b]):
      ax = fig.add_subplot(3,1,k+1)
      ax.plot(tus,Vin,tus,Vc)
      ax.legend(['Vin','Vc1','Vc2'])
      ax.set_ylabel(ylabels[k])
      ax.grid('on')
  
  ax = fig.add_subplot(3,1,3)
  ax.plot(tus,Vc_a[:,-1],tus,Vc_b[:,-1])
  ax.legend(['Vc2_a','Vc2_b'])
  ax.set_ylabel('Vc2')
  ax.grid('on')
  
  fig.suptitle('2-pole RC filters: Vc_a = 1K,10nF,10K,1nF; Vc_b = 1K,10nF,1K,10nF')
  fig.savefig('rcfilt1.png',dpi=fig.dpi)
  plt.show()  
  

  9 hoặc

  from sympy import *
  x0,x1,y0,y1,m,h = symbols('x0 x1 y0 y1 m h')
  simplify(integrate((m*(x-x0)+y0)**2,(x,x0,x0+h)).subs(m,(y1-y0)/h))
  

  0

Bạn muốn tìm hiểu thêm về PyLab?

Đầu tiên và quan trọng nhất. thử nó

Có một số hướng dẫn tuyệt vời về scipy. tổ chức. Python đủ phổ biến để có nhiều hướng dẫn khác nằm rải rác trên internet. Đây là một cái mà tôi thấy có vẻ như là một nơi tốt để bắt đầu

Đối với Python nói chung, cuốn sách Học Python của O'Reilly là một cuốn sách cổ điển - ấn bản thứ 5 sắp xuất bản, nhưng đối với những điều cơ bản, bạn sẽ không bỏ lỡ nhiều bằng cách lấy ấn bản trước đó. Ngoài ra còn có Learn Python The Hard Way, miễn phí dưới dạng một chuỗi bài tập trực tuyến

Các nguồn lực khác

Tôi mới bắt đầu học cách sử dụng pandas và IPython

gấu trúc

Gói gấu trúc bao gồm các công cụ để phân tích dữ liệu với Python. Thư viện numpy và scipy hoạt động với mảng N chiều. Thư viện gấu trúc thêm các cột và hàng được đặt tên và lập chỉ mục vào mảng. Nếu bạn đã từng làm việc với các tệp CSV có tiêu đề cột, bạn sẽ biết ý tôi là gì. Hãy tưởng tượng việc xóa các tiêu đề khỏi tệp CSV. những gì bạn còn lại là một ma trận, nơi bạn phải nhớ rằng cột 0 là thời gian và cột 1-3 là điện áp pha động cơ. Thư viện gấu trúc cung cấp cho bạn một lớp Python có tên là DataFrame, lớp này cho phép bạn chú thích các ma trận với thông tin về từng hàng và cột. Có rất nhiều goodies khác trong gấu trúc. DataFrame để xử lý số trên loại dữ liệu này

Bạn muốn tìm hiểu thêm về gấu trúc?

IPython

Nếu bạn đã quen với shell tương tác trong Matlab, thì IPython là dành cho bạn. Nếu bạn nhập

from sympy import *
x0,x1,y0,y1,m,h = symbols('x0 x1 y0 y1 m h')
simplify(integrate((m*(x-x0)+y0)**2,(x,x0,x0+h)).subs(m,(y1-y0)/h))

Nếu bạn quên các phương thức có sẵn của một đối tượng, bạn chỉ cần nhấn phím tab để hoàn thành tương tác

Nếu bạn bắt đầu viết một lời gọi hàm và do dự, IPython sẽ nhắc bạn với một số trợ giúp cơ bản

Và đó mới chỉ là khởi đầu. Như tôi đã nói, tôi vẫn đang học IPython. Muốn tìm hiểu thêm?

Phần kết luận

Càng tìm hiểu nhiều về Python, tôi càng ít phụ thuộc vào MATLAB hơn cho các nhiệm vụ phân tích và trực quan hóa dữ liệu mà tôi cần cho công việc của mình

Nhớ. phát triển hệ thống nhúng không chỉ là viết mã. Đó là về lập kế hoạch, trong bối cảnh của một hệ thống thực với các thành phần điện tử và đôi khi là các thành phần cơ khí. Để tạo ra một hệ thống tốt hơn, bạn có thể tiết kiệm cho mình rất nhiều rắc rối bằng cách phân tích nó trước khi bắt đầu ném mã C nhúng vào nó. Các công cụ như MATLAB và Python có thể giúp ích;

Python có tốt cho việc xử lý tín hiệu không?

Python có tốt hơn MATLAB để xử lý ảnh không?

MATLAB có hữu ích hơn Python không?

MATLAB hay Python tốt hơn cho máy học?