"Embedded Space"

Think − Do − Learn − Share







This page is no longer maintained or updated...






การทดลองใช้งาน Python / MyHDL เพื่อออกแบบวงจรดิจิทัลพื้นฐาน

บทความนี้กล่าวถึง การทดลองใช้งานภาษา Python ในการสร้างแบบจำลอง (โมเดล) สำหรับวงจรดิจิทัล โดยใช้ MyHDL เวอร์ชัน 0.8.1 ซึ่งเป็น Python package (ใช้ได้กับ Python 2.7.x)

คำสำคัญ / Keywords: Python, MyHDL, Hardware Description Language

หลายคนอาจเคยได้ลองใช้ภาษาสำหรับอธิบายการทำงาน หรือสร้างแบบจำลองการทำงานของวงจรดิจิทัล อย่างเช่น VHDL หรือ Verilog HDL ซึ่งเป็นภาษาจำพวก HDL (Hardware Description Language) ที่มีการใช้งานโดยทั่วไป แต่ถ้าต้องการใช้ภาษา Python สำหรับวัตถุประสงค์ดังกล่าว จะทำได้หรือไม่  MyHDL (http://www.myhdl.org/) ก็เป็นตัวเลือกหนึ่งที่น่าสนใจ อาจจะเหมาะกับคนที่มีความคุ้นเคยกับภาษา Python มาก่อน และต้องการเรียนรู้การออกแบบวงจรดิจิทัลโดยใช้ภาษา Python

  • MyHDL เป็น Python package และเป็น open-source
  • มีการพัฒนาขึ้นในปี ค.ศ. 2002-2003 โดย Jan Decaluwe
  • เหมาะสำหรับการสร้างแบบจำลองของวงจรดิจิทัลในระดับ RTL (Register Transfer Level)
  • สามารถแปลงโค้ด MyHDL ให้เป็น Synthesizable VHDL และ Verilog HDL ได้
    ซึ่งสามารถนำไปสังเคราะห์วงจรใน Hardware Design Flow ทั่วไป (เช่น FPGA Design Flow)
  • MyHDL ไม่ใช่เครื่องมือสำหรับการสังเคราะห์วงจรดิจิทัล (Synthesis Tool) และ
    ไม่สามารถแปลงโค้ด Python ทั่วๆไป ให้เป็นโค้ด VHDL หรือ Verilog ได้
  • สามารถจำลองการทำงานของวงจรดิจิทัลได้ สามารถเขียน Testbench โดยใช้ภาษา Python ได้
    และเมื่อทำขั้นตอนการจำลองการทำงาน จะให้เอาต์พุตเป็นรูปคลื่นสัญญาณ (Waveform) ในไฟล์ .VCD
    ซึ่งสามารถดูรูปคลื่นสัญญาณได้โดยใช้โปรแกรม GTKWave
  • สามารถตรวจสอบความถูกต้องของวงจรได้ ในแบบ Functional Simulation (ในระดับ cycle-accurate)

ในการเขียนโค้ดเพื่อจำลองการทำงานของวงจรดิจิทัลหรือฮาร์ดแวร์นั้น มีความแตกต่างจากการเขียนโค้ดสำหรับซอฟต์แวร์โดยทั่วไป อย่างเช่น
  • การทำงานของส่วนต่างๆในวงจรที่เกิดขึ้นพร้อมกันได้ (Hardware Concurrency)
  • การกำหนดจังหวะทำงานของวงจรส่วนต่างๆ เช่น การรอจังหวะขอบขาขึ้น (rising edge) หรือขาลง (falling edge) ของสัญญาณ clock หรือสัญญาณอื่นๆ เพื่อทำอะไรบ้างอย่าง การเปลี่ยนแปลงค่าใหม่ของสัญญาณตามจังหวะขอบขาขึ้นหรือขาลงของสัญญาณ clock เป็นต้น
  • การใช้งานชนิดข้อมูลสำหรับวงจรดิจิทัล เช่น ข้อมูลแบบ integer ที่กำหนดจำนวนของบิต ที่ต้องการใช้งานได้ (bit vector)
  • การสร้างวงจรที่มีขอบเขตและการเชื่อมต่อ เช่น I/O interface ให้มีลักษณะเป็นโมดูลหรือคอมโพเนนท์
    และนำสามารถใช้งานในโมดูลอื่นๆ และเชื่อมต่อกันได้ (component instantiation & structural composition)

ภาษา MyHDL รองรับการใช้งานในลักษณะดังกล่าว

การติดตั้ง MyHDL เพื่อใช้งาน (สำหรับ Linux)


สำหรับ Linux เช่น Ubuntu, Debian, Raspbian สามารถติดตั้ง MyHDL โดยใช้คำสั่งต่อไปนี้
  # install MyHDL
  $ sudo pip install myhdl 

  # upgrade MyHDL if the package is already installed.
  $ sudo pip install --upgrade myhdl

  # install gtkwave
  $ sudo apt-get install gtkwave

ตัวอย่างการใช้งาน: วงจรลอจิกแบบ Combinational Logic

ตัวอย่างแรกในการใช้ภาษา MyHDL เป็นวงจร 2-to-1 multiplexor หรือเรียกอย่างย่อว่า MUX2_1 ซึ่งเป็นวงจรแบบ combinational logic (ไม่มีการใช้สัญญาณ clock ค่าของเอาต์พุตขึ้นอยู่กับค่าของอินพุตเท่านั้น)

ตัวอย่างการเขียนโค้ด Python โดยใช้ MyHDL สำหรับวงจร "MUX2_1"
File: mux2_1.py
from myhdl import *

# define a generator function that models a MUX2_1
def mux2_1( o, a, b, s ):
    """ 'a', 'b', and 's' are the input and 'o' is the output of the MUX2_1."""
    @always_comb
    def logic():  # combinational logic
        if s == 0:
            o.next = a
        else:
            o.next = b
    return logic # returns the generator

โค้ดตัวอย่างแรกเป็นการสร้างวงจรดิจิทัล MUX2_1 ที่มีสัญญาณอินพุตข้อมูลเป็น a และ b และมีสัญญาณอินพุตควบคุม s เพื่อเลือกว่า จะให้เอาต์พุต o มีค่าตรงกับอินพุตข้อมูลใด
  • ฟังก์ชัน mux2_1() เป็น Python function และสร้างขึ้นมาเพื่อสำหรับวงจร MUX2_1 โดยมี argument list เป็นชื่อของสัญญาณอินพุต-เอาต์พุตของวงจร (ได้แก่ o, a, b, s)
  • ภายในฟังก์ชัน mux2_1() มีฟังก์ชันอยู่ภายในชื่อ logic() ที่กำหนดขึ้นมาเอง และทำหน้าที่เป็น generator function และฟังก์ชัน mux2_1() จะให้ค่ากลับคืนเป็น function generator ดังกล่าว
  • MyHDL ใช้หลักการของ function generator ในภาษา Python เพื่อจำลองการทำงานของ Hardware Concurrency
  • @always_comb เป็นตัวอย่างของ Python decorator (สังเกตว่าขึ้นต้นด้วย @) และใช้กับ function generator สำหรับวงจรดิจิทัลแบบ combinational logic
  • ในตัวอย่างนี้ เมื่อใดที่มีการเปลี่ยนแปลงของค่าลอจิกของสัญญาณอินพุต a, b หรือ s จะมีการอัพเดทค่าของเอาต์พุต o

ลองมาดูตัวอย่างการเขียนโค้ด Testbench เพื่อสร้างสัญญาณอินพุตทดสอบวงจร MUX2_1 โดยใช้ MyHDL ดูบ้าง

ตัวอย่างการเขียนโค้ด Testbench สำหรับวงจร "MUX2_1" และใช้สัญญาณอินพุตที่เป็นข้อมูลแบบบิตเดียว
File: test_mux2_1.py
#!/usr/bin/env python

from random import randrange
from myhdl import *
from mux2_1 import mux2_1   # import from file: 'mux2_1.py'

def tb_test_mux2_1():
    # create test signals: 
    t_o, t_a, t_b, t_s = [Signal(bool(0)) for i in range(4)] # create 4 boolean signals

    # instantiate the MUX2_1 as DUT (Design-under-Test) with port-signal mapping
    dut_inst = mux2_1( o=t_o, a=t_a, b=t_b, s=t_s ) # instantiate a MUX2_1

    # define a function generator to be used with the decolorator @instance
    # for generating input test signals: t_a, t_b, t_s
    @instance
    def input_gen():
        t_a.next = 0
        t_b.next = 0
        t_s.next = 0
        yield delay( 100 )  # wait for 100 timesteps
        while True:
            t_a.next = randrange(2)  # assign a new boolean value to 'a'
            t_b.next = randrange(2)  # assign a new boolean value to 'b'
            t_s.next = randrange(2)  # assign a new boolean value to 's'
            yield delay( randrange(100,200) ) # delay between 100 .. 200 timesteps

    return dut_inst, input_gen  # returns the generators

if __name__ == "__main__": 
    traceSignals.timescale = "1ns"
    tb_dut = tb_test_mux2_1
    tb  = traceSignals( tb_dut )
    sim = Simulation( tb ) # create a simulator
    timesteps = 2000       # specify the number of timesteps for simulation
    sim.run( timesteps )   # start simulation

    o, a, b, s = [ Signal(bool(0)) for i in range(4) ]
    toVHDL( mux2_1, o, a, b, s )  # convert to VHDL

หลักการในการสร้าง Testbench โดยใช้ MyHDL มีดังนี้
  • สร้างฟังก์ชัน tb_test_mux2_1() ตามตัวอย่าง เพื่อใช้ในการสร้างสัญญาณทดสอบให้วงจร MUX2_1
  • ภายในฟังก์ชันนี้ มีการสร้างสัญญาณทดสอบ ซึ่งเป็น Signal แบบ Boolean (ลอจิก 0 หรือ 1) เพื่อเชื่อมต่อกับวงจร MUX2_1 ที่ถูกสร้างขึ้นมา (component instantiation) และมีการสร้างฟังก์ชัน input_gen() ที่เป็น function generator และใช้ร่วมกับ Python decolorator ชื่อ @instance เพื่อทำหน้าที่กำหนดค่าลอจิกให้สัญญาณทดสอบในช่วงเวลาต่างๆ
  • สังเกตว่า ฟังก์ชัน tb_test_mux2_1() ให้ค่ากลับคืนเป็นรายการของ function generator ซึ่งได้แก่ dut_inst และ input_gen
  • Simulation ใช้สำหรับการจำลองการทำงาน หรือเป็น Simulator นั่นเอง
  • traceSignals ใช้ในการบันทึกค่าและเวลาเมื่อมีการเปลี่ยนแปลงของสัญญาณ I/O ของวงจร ในขณะที่จำลองการทำงาน
  • toVHDL() ไม่เกี่ยวข้องกับการจำลองการทำงาน แต่ใช้ในการสร้างโค้ด VHDL สำหรับวงจร MUX2_1
  • ถ้าต้องการทำขั้นตอน Simulation ให้ทำคำสั่ง python ./test_mux2_1.py


รูปแสดง Waveform จากไฟล์ .VCD โดยใช้โปรแกรม GTKWave

ลองมาดูตัวอย่างโค้ด Testbench สำหรับวงจร "mux2_1" ที่ใช้สัญญาณอินพุตเป็นข้อมูลแบบ 4 บิต (bit vector)
File: test_mux2_1_bv.py
#!/usr/bin/env python

from random import randrange
from myhdl import *
from mux2_1 import mux2_1

def tb_test_mux2_1_bv():
    # create test signals:
    t_o, t_a, t_b = [ Signal(intbv(0)[4:]) for i in range(3) ]  # 4-bit signals
    t_s = Signal(bool(0))  # boolean signal

    # instantiate the DUT (Design-under-Test) with port-signal mapping
    dut_inst = mux2_1( o=t_o, a=t_a, b=t_b, s=t_s )

    # define a function generator for generating input test signals
    @instance
    def input_gen():
        t_a.next = 0
        t_b.next = 0
        t_s.next = 0
        yield delay( 100 ) # wait for 100 timesteps
        while True:
            t_a.next = randrange(16)  # assign a new 4-bit int value to 'a'
            t_b.next = randrange(16)  # assign a new 4-bit int value to 'b'
            t_s.next = randrange(2)   # assign a new boolean value to 's'
            yield delay( randrange(100,200) ) # delay between 100 .. 200 timesteps

    return dut_inst, input_gen  # returns the generators

if __name__ == "__main__": 
    traceSignals.timescale = "1ns"
    tb_dut = tb_test_mux2_1_bv
    tb  = traceSignals( tb_dut )
    sim = Simulation( tb ) # create a simulator
    timesteps = 2000       # specify the number of timesteps for simulation
    sim.run( timesteps )   # start simulation

    o, a, b = [ Signal(intbv(0)[4:]) for i in range(3) ]
    s = Signal(bool(0))
    toVHDL( mux2_1, o, a, b, s )  # convert to VHDL


รูปแสดง Waveform จากไฟล์ .VCD จากการจำลองการทำงานของวงจร mux2_1 ขนาดข้อมูล 4 บิต

ดูตัวอย่างไฟล์ VHDL ที่สร้างโดย MyHDL สำหรับวงจร MUX2_1 (สำหรับข้อมูลอินพุตขนาด 4 บิต)
File: mux2_1.vhd
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;
use std.textio.all;

use work.pck_myhdl_081.all;

entity mux2_1 is
    port (
        o: out unsigned(3 downto 0);
        a: in unsigned(3 downto 0);
        b: in unsigned(3 downto 0);
        s: in std_logic
    );
end entity mux2_1;
-- 'a', 'b', and 's' are the input and 'o' is the output of the MUX2_1.

architecture MyHDL of mux2_1 is

begin

MUX2_1_LOGIC: process (a, s, b) is
begin
    if (s = '0') then
        o <= a;
    else
        o <= b;
    end if;
end process MUX2_1_LOGIC;

end architecture MyHDL;

ตัวอย่างการใช้งาน: วงจรลอจิกแบบ Sequential Logic

ตัวอย่างถัดไปเป็นการสร้างวงจรตัวนับขึ้น (n-bit Up-Counter) ซึ่งเป็นวงจรแบบ sequential logic โดยมีสัญญาณ clk เป็นตัวกำหนดจังหวะการทำงานที่ขอบขาขึ้น มีสัญญาณ rst_n เพื่อรีเซตค่าของตัวนับ (ทำงานแบบ active-low, asynchronous) มีสัญญาณ ld เป็นสัญญาณควบคุม ถ้าเป็น '1' จะโหนดค่าจากอินพุต d มาเป็นค่าเริ่มต้นในการนับ และมีสัญญาณ o เป็นสัญญาณเอาต์พุต ซึ่งเป็นค่าของตัวนับ ในตัวอย่างนี้ ยังมีการใช้พารามิเตอร์ width เพื่อใช้กำหนดความกว้างของตัวนับ (bit width) คล้ายกับ generic ในภาษา VHDL


File: counter.py
from myhdl import *

# define a generator function that models a binary up-counter.
def counter( rst_n, clk, ld, d, q, width=8 ):
    """
    rst_n  async. active-low reset signal (input)
    clk    clock signal (input)    
    ld     load signal (input)
    d      initial data (input)
    q      counter value (output)
    width  bit width of the counter (parameter)
    """

    # create an internal signal, 8-bit bitvector (with modulo)
    reg = Signal(modbv(0)[width:]) 
 
    @always_comb
    def comb():
        q.next = reg

    @always( clk.posedge, rst_n.negedge )
    def seq():
        if rst_n == 0:
            reg.next = 0           # reset the value
        else: 
            if ld == 1:
               reg.next = d        # load the initial value
            else:
               reg.next = reg + 1  # increment the value
  
    return comb, seq   # returns the generators

ตัวอย่างการเขียนโค้ดสำหรับ Testbench เพื่อทดสอบการทำงานของวงจร counter ขนาด 8 บิต
File: tb_counter.py
#!/usr/bin/env python

from random import randrange
from myhdl import *
from counter import counter

BW = 8 # bit width o the counter

def tb_counter():
    # create test signals:
    t_ld, t_clk, t_rst_n = [ Signal(bool(0)) for i in range(3) ]
    t_q, t_d = [ Signal(intbv(0)[BW:]) for i in range(2) ]

    # instantiate the DUT with port-signal mapping
    dut_inst = counter( q=t_q, d=t_d, ld=t_ld, 
                        clk=t_clk, rst_n=t_rst_n, width=BW )
 
    # define a function generator for generating clock signal, 
    # period = 2*10 cycles
    @always( delay(10) )
    def clk_gen():
        t_clk.next = not t_clk

    # define a function generator for generating input signals: 'ld' and 'd'
    @instance
    def ld_d_gen():
        yield delay( 200 )
        yield t_clk.negedge
        t_ld.next = 1
        t_d.next  = randrange(2**BW)
        yield t_clk.negedge
        t_ld.next = 0
        while True:
             yield delay( 10000 )

    @instance
    def rst_gen():
        t_rst_n.next = 0
        yield delay( 50 )
        t_rst_n.next = 1
        while True:
            yield delay( 10000 )

    return dut_inst, clk_gen, ld_d_gen, rst_gen  # returns the generators

if __name__ == "__main__": 
    traceSignals.timescale = "1ns"
    tb_dut = tb_counter
    tb  = traceSignals( tb_dut )
    sim = Simulation( tb ) # create a simulator
    timesteps = 5000
    sim.run( timesteps )   # start simulation for the given number of timesteps

    ld, clk, rst_n = [ Signal(bool(0)) for i in range(3) ]
    q, d = [ Signal(modbv(0)[BW:]) for i in range(2) ]
    toVHDL.name = 'counter' + str(BW)
    toVHDL( counter, q=q, d=d, ld=ld, clk=clk, rst_n=rst_n )


รูปแสดง Waveform จากไฟล์ .VCD สำหรับวงจร counter ขนาด 8 บิต


มาดูตัวอย่างโค้ด VHDL ที่ได้จาก MyHDL
File: counter8.vhd
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;
use std.textio.all;

use work.pck_myhdl_081.all;

entity counter8 is
    port (
        rst_n: in std_logic;
        clk: in std_logic;
        ld: in std_logic;
        d: in unsigned(7 downto 0);
        q: out unsigned(7 downto 0)
    );
end entity counter8;
-- rst_n  async. active-low reset signal (input)
-- clk    clock signal (input)    
-- ld     load signal (input)
-- d      initial data (input)
-- q      counter value (output)
-- width  bit width of the counter (parameter)

architecture MyHDL of counter8 is

signal reg: unsigned(7 downto 0);

begin

q <= reg;

COUNTER8_SEQ: process (clk, rst_n) is
begin
    if (rst_n = '0') then
        reg <= to_unsigned(0, 8);
    elsif rising_edge(clk) then
        if (ld = '1') then
            reg <= d;
        else
            reg <= (reg + 1);
        end if;
    end if;
end process COUNTER8_SEQ;

end architecture MyHDL;

จากไฟล์ VHDL ที่ได้จาก MyHDL สำหรับตัวอย่าง counter นั้น สังเกตได้ว่า MyHDL ไม่สามารถสร้างไฟล์แบบ parameterizable VHDL ได้

อีกตัวอย่างหนึ่งเป็นการสร้างรีจิสเตอร์แบบเลื่อนบิต (Shift Register) ที่มีอินพุตและเอาต์พุตแบบบิตอนุกรม (Serial-In-Serial-Out: SISO) และทำตามจังหวะของ Clock ที่ขอบขาขึ้น และสร้างได้จากการนำวงจร DFF มาต่อเข้าด้วยกันตามลำดับ ตามจำนวนที่ต้องการ

มาดูตัวอย่างโค้ดโดยใช้ MyHDL
File: siso_sreg.py
#!/usr/bin/env python

from myhdl import *

# D-type Flip-Flop
def dff( q, d, clk ):
    """ d is the data input of DFF."""
    """ clk is the clock input of DFF."""
    """ q is the data outut of the DFF."""

    @always( clk.posedge ) # wait on a rising-edge event of the clock 
    def logic():
        q.next = d  # signal assignment

    return logic # returns the generator

# Serial-In-Serial-Out Shift Register
def siso_sreg( q, d, clk, num=8 ):
    if num > 0:
        s = [Signal(bool(0)) for i in range(num-1) ]

    dff_inst = list()  # empty list
    for i in range(num):
        if i==0:
           si = d
        else:
           si = s[i-1]
  
        if i==(num-1):
           so = q
        else:
           so = s[i]

        dff_inst.append( dff( q=so, d=si, clk=clk ) )

    return dff_inst  # returns a list of function generators
   
if __name__ == "__main__": 
    n = 4   # number of DFFs
    q, d, clk = [ Signal(bool(0)) for i in range(3) ]
    toVHDL.name = 'siso_sreg' + str(n)
    toVHDL( siso_sreg, q=q, d=d, clk=clk, num=n )  # convert to VHDL 

อย่างไรก็ตาม จากตัวอย่างเหล่านี้ แสดงให้เห็นว่า MyHDL สามารถนำมาใช้เป็นตัวเลือกหนึ่ง ในการเรียนรู้การออกแบบวงจรดิจิทัล-ลอจิกโดยใช้ภาษา Python ได้ อาจจะมีข้อจำกัดอยู่บ้าง เมื่อเปรียบเทียบกับภาษาอย่างเช่น VHDL และ Verilog ผู้ที่สนใจสามารถศึกษาเพิ่มเติมจากตัวอย่างและเอกสารได้จากเว็บไซต์ของ MyHDL (http://myhdl.org/)

ตัวอย่างสำหรับนำไปทดสอบกับบอร์ด FPGA

ตัวอย่างต่อไปนี้เป็นวงจรดิจิทัล running_leds ที่แสดงค่าของเอาต์พุตโดยใช้ LED จำนวน 8 ดวง และมีเพียงหนึ่งดวงที่สว่าง (ON) แต่จะเปลี่ยนตำแหน่งไปตามลำดับและตามช่วงเวลาที่กำหนด โค้ด VHDL ที่ได้จากโค้ด Python / MyHDL นั้น สามารถได้นำไปใช้กับ Altera Quartus II เพื่อสังเคราะห์วงจรและสร้างเป็นไฟล์ bitstream เและนำไปทดสอบกับบอร์ด Terasic DE0-nano



รูปแสดงตัวอย่างผลการจำลองการทำงานของ Testbench สำหรับวงจร running_leds



รูปแสดงการแปลงไฟล์ VHDL ให้เป็นไฟล์ Bitstream โดยใช้ Altera Quartus II



วิดีโอสาธิตการทำงาน (Best View with Chrome)

ประเด็นและคำถามที่น่าสนใจท้ายบทความ

  • ผู้ที่พัฒนา MyHDL เริ่มแรกนั้น เขาคิดหรือมองเห็นช่องทางได้อย่างไรที่จะใช้ Python (เขาต้องเข้าใจภาษา Python เป็นอย่างดี) เพื่อนำมาในใช้การสร้างแบบจำลองการทำงานของวงจรดิจิทัล-ลอจิก?
  • มีตัวอย่างที่ใช้ MyHDL ในการออกแบบและนำไปสร้างเป็นวงจรเพื่อใช้งานจริง มากน้อยเพียงไรในปัจจุบัน มีกลุ่มผู้ใช้มากหรือไม่?
  • ถ้าเปรียบเทียบกับการใช้ภาษา VHDL หรือ Verilog กับการใช้ภาษา Python / MyHDL สำหรับผู้เริ่มต้นที่จะเรียนรู้ในการออกแบบวงจรดิจิทัล-ลอจิกโดยใช้ภาษาระดับสูง แบบไหนน่าจะง่ายกว่ากัน?
  • ภาษาคอมพิวเตอร์ประเภท HDL เป็นตัวช่วยในการอธิบายการทำงานหรือสร้างแบบจำลอง (โมเดล) ของวงจรดิจิทัลหรือฮาร์ดแวร์ ดังนั้นการเลือกใช้ภาษาก็ถือว่าเป็นสิ่งสำคัญ แต่การเข้าใจหลักการ น่าจะสำคัญกว่า เช่น หลักการของ Hardware Concurrency (การทำงานของส่วนต่างๆที่เกิดพร้อมๆกันในฮาร์ดแวร์), Communication / Synchronization (การสื่อสารและรอจังหวะกัน), Modularity & Interface (การแบ่งเป็นโมดูลและส่วนเชื่อมต่อ) และ Modeling Styles (รูปแบบการสร้างโมเดลสำหรับวงจรดิจิทัล-ลอจิก) เป็นต้น และหลักการเหล่านี้ ต้องสามารถใช้ได้กับภาษาประเภท HDL ส่วนใหญ่
  • ข้อดีของการใช้ภาษา Python / MyHDL อีกข้อหนึ่ง อาจจะอยู่ที่การเขียนโค้ดเพื่อทดสอบ เหมือนในกรณีที่ใช้ Python พัฒนาซอฟต์แวร์ทั่วไป เพราะการใช้ภาษา Python ในการเขียนโค้ดสำหรับ Testbench น่าจะทำได้ดีกว่าการใช้ภาษาอย่างเช่น VHDL และ Verilog
  • เราสามารถใช้ Python / MyHDL มาใส่ส่วนที่เป็น GUI เพื่อจำลองการทำงานและแสดงผลเชิงกราฟิก สำหรับวงจรพื้นฐานแบบต่างๆ ใช้เป็นสื่อการสอนในวิชาพื้นฐานเกี่ยวกับดิจิทัล-ลอจิกได้หรือไม่? เช่น แสดงค่าของสัญญาณต่างๆ ภายในวงจรดิจิทัล-ลอจิกและส่วนที่เป็น I/O ในขณะที่จำลองการทำงาน ทำต่อเนื่องหรือทำทีละหน่วยเวลาได้ (time-stepping)

เผยแพร่ (First Published): 5 March 2015
แก้ไขครั้งล่าสุด (Last Updated): 8 March 2015


เผยแพร่ภายใต้ลิขสิทธิ์ / This work is licensed under: Creative Commons Attribution-NonCommercial 3.0 Unported



This page is no longer maintained or updated...




ไปหน้ารายการบทความ / Back to the article list
Formerly known as "Embedded Systems Lab (ESL@KMUTNB)"
Department of Electrical and Computer Engineering (ECE)
Faculty of Engineering, KMUTNB, Bangkok / Thailand