Video
Đăng bởi Ban biên tập OpenER ·
Tác giả giữ toàn bộ bản quyền (All Rights Reserved) — không phải giấy phép mở. Bạn vẫn xem và học miễn phí trên OpenER; muốn tái sử dụng cần xin phép tác giả.
Out of the blue. Okay, good morning, everyone. Hope you all had a great long weekend. Great to see you all here.
Bất ngờ thật. Được rồi, chào buổi sáng mọi người. Hy vọng các bạn đã có một kỳ nghỉ cuối tuần dài thật vui. Rất vui được gặp lại các bạn ở đây.
Welcome to EECS 151/251A, Introduction to Digital Design and Integrated Circuits. So we started some discussion last week about Verilog. Some of you already seen a little bit more during the discussions.
Chào mừng các bạn đến với EECS 151/251A, Nhập môn Thiết kế số và Mạch tích hợp. Tuần trước chúng ta đã bắt đầu thảo luận về Verilog. Một số bạn đã được xem thêm một chút trong các buổi thảo luận.
Today we'll see in depth about what are the different ways of using Verilog to express different styles of hardware.
Hôm nay chúng ta sẽ tìm hiểu sâu về các cách khác nhau để dùng Verilog biểu diễn những kiểu phần cứng khác nhau.
In particular, how we can use Verilog to describe the combinational circuit and the sequential circuit that we discussed before.
Cụ thể, chúng ta có thể dùng Verilog để mô tả mạch tổ hợp và mạch tuần tự mà chúng ta đã bàn trước đây.
Before we get there, right, I guess last time we talked about a lot of excitement, especially from Intel's side, actually building up more domestic fabrication structure, infrastructures here in the US.
Trước khi vào phần đó, tôi nhớ lần trước chúng ta đã nói về nhiều sự phấn khởi, đặc biệt từ phía Intel, trong việc xây dựng thêm cơ sở chế tạo trong nước, tức là hạ tầng ngay tại Hoa Kỳ.
Some of you may also be very familiar with, or have heard of, the CHIPS Act or CHIPS Plus Act.
Có thể một số bạn cũng đã rất quen thuộc với hoặc đã nghe đến CHIPS Act hay CHIPS Plus Act.
There is a lot of excitement here, I wouldn't say just domestically, also internationally, about setting up more infrastructures, understanding how we can actually build more advanced circuits globally to actually stay competitive.
Có rất nhiều sự hào hứng ở đây, tôi sẽ không chỉ nói là trong nước, mà cả trên phạm vi quốc tế, về việc xây dựng thêm hạ tầng, về việc hiểu cách chúng ta thực sự có thể chế tạo các mạch tiên tiến hơn trên toàn cầu để giữ được khả năng cạnh tranh.
Some of the really interesting moves from all the different fabs, especially in the past decades, are both the shrinking of the number of fabs actually available globally, and also some of the actually sharing of the fab or sharing the facilities from the different fab vendors.
Một số diễn biến thực sự thú vị từ các nhà máy chế tạo khác nhau, đặc biệt trong những thập kỷ qua, là việc số lượng nhà máy chế tạo hiện có trên toàn cầu bị thu hẹp, và cả việc một số nhà máy chia sẻ với nhau hoặc chia sẻ cơ sở vật chất từ các nhà cung cấp fab khác nhau.
So first, we actually look at different technology generations, right? From 180 to the more recent ones, actually very advanced technology.
Trước hết, chúng ta hãy xem các thế hệ công nghệ khác nhau, đúng không? Từ 180 cho đến những thế hệ gần đây, là công nghệ rất tiên tiến.
And what this plot shows is actually the number of fabs, the names of different fab facilities in the, I guess, in the past decades, right? We see a lot of things actually going on.
Và biểu đồ này cho thấy số lượng nhà máy chế tạo, tên của các cơ sở chế tạo khác nhau trong những thập kỷ qua. Chúng ta thấy có rất nhiều chuyện đang diễn ra.
We actually talk about more traditional technology now, right?
Bây giờ hãy nói về công nghệ truyền thống hơn.
A lot of different companies, and also located in different countries, actually have the ability to actually make semiconductors and fabricate their own semiconductors for those different, especially older, technology generations.
Có rất nhiều công ty khác nhau, đặt ở nhiều quốc gia khác nhau, đều có khả năng sản xuất chất bán dẫn và tự chế tạo chất bán dẫn của mình cho những thế hệ công nghệ khác nhau, đặc biệt là các thế hệ cũ hơn.
One thing really interesting, and in some sense a little bit alarming, is that when we actually get to more advanced technology now, so what we show here is roughly five nanometer, seven nanometer, we see there are actually not many players left.
Một điều rất thú vị, và theo một nghĩa nào đó hơi đáng lo, là khi chúng ta đi đến công nghệ tiên tiến hơn, ở đây là khoảng năm nanomet, bảy nanomet, chúng ta thấy thực sự không còn nhiều đơn vị tham gia.
So here we basically see Samsung, TSMC and Intel. So, oh, let me, there is Intel, right? So those are basically the major players, right?
Ở đây về cơ bản chúng ta thấy Samsung, TSMC và Intel. À, để tôi xem, Intel đây. Đó về cơ bản là những đơn vị chủ chốt.
We already mentioned, when we actually get to very advanced node, not many actually fabs are able to actually fabricate it, right?
Như đã nói, khi đến các node rất tiên tiến, không có nhiều nhà máy đủ khả năng chế tạo.
So a lot of fab based companies these days, they actually need to compete for resources, compete for slots in TSMC or Samsung, or especially today, these days, Intel is also opening up their fab, right?
Vì vậy ngày nay nhiều công ty dựa vào fab cần phải cạnh tranh về nguồn lực, cạnh tranh giành suất sản xuất tại TSMC hay Samsung, hoặc đặc biệt là ngày nay, Intel cũng đang mở fab của họ ra cho bên ngoài, đúng không?
So they can also have more customers there. So we actually need to compete for those resources, get our chips fabricated. Things are not so bad in more like older generation, older technology generation.
Như vậy họ cũng có thể có thêm khách hàng. Vì vậy chúng ta thực sự phải cạnh tranh để giành những nguồn lực đó, để chip của mình được chế tạo. Với các thế hệ công nghệ cũ hơn thì mọi chuyện không đến nỗi tệ như vậy.
We see roughly 28, let's see whether this is, yeah, 28, 32, right?
Chúng ta thấy khoảng 28, để xem có phải không, vâng, 28, 32, đúng không?
We, like those older technology generation, there are still a handful of players left, but we are actually talking about those very advanced technology, right? Those are actually where the competition really matters.
Với những thế hệ công nghệ cũ hơn đó, vẫn còn một số ít hãng tham gia, nhưng ở đây chúng ta đang nói về những công nghệ rất tiên tiến, đúng không? Đó mới là nơi sự cạnh tranh thực sự có ý nghĩa.
And a lot of today's investment, both from government or from individual VCs, really thinking about how we can actually set up more advanced fab facilities, both here in the US or internationally, globally.
Và rất nhiều khoản đầu tư ngày nay, cả từ chính phủ lẫn từ các quỹ đầu tư mạo hiểm, đang suy nghĩ về cách xây dựng thêm các cơ sở fab tiên tiến hơn, cả ở Mỹ lẫn trên phạm vi quốc tế, toàn cầu.
We also see different governments actually also trying to set up their own chips act, right?
Chúng ta cũng thấy nhiều chính phủ khác nhau đang cố gắng xây dựng đạo luật chip của riêng họ, đúng không?
One thing really interesting, this is a little bit, I guess, last year, early this year, you will look at those different, we'll have three players, right? TSMC, Samsung and Intel, right?
Có một điều thực sự thú vị, đây là chuyện từ khoảng năm ngoái, đầu năm nay, tôi nghĩ vậy, khi nhìn vào những hãng khác nhau này, chúng ta có ba hãng, đúng không? TSMC, Samsung và Intel, đúng không?
Intel has been a little bit struggling, especially starting from 14 to 10 nanometer nodes, right? We expect things will get better when we actually go to even smaller, more advanced node.
Intel đã gặp một chút khó khăn, đặc biệt bắt đầu từ các node 14 đến 10 nanomet, đúng không? Chúng ta kỳ vọng mọi thứ sẽ tốt lên khi đi tới các node nhỏ hơn nữa, tiên tiến hơn.
But in the meantime, We also see this interesting interactions between Intel and TSMC. It's not like Intel will only use their fab, right?
Nhưng trong lúc đó, chúng ta cũng thấy sự tương tác thú vị giữa Intel và TSMC. Không phải Intel chỉ dùng fab của chính họ, đúng không?
If their fabs are actually falling behind, especially for current technology generation, they are actually very open to actually also use other vendors, in this case TSMC, to build their advanced node, right?
Nếu các fab của họ đang bị tụt lại, đặc biệt với thế hệ công nghệ hiện tại, thì họ rất sẵn sàng sử dụng các nhà cung cấp khác, trong trường hợp này là TSMC, để chế tạo node tiên tiến của họ, đúng không?
Because they need to actually build their products, sell their products, they need to make sure their products stay competitive. Now, this can be alarming with this kind of dependencies, right?
Bởi vì họ cần làm ra sản phẩm, bán sản phẩm, họ cần đảm bảo sản phẩm của mình giữ được tính cạnh tranh. Điều này có thể đáng lo ngại với kiểu phụ thuộc như vậy, đúng không?
So Intel is actually trying really hard to build like more advanced fab so that they can actually stay competitive in this very small, but also very important business.
Vì vậy Intel đang rất nỗ lực xây dựng các fab tiên tiến hơn để có thể giữ được khả năng cạnh tranh trong lĩnh vực kinh doanh rất nhỏ, nhưng cũng rất quan trọng này.
The fab industry, chip industry is actually getting really interesting and also super competitive with those fab vendors. They are actually trying really hard, especially in terms of getting to advanced technology.
Ngành fab, ngành chip đang trở nên thực sự thú vị và cũng cạnh tranh cực kỳ gay gắt giữa các nhà cung cấp fab. Họ đang rất nỗ lực, đặc biệt trong việc tiến tới công nghệ tiên tiến.
And we also see a lot of interactions between those vendors to stay competitive, both at the fab level, but also at the design level.
Và chúng ta cũng thấy nhiều tương tác giữa các nhà cung cấp này để giữ khả năng cạnh tranh, không chỉ ở cấp độ fab mà cả ở cấp độ thiết kế.
So, something interesting on the fabrication side, and we'll see more things, especially Intel setting up a lot more fabs here domestically, right?
Vậy đó là một điều thú vị về mặt chế tạo, và chúng ta sẽ còn thấy nhiều hơn nữa, đặc biệt là việc Intel xây dựng thêm nhiều fab ngay trong nước, đúng không?
So that will also open up both Intel as a competitor in the fabrication business, but also Intel really as a vendor, where a lot of interesting design could be potentially fabricated actually here at Intel.
Điều đó sẽ mở ra không chỉ việc Intel là đối thủ cạnh tranh trong lĩnh vực chế tạo chip, mà còn Intel thực sự là một nhà cung cấp, nơi nhiều thiết kế thú vị có thể được chế tạo ngay tại Intel ở đây.
Okay, so that's the fab side. And let's move on to today's discussion. We'll talk about fabrication, but we still need to design to actually get to fabrication.
Được rồi, đó là phần về fab. Và chúng ta chuyển sang nội dung thảo luận hôm nay. Chúng ta sẽ nói về chế tạo, nhưng vẫn cần thiết kế thì mới có thể đi đến chế tạo.
And basically this week, we'll basically talk about Verilog, and that's a language, especially for digital design, that we actually use this language to describe different designs and eventually use synthesis tools.
Và về cơ bản, tuần này chúng ta sẽ nói về Verilog, đây là một ngôn ngữ dùng riêng cho thiết kế số, chúng ta dùng ngôn ngữ này để mô tả các thiết kế khác nhau và cuối cùng dùng các công cụ tổng hợp.
We talked about different tools actually also last lecture. Use synthesis tool to actually get to the final design. Last, we'll talk about different design metrics.
Bài giảng trước chúng ta cũng đã nói về các công cụ khác nhau. Dùng công cụ tổng hợp để đi đến thiết kế cuối cùng. Cuối cùng, chúng ta sẽ nói về các tiêu chí thiết kế khác nhau.
Functionality is always the most important one, but also power, performance, Energy, very important, very qualitative metrics, and also cost, because the semiconductor industry will eventually need to sell products to our customer, right?
Chức năng luôn là tiêu chí quan trọng nhất, nhưng cũng có công suất, hiệu năng, năng lượng, đều là những tiêu chí định lượng rất quan trọng, và cả chi phí, vì ngành bán dẫn cuối cùng cũng cần bán sản phẩm cho khách hàng, đúng không?
How we can actually maintain the cost of both design, verification, and fabrication, but also produce competitive products. That's very important.
Làm sao kiểm soát được chi phí thiết kế, kiểm chứng và chế tạo, mà vẫn tạo ra được sản phẩm có tính cạnh tranh. Điều đó rất quan trọng.
And the Verilog, I've mentioned one most important message I want to convey is like this is really hardware description language. We actually want to describe hardware.
Còn về Verilog, tôi đã nói thông điệp quan trọng nhất tôi muốn truyền đạt là đây thực sự là ngôn ngữ mô tả phần cứng. Chúng ta thực sự muốn mô tả phần cứng.
And the Verilog language is basically used, it's a state of art language that's used in the industry.
Và ngôn ngữ Verilog về cơ bản được dùng, đây là ngôn ngữ hiện đại nhất được dùng trong công nghiệp.
If you learn this language, you will be actually able to actually design also other products in different hardware, software vendors. This is also the language that most basic and FPGA lab, right?
Nếu bạn học ngôn ngữ này, bạn cũng sẽ có thể thiết kế các sản phẩm khác ở nhiều hãng phần cứng, phần mềm khác nhau. Đây cũng là ngôn ngữ dùng trong hầu hết các bài thực hành FPGA, đúng không?
So this is, let's say, you will be basically using different tools to synthesize the language into different hardware implementation, but the language is the same.
Vậy nên, giả sử như, bạn sẽ dùng các công cụ khác nhau để tổng hợp ngôn ngữ này thành các cách hiện thực phần cứng khác nhau, nhưng ngôn ngữ thì vẫn như nhau.
In today's lecture, we're going to go slightly, go deeper into the language, see how this language, what's really, what are the syntax of this language and how we can actually use this language to describe both computational logic and this logic.
Trong bài giảng hôm nay, chúng ta sẽ đi sâu hơn một chút vào ngôn ngữ này, xem ngôn ngữ này thực sự là gì, cú pháp của nó ra sao và làm sao dùng ngôn ngữ này để mô tả cả logic tính toán lẫn logic tuần tự.
So we get to Verilog, one of the most important syntax is this module. So this is basically, you can think about like a data structure that you use in a traditional programming language.
Vậy với Verilog, một trong những cú pháp quan trọng nhất là module. Về cơ bản, bạn có thể xem nó giống như một cấu trúc dữ liệu mà bạn dùng trong ngôn ngữ lập trình truyền thống.
So this is basically the way to actually define a component in the circuit. We'll see a little bit more example in a minute, but module is basically, you can think about like building blocks.
Đây là cách để định nghĩa một thành phần trong mạch. Lát nữa chúng ta sẽ xem thêm ví dụ, nhưng module về cơ bản bạn có thể xem như các khối xây dựng.
This is a basic building block that we use to describe different components in circuit. Typically, there are two ways to describe those modules or design those data structures.
Đây là khối xây dựng cơ bản mà chúng ta dùng để mô tả các thành phần khác nhau trong mạch. Thông thường có hai cách để mô tả các module này hay thiết kế các cấu trúc dữ liệu đó.
One is using structure, Verilog, structural Verilog. This is basically, as the name suggests, is basically literally describing the structure of circuit. We'll see an example later.
Một là dùng Verilog cấu trúc, structural Verilog. Đúng như tên gọi, nó mô tả trực tiếp cấu trúc của mạch. Lát nữa chúng ta sẽ xem một ví dụ.
We'll basically see what are the gates that we want to use and connect those gates, just happen to be Verilog.
Chúng ta sẽ xem các cổng nào mà ta muốn dùng và nối các cổng đó với nhau, chỉ là tình cờ viết bằng Verilog.
In reality, In today's design job, most of the time, we will actually never use structural Verilog. Most time, we'll basically just use behavior Verilog.
Thực tế, trong công việc thiết kế ngày nay, phần lớn thời gian, chúng ta gần như sẽ không bao giờ dùng Verilog cấu trúc. Hầu hết thời gian, chúng ta chỉ dùng Verilog hành vi.
So this one is a lot more important, but we'll still talk about what are the differences. What do we mean by structural Verilog and behavior Verilog?
Vì vậy cái này quan trọng hơn nhiều, nhưng chúng ta vẫn sẽ nói về những điểm khác biệt. Verilog cấu trúc và Verilog hành vi nghĩa là gì?
As the name suggests, behavior Verilog is more actually describing what the component does, what's the functionality of this component, but not necessarily the direct implementation. It's a lot easier to design.
Đúng như tên gọi, Verilog hành vi mô tả linh kiện đó làm gì, chức năng của linh kiện này là gì, chứ không nhất thiết là cách hiện thực trực tiếp. Cách này dễ thiết kế hơn nhiều.
We'll describe the component at the higher level instead of doing this low-level implementation.
Chúng ta mô tả linh kiện ở mức cao hơn thay vì hiện thực ở mức thấp.
Very importantly, we also mentioned that in the layers of abstraction, in any of the designs, what we are really doing is basically building a hierarchy of modules.
Rất quan trọng, chúng ta cũng đã nhắc đến các tầng trừu tượng, trong bất kỳ thiết kế nào, điều chúng ta thực sự làm là xây dựng một hệ phân cấp các module.
You'll have the basic building blocks, connecting different basic building blocks together, you'll get a higher level module. And then remember the layers of abstraction. So this is more like a bottom-up approach.
Bạn có các khối xây dựng cơ bản, nối các khối cơ bản khác nhau lại với nhau, bạn sẽ có một module ở mức cao hơn. Và hãy nhớ đến các tầng trừu tượng. Đây giống một cách tiếp cận từ dưới lên.
We can talk about each individual module. You can also think about different libraries, different library components, and then you can just instantiate those components in your design to build more complex examples.
Chúng ta có thể nói về từng module riêng lẻ. Bạn cũng có thể nghĩ đến các thư viện, các thành phần thư viện khác nhau, rồi bạn chỉ cần khởi tạo các thành phần đó trong thiết kế để xây dựng những ví dụ phức tạp hơn.
Again, we'll see more examples later. It's a little bit abstract, but in most of the discussion and in today's industry, when you use Verilog, you'll be using behavior Verilog.
Một lần nữa, lát nữa chúng ta sẽ xem thêm ví dụ. Hơi trừu tượng một chút, nhưng trong hầu hết các thảo luận và trong ngành hiện nay, khi dùng Verilog, bạn sẽ dùng Verilog hành vi.
Very rarely will we actually be talking about structural Verilog. So we already talked about modules, right? What do we mean by module, and how do we actually instantiate a module?
Rất hiếm khi chúng ta thực sự nói đến Verilog cấu trúc. Chúng ta đã nói về module rồi, đúng không? Module nghĩa là gì, và làm sao để khởi tạo một module?
So basically, as the name suggests, a module is basically describing a modular component existing in our digital circuit. And then we can actually instantiate the module. Remember the data structure example?
Đúng như tên gọi, module mô tả một thành phần mang tính mô-đun tồn tại trong mạch số của chúng ta. Và sau đó chúng ta có thể khởi tạo module. Nhớ ví dụ về cấu trúc dữ liệu chứ?
Each data structure defines a component that we can use. And when we need that component, we can just instantiate that component in our implementation.
Mỗi cấu trúc dữ liệu định nghĩa một thành phần mà chúng ta có thể dùng. Và khi cần thành phần đó, chúng ta chỉ cần khởi tạo thành phần đó trong phần hiện thực của mình.
A couple of keywords or structures or syntax you will see after we interact with the Verilog language. So first, module, right? We already talked about module.
Một vài từ khóa hay cấu trúc hay cú pháp mà bạn sẽ thấy khi làm việc với ngôn ngữ Verilog. Đầu tiên là module, đúng không? Chúng ta đã nói về module rồi.
You can think about a declaration of a data structure, right? Whenever you'll see a module, it's always a pair.
Bạn có thể xem nó như khai báo một cấu trúc dữ liệu, đúng không? Bất cứ khi nào bạn thấy module, nó luôn đi thành một cặp.
We see a starting, the beginning of module, and we also see the end of a module, right? So whenever you instantiate a module, there's module and then endmodule, right?
Chúng ta thấy phần bắt đầu của module, và cũng thấy phần kết thúc của module, đúng không? Vậy khi bạn khởi tạo một module, có module rồi đến endmodule, đúng không?
So that's a pair. Those are the keywords that we'll be using. And the same when we declare a data structure, right? We need to give them a name, right?
Đó là một cặp. Đó là những từ khóa chúng ta sẽ dùng. Và tương tự khi chúng ta khai báo một cấu trúc dữ liệu, đúng không? Chúng ta cần đặt tên cho chúng, đúng không?
So here we are actually building an adder cell. So this will be the name of this module, right? So that we can actually instantiate later.
Ở đây chúng ta thực sự đang xây dựng một adder cell. Đây sẽ là tên của module này, đúng không? Để sau này chúng ta có thể khởi tạo nó.
And this is also similar to, I guess, the argument list that we used to have in other programming languages. Here we have a port list.
Và điều này cũng tương tự, tôi đoán là vậy, như danh sách đối số mà chúng ta thường có trong các ngôn ngữ lập trình khác. Ở đây chúng ta có một danh sách cổng (port list).
We use a port list because we're still instantiating hardware, right? The interface between my current module and other modules will basically be input and output, right?
Chúng ta dùng danh sách cổng vì chúng ta vẫn đang khởi tạo phần cứng, đúng không? Giao diện giữa module hiện tại của tôi và các module khác về cơ bản sẽ là đầu vào và đầu ra, đúng không?
So those are basically the input and output ports that are actually used. IO ports are actually used in this module declaration, right?
Vậy đó về cơ bản là các cổng đầu vào và đầu ra được sử dụng. Các cổng IO được sử dụng trong phần khai báo module này, đúng không?
You can think of them as like an argument list, but again, they actually have physical meanings, right? Those are actually ports, IO ports actually used in hardware, right?
Bạn có thể coi chúng như một danh sách đối số, nhưng một lần nữa, chúng thực sự có ý nghĩa vật lý, đúng không? Đó là các cổng, các cổng IO thực sự được dùng trong phần cứng, đúng không?
Then again, internally, we need to actually clearly declare whether they're actually input or output, right? So for this adder cell, we have three inputs, A, B, and the carry in.
Sau đó, bên trong, chúng ta cần khai báo rõ ràng chúng là đầu vào hay đầu ra, đúng không? Vậy với adder cell này, chúng ta có ba đầu vào: A, B và carry in.
We have outputs of sum and the carry out, right? So that's the input and output.
Chúng ta có các đầu ra là sum và carry out, đúng không? Đó là đầu vào và đầu ra.
We'll skip the module body for now because that's actually related to the structure and the behavior overlap we discussed earlier. We'll talk about that later, right?
Chúng ta tạm bỏ qua phần thân module vì nó liên quan đến sự chồng lấn giữa cấu trúc và hành vi mà chúng ta đã bàn trước đó. Chúng ta sẽ nói về điều đó sau, đúng không?
But we'll talk about how we actually instantiate a module. So here, so far, we have basically only defined this data structure, right? But we need to use this data structure in our design.
Nhưng chúng ta sẽ nói về cách khởi tạo một module. Vậy cho đến giờ, chúng ta về cơ bản mới chỉ định nghĩa cấu trúc dữ liệu này, đúng không? Nhưng chúng ta cần sử dụng cấu trúc dữ liệu này trong thiết kế của mình.
Let's say here we build the adder cell and we actually want to use this cell in the top level, in a higher level module called adder, right?
Giả sử ở đây chúng ta xây dựng adder cell và muốn dùng cell này ở mức trên cùng, trong một module mức cao hơn có tên là adder, đúng không?
So here the hierarchy is, this is my adder design, and inside my adder design we have adder cell, right? So this is a hierarchy.
Vậy phân cấp ở đây là: đây là thiết kế adder của tôi, và bên trong thiết kế adder có adder cell, đúng không? Đây là một phân cấp.
My top level is this adder, and then we instantiate this adder cell here, right? So when we want to instantiate this adder cell, we basically create an instance.
Mức trên cùng của tôi là adder này, rồi chúng ta khởi tạo adder cell này ở đây, đúng không? Khi muốn khởi tạo adder cell này, về cơ bản chúng ta tạo một thực thể (instance).
This is actually we create an instance of this module, right? We have this module name. Remember the name of the module? We have the module name here.
Tức là chúng ta tạo một instance của module này, đúng không? Chúng ta có tên module này. Nhớ tên của module chứ? Chúng ta có tên module ở đây.
And then we actually gave a name that in this instance, right, we call it AC1 in this instance. I will talk about this later. We basically need to specify the connection, right?
Rồi chúng ta đặt một cái tên cho instance này, đúng không, ta gọi nó là AC1 trong instance này. Tôi sẽ nói về điều này sau. Về cơ bản chúng ta cần chỉ định kết nối, đúng không?
How the IOs are actually connected in this top level. We have three input and two output, right? Those IO ports need to be connected in a top level.
Các IO được kết nối như thế nào ở mức trên cùng này. Chúng ta có ba đầu vào và hai đầu ra, đúng không? Các cổng IO đó cần được kết nối ở mức trên cùng.
All right, so again, so here's a high level. We talk about modules, always this pair, module and endmodule.
Được rồi, vậy đây là cái nhìn ở mức cao. Khi nói về module, luôn có cặp này: module và endmodule.
So we have a pair, we define this data structure, and then we instantiate this data structure in a top level module.
Vậy chúng ta có một cặp, định nghĩa cấu trúc dữ liệu này, rồi khởi tạo cấu trúc dữ liệu này trong một module mức trên cùng.
And then we basically use a module name and give it a name here. As I mentioned here, this is actually more like a data structure.
Và về cơ bản chúng ta dùng tên module rồi đặt cho nó một cái tên ở đây. Như tôi đã đề cập, cái này thực ra giống một cấu trúc dữ liệu hơn.
Some students like to actually think this is more like function.
Một số sinh viên thích nghĩ nó giống một hàm hơn.
I mean, there are some similarity in a function because like, if you think about like a library component, you can reuse it, but there's never like a call, like calling conventions or parameter passing, because everything's actually hardware.
Ý tôi là, có một số điểm tương đồng với hàm vì, nếu bạn nghĩ về một thành phần thư viện, bạn có thể tái sử dụng nó, nhưng không bao giờ có lời gọi, tức là quy ước gọi hay truyền tham số, vì mọi thứ thực chất đều là phần cứng.
We literally create a copy of hardware, right? So the analogy I like to use is actually more like a data structure where you instantiate this data structure.
Chúng ta tạo ra đúng nghĩa đen một bản sao của phần cứng, đúng không? Vì vậy phép so sánh tôi thích dùng hơn là với cấu trúc dữ liệu, trong đó bạn khởi tạo cấu trúc dữ liệu này.
So that's, I guess, a general hierarchy and the keywords related to Verilog, especially Verilog modules. Questions before we move on?
Đó, tôi nghĩ, là phân cấp chung và các từ khóa liên quan đến Verilog, đặc biệt là các module Verilog. Có câu hỏi nào trước khi chúng ta đi tiếp không?
Oh, what is input output, Yumi? Oh, you mean the C in and the C out? Oh, those are just name, the port name, right?
À, input output là gì vậy Yumi? À, ý bạn là C in và C out phải không? À, đó chỉ là tên thôi, tên cổng, đúng không?
So like for this adder cell, This is my adder.
Ví dụ như với ô cộng này, đây là bộ cộng của tôi.
Well, we actually have input A, input B and the carry in, and we have the sum and the carry out. So those are modules specific to the name we gave for each port.
Chúng ta có đầu vào A, đầu vào B và carry in, và có sum cùng carry out. Đó là những tên riêng của module mà chúng ta đặt cho từng cổng.
Oh, you're asking about inout here, right? So inout is something you can actually use both as input and we'll talk about that later, but that's also instantiation we actually also use.
À, bạn đang hỏi về inout ở đây, đúng không? Inout là thứ bạn có thể dùng vừa làm đầu vào và chúng ta sẽ nói về nó sau, nhưng đó cũng là một kiểu khởi tạo mà chúng ta có dùng.
Okay, we'll see a little bit more example. This is very high level. Specifically, I like to get the notion of the data structure first. Question?
Được rồi, chúng ta sẽ xem thêm một chút ví dụ. Đây là mức rất cao. Cụ thể, tôi muốn các bạn nắm khái niệm cấu trúc dữ liệu trước. Câu hỏi?
Oh, you mean the A, B, S here? So this is basically the port list for this top level module. So now for this top level module, it's probably multi-bit.
À, ý bạn là A, B, S ở đây phải không? Đây về cơ bản là danh sách cổng của module cấp cao nhất này. Với module cấp cao nhất này, có lẽ chúng nhiều bit.
So then we also have A, B and S, right? So this is basically the input output for the top level module, right?
Vậy chúng ta cũng có A, B và S, đúng không? Đây về cơ bản là đầu vào đầu ra của module cấp cao nhất, đúng không?
It's the same as the port list. Yeah, we don't have, yeah. We are missing some code here. Yeah, we didn't define it, yeah.
Nó giống với danh sách cổng. Vâng, chúng ta không có, vâng. Ở đây chúng ta đang thiếu một ít mã. Vâng, chúng ta chưa định nghĩa nó.
It doesn't make a difference on performance. It's mostly for readability. I recommend to have some structure so that it's actually clear what are the inputs and what are the outputs.
Nó không tạo khác biệt về hiệu năng. Chủ yếu là để dễ đọc. Tôi khuyên bạn nên có một cấu trúc nào đó để rõ ràng đâu là đầu vào và đâu là đầu ra.
We'll also talk about like the main port later and that also create more for readability. One thing you will realize that sometimes it's actually very hard to read Verilog, very confusing.
Chúng ta cũng sẽ nói về cổng chính sau và điều đó cũng giúp mã dễ đọc hơn. Bạn sẽ nhận ra có lúc Verilog rất khó đọc, rất rối.
So a lot of this syntax are really for readability. We'll get to some a little bit more example in a minute. Okay, so we talk about the module and hierarchy, right?
Vì vậy nhiều cú pháp này thực sự là để dễ đọc. Chút nữa chúng ta sẽ xem thêm vài ví dụ. Được rồi, vậy chúng ta đã nói về module và phân cấp, đúng không?
We briefly mentioned the structure of Verilog. Again, we rarely use that, especially when it goes through interview when you are asked, right? So it's basically literally translate a schematic, something like this.
Chúng ta đã nhắc sơ qua về cấu trúc của Verilog. Một lần nữa, chúng ta hiếm khi dùng cách đó, nhất là khi phỏng vấn, khi các bạn được hỏi, đúng không? Về cơ bản nó dịch đúng nghĩa đen một sơ đồ mạch, kiểu như thế này.
Well, in this case, we're doing an XOR gate into the Verilog. So we basically use the Verilog building gates. So if you look at the left and the right hand side, right?
Ở đây, chúng ta đang chuyển một cổng XOR sang Verilog. Chúng ta dùng các cổng dựng sẵn của Verilog. Nếu nhìn bên trái và bên phải, đúng không?
So basically to build an XOR gate, we're not getting into schematic details, but you basically need two inverters, two AND gates and an OR gate, right?
Để xây một cổng XOR, chúng ta sẽ không đi vào chi tiết sơ đồ mạch, nhưng về cơ bản bạn cần hai cổng đảo, hai cổng AND và một cổng OR, đúng không?
So you could also, we'll see another example later, we can just describe the XOR behavior directly using the Verilog XOR operator.
Bạn cũng có thể, lát nữa chúng ta sẽ xem một ví dụ khác, chúng ta có thể mô tả trực tiếp hành vi XOR bằng toán tử XOR của Verilog.
But here you could actually instantiate the structural Verilog by actually explicitly using the built-in gates and using the wires. We'll see those wire connections here to connect input and output of the gates, right?
Nhưng ở đây bạn thực sự có thể khởi tạo Verilog theo kiểu cấu trúc, bằng cách dùng tường minh các cổng có sẵn và dùng các dây nối. Chúng ta sẽ thấy các kết nối dây ở đây để nối đầu vào và đầu ra của các cổng, đúng không?
We still follow the same convention where we basically instantiate a different module here. But we basically use the built-in, the fundamental built-in gates where we actually do the instantiation.
Chúng ta vẫn theo cùng một quy ước, tức là khởi tạo một module khác ở đây. Nhưng chúng ta dùng các cổng có sẵn, các cổng cơ bản có sẵn mà chúng ta thực hiện khởi tạo.
Okay, this is very rarely used these days, but it's because it's just very tedious, right? Very low level.
Được rồi, ngày nay cách này rất hiếm khi được dùng, vì nó quá rườm rà, đúng không? Rất ở mức thấp.
You need to actually see how it's built and also write a lot of code to actually describe sometimes a simple operator. So Verilog actually has a very rich set of operators.
Bạn phải thực sự biết nó được xây dựng như thế nào và còn phải viết rất nhiều mã để mô tả đôi khi chỉ là một toán tử đơn giản. Verilog thực ra có một tập toán tử rất phong phú.
We'll also see in a minute how to actually describe those behaviors. So don't worry too much about it, but structural Verilog basically you literally actually describe the internal gates of the implementation.
Lát nữa chúng ta cũng sẽ xem cách mô tả những hành vi đó. Nên đừng lo lắng quá về điều này, nhưng với Verilog cấu trúc, bạn thực sự mô tả từng cổng bên trong của phần hiện thực.
Again, today, especially for more complex circuits, right? Very tedious. So we actually use more complex syntax to describe other circuits. So what do we mean by behavioral Verilog?
Một lần nữa, ngày nay, nhất là với các mạch phức tạp hơn thì rất rườm rà. Vì vậy chúng ta dùng cú pháp phức tạp hơn để mô tả các mạch khác. Vậy Verilog hành vi nghĩa là gì?
How would we actually write this example in behavioral Verilog?
Chúng ta sẽ viết ví dụ này bằng Verilog hành vi như thế nào?
So this is, again, this is actually very similar to the way we actually use other programming languages, right? We basically literally just like, I guess we are using an AND gate here, right?
Một lần nữa, điều này rất giống với cách chúng ta dùng các ngôn ngữ lập trình khác, đúng không? Về cơ bản, ở đây chúng ta đang dùng một cổng AND, đúng không?
So we basically use the AND gate directly, again, input and output, and we actually assign to the output, right? So you will see this assign keyword here. This is basically another keyword.
Nên chúng ta dùng trực tiếp cổng AND, vẫn là đầu vào và đầu ra, và gán giá trị cho đầu ra, đúng không? Bạn sẽ thấy từ khóa assign ở đây. Đây là một từ khóa khác.
We'll also talk a little bit more later. This is basically what we use to actually do a continuous assignment. It's a continuous assignment. You can think about the combinational logic.
Chúng ta cũng sẽ nói thêm về nó sau. Đây là thứ chúng ta dùng để thực hiện phép gán liên tục. Đó là phép gán liên tục. Bạn có thể xem nó như logic tổ hợp.
Whenever the input changes, either input one or input two changes, the output also changes. So this is actually more commonly used to describe Verilog.
Bất cứ khi nào đầu vào thay đổi, dù là đầu vào một hay đầu vào hai thay đổi, đầu ra cũng thay đổi. Cách này thực ra được dùng phổ biến hơn để mô tả bằng Verilog.
We don't actually need to instantiate, in this case, like what we did before, an AND gate, blah, blah, blah, but we actually just have this AND operator.
Trong trường hợp này, chúng ta không cần khởi tạo một cổng AND như đã làm trước đó, v.v., mà chỉ cần dùng toán tử AND này.
We'll see a list of supported operators in Verilog in a minute. This is actually more commonly used.
Lát nữa chúng ta sẽ xem danh sách các toán tử được Verilog hỗ trợ. Cách này được dùng phổ biến hơn.
Another terminology, just to clarify, what sometimes you will actually read the document or how to read Verilog code, you will see people say right-hand side or left-hand side, right?
Một thuật ngữ khác, để làm rõ, đôi khi khi đọc tài liệu hoặc cách đọc mã Verilog, bạn sẽ thấy người ta nói vế phải hoặc vế trái, đúng không?
So right-hand side is basically whatever happened after the equal sign, and left-hand side is basically whatever happened before the equal sign, right?
Vế phải là phần nằm sau dấu bằng, còn vế trái là phần nằm trước dấu bằng, đúng không?
So here with a continuous assignment, whatever, whenever the output changes, any of the signals in the output change, the input, sorry, any of the signals on the right-hand side change, changes will actually be propagated to the left-hand side.
Vậy ở đây với phép gán liên tục, bất cứ khi nào đầu ra thay đổi, bất kỳ tín hiệu nào ở đầu ra thay đổi, đầu vào, xin lỗi, nếu bất kỳ tín hiệu nào ở vế phải thay đổi, thì các thay đổi đó sẽ được lan truyền sang vế trái.
So the left-hand side signal also changes. So that's also another reason why we call it continuous assignment. You can think about it basically as a wire, right?
Vì vậy tín hiệu ở vế trái cũng thay đổi. Đó cũng là một lý do khiến ta gọi nó là phép gán liên tục. Về cơ bản bạn có thể hình dung nó như một sợi dây, đúng không?
Whenever wire after a gate, whenever any input, let's say an AND gate, right? Changes, right? The output also changes.
Mỗi khi dây sau một cổng, mỗi khi có đầu vào nào, giả sử là cổng AND, đúng không? Thay đổi, thì đầu ra cũng thay đổi.
We'll see in a minute actually for, so this is only true for combinational logic, but not for sequential logic because there's a clock component, right?
Lát nữa ta sẽ thấy, điều này chỉ đúng với logic tổ hợp, chứ không đúng với logic tuần tự vì có thành phần xung nhịp, đúng không?
We only update the value if the clock actually changes. Right, so as what we have in the text, right? There's continuous happen.
Ta chỉ cập nhật giá trị khi xung nhịp thực sự thay đổi. Đúng rồi, như trong giáo trình, nó xảy ra liên tục.
Any changes on the right-hand side is reflected on the left-hand side, right? So this is, and it's something happened in hardware combinationally, and there could be multiple assignments, right?
Mọi thay đổi ở vế phải đều được phản ánh ở vế trái, đúng không? Vậy đây là điều xảy ra trong phần cứng theo kiểu tổ hợp, và có thể có nhiều phép gán, đúng không?
Whenever certain things on the right-hand side change, the output, the assigned value on the left-hand side also changes. So that's continuous assignment. Questions, but, mm-hmm?
Mỗi khi có thứ gì đó ở vế phải thay đổi, đầu ra, tức giá trị được gán ở vế trái, cũng thay đổi. Đó là phép gán liên tục. Có câu hỏi nào không, à, mời bạn?
What is the, let's say we have another assign statement.
Giả sử ta có thêm một câu lệnh assign khác.
Let's say we have, let's say we have A equals to out, just out, A is the same as out, or maybe let's do A AND B, some other combination, right?
Giả sử ta có A bằng out, chỉ out thôi, A giống như out, hoặc có thể làm A AND B, một tổ hợp khác, đúng không?
So if out is changed, we have the input, and input one and input two changes, right? So A also changes. You can basically think of this as a combinational circuit.
Nếu out thay đổi, ta có đầu vào, và đầu vào một và đầu vào hai thay đổi, đúng không? Thì A cũng thay đổi. Về cơ bản bạn có thể coi đây là một mạch tổ hợp.
Input one, input two, we have AND gate, and we have AND gate, and this is out. And we have another AND gate here. Actually, this is B, and this is A, right?
Đầu vào một, đầu vào hai, ta có cổng AND, rồi lại một cổng AND, và đây là out. Và ta có thêm một cổng AND nữa ở đây. Thực ra đây là B, và đây là A, đúng không?
So whenever anything changes here, all the values propagate to the output. Everything is a combinational circuit. So sometimes it's useful to think about in a hardware perspective, right?
Mỗi khi có gì thay đổi ở đây, mọi giá trị đều lan truyền tới đầu ra. Tất cả đều là mạch tổ hợp. Vì vậy đôi khi nên suy nghĩ theo góc nhìn phần cứng.
So we are basically having values propagate through the circuit. We have multiple assignments. They basically instantiate this hardware. Anything in the input changes, output just changes accordingly.
Về cơ bản các giá trị lan truyền qua mạch. Ta có nhiều phép gán. Chúng tạo ra (instantiate) phần cứng này. Đầu vào có thay đổi gì thì đầu ra thay đổi tương ứng.
Oh, you are switching A to B out. You mean having a loop here? Oh, this is, we'll talk a little bit later, right? But now it's basically you have a combinational loop here, right?
À, bạn đang đổi A thành B ra out. Ý bạn là tạo một vòng lặp ở đây? À, cái này lát nữa ta sẽ nói, đúng không? Nhưng bây giờ về cơ bản bạn có một vòng lặp tổ hợp ở đây.
Because whenever out changes, A changes, and then you actually reflect it. This is basically, you will see actually in your tool, this is a combinatorial loop, and this is not a unique loop.
Vì mỗi khi out thay đổi thì A thay đổi, rồi nó lại được phản ánh trở lại. Về cơ bản bạn sẽ thấy ngay trong công cụ của mình, đây là một vòng lặp tổ hợp, và nó không xác định được một giá trị duy nhất.
There's no meaning, right? Why would we actually want to have a circuit like this, right? So designing a valid circuit is also very important.
Nó không có ý nghĩa gì cả. Tại sao ta lại muốn có một mạch như thế này? Vì vậy việc thiết kế một mạch hợp lệ cũng rất quan trọng.
So when this goes through the synthesis tool, it will actually complain. They say it's a combinatorial loop here. Again, we'll see a little bit more example later. Don't get too, don't worry too much.
Khi nó đi qua công cụ tổng hợp, công cụ sẽ báo lỗi. Nó sẽ báo là có một vòng lặp tổ hợp ở đây. Một lần nữa, lát nữa ta sẽ xem thêm ví dụ. Đừng quá lo lắng.
Just understanding the syntax. But one thing is that it's always useful to think about the hardware representation because we're using this language to describe hardware. So think about the hardware representation here.
Cứ hiểu cú pháp đã. Nhưng có một điều là luôn nên nghĩ đến cách biểu diễn phần cứng, vì ta đang dùng ngôn ngữ này để mô tả phần cứng. Vì vậy hãy nghĩ đến cách biểu diễn phần cứng ở đây.
So combinational circuit, any of the input changes, the value actually propagates to output.
Với mạch tổ hợp, khi bất kỳ đầu vào nào thay đổi, giá trị đó sẽ lan truyền ra đầu ra.
Okay, so it has, oh, question.
Okay, nên nó có, ồ, có câu hỏi.
The indentation, oh, it doesn't matter. But it's still good to have, follow your convention. Yeah, it doesn't matter. Good question. Okay, we talk a lot of different things, right?
Việc thụt lề ấy à, không quan trọng. Nhưng vẫn nên tuân theo quy ước của mình. Vâng, không quan trọng. Câu hỏi hay. Okay, chúng ta đã nói về rất nhiều thứ khác nhau, đúng không?
One thing you may say, okay, we only look at the single, like single bit, right? Single bit input and output, right? What if we have array, right? We have array of ports.
Có thể các em sẽ nói, okay, ta mới chỉ xét một bit đơn, đúng không? Đầu vào và đầu ra chỉ một bit, đúng không? Vậy nếu có mảng thì sao? Ta có một mảng các cổng.
Let's say we have four input MUX. You just think about this as a multiplexer as a module, right? We have a select signal. And the output is based on the select signal.
Giả sử ta có bộ MUX bốn đầu vào. Các em cứ coi bộ dồn kênh này như một module, đúng không? Ta có một tín hiệu chọn. Và đầu ra phụ thuộc vào tín hiệu chọn đó.
We pass one of the input to output, right? Don't worry about the detail, the internal of this, right? We want to use this as example to create a hierarchical design, right?
Ta cho một trong các đầu vào đi qua ra đầu ra, đúng không? Đừng lo về chi tiết, về bên trong của nó, nhé. Ta muốn dùng nó làm ví dụ để tạo một thiết kế phân cấp, đúng không?
So this is a four input. We could actually potentially build it, right? In a hierarchical fashion with two input MUXs, right?
Đây là bộ bốn đầu vào. Thực ra ta có thể xây dựng nó, theo kiểu phân cấp từ các MUX hai đầu vào, đúng không?
And then we have like a pair of select signals. We have four inputs. And then based on the combination of the select signal, we pass different inputs to the output, right?
Rồi ta có một cặp tín hiệu chọn. Ta có bốn đầu vào. Và tùy theo tổ hợp của các tín hiệu chọn, ta cho các đầu vào khác nhau đi qua ra đầu ra, đúng không?
So first, what we are introducing here is an array of signals, right? So similar to other programming language, it's just very tedious to always have a single bit.
Trước hết, điều ta giới thiệu ở đây là mảng tín hiệu, đúng không? Tương tự các ngôn ngữ lập trình khác, lúc nào cũng chỉ dùng một bit thì rất rườm rà.
So you could actually declare array of signals. And this is very useful when you write the code, right? And again, we could actually do instantiate multiple modules here.
Nên ta có thể khai báo một mảng tín hiệu. Và điều này rất hữu ích khi viết mã, đúng không? Và ta cũng có thể khởi tạo nhiều module ở đây.
So MUX2 is a module we defined earlier. Again, this is a data structure. We can instantiate multiple MUX2, give them different names here.
MUX2 là module ta đã định nghĩa trước đó. Đây là một cấu trúc dữ liệu. Ta có thể khởi tạo nhiều MUX2 và đặt cho chúng các tên khác nhau.
One thing, I guess we discussed earlier in terms of recommended way of structure your Verilog, always have a named port. What do we mean by named port?
Một điều nữa, tôi nghĩ ta đã bàn trước đó về cách được khuyến nghị để cấu trúc mã Verilog, là luôn dùng cổng có tên. Cổng có tên nghĩa là gì?
So we basically want to create a very explicit mapping between the port list that we described in our data structure in our module to the newly mapped signal.
Về cơ bản ta muốn tạo một ánh xạ rất tường minh giữa danh sách cổng mà ta mô tả trong cấu trúc dữ liệu của module với tín hiệu mới được ánh xạ tới.
Or you can think about, I guess, function argument, Here, so we actually know which signal in my current design, in my top level module, is actually mapped to the signal in my individual module.
Hoặc có thể nghĩ nó giống đối số của hàm. Ở đây, ta biết chính xác tín hiệu nào trong thiết kế hiện tại, trong module cấp cao nhất, được ánh xạ tới tín hiệu nào trong module riêng lẻ.
Let's look at the select signal as an example, right? So we have this select signal here in the bottom, in the lower level module.
Hãy xem tín hiệu chọn làm ví dụ, đúng không? Ta có tín hiệu chọn này ở dưới, trong module cấp thấp hơn.
And when we instantiate a hierarchy, right, this select signal is actually being mapped to those two signals, select one and select zero, right?
Và khi ta khởi tạo một phân cấp, đúng không, tín hiệu chọn này thực ra được ánh xạ tới hai tín hiệu, select một và select không, đúng không?
So what we actually do, if you focus on this part of the code, is that we first mention the original name in my module declaration: we have a select signal.
Vậy thực ra ta làm gì, nếu các em tập trung vào đoạn mã này, là trước tiên ta nêu tên gốc trong phần khai báo module của mình: ta có một tín hiệu select.
And we also mention the current name in my current module, right? Which wire is actually mapped to the select signal in my original declaration.
Và ta cũng nêu tên hiện tại trong module hiện tại, đúng không? Dây nào thực sự được ánh xạ tới tín hiệu select trong khai báo gốc của tôi.
So with this, it's actually clear to see what's going on. So this is, again, not required.
Như vậy, ta có thể thấy rõ chuyện gì đang diễn ra. Vì vậy, một lần nữa, điều này không bắt buộc.
You can also get rid of those and directly pass parameters, but it's very easy to get things wrong. So it's always better to actually have what people call named ports.
Bạn cũng có thể bỏ những phần đó và truyền trực tiếp các tham số, nhưng rất dễ làm sai. Vì vậy luôn tốt hơn là dùng cái mà người ta gọi là named ports.
During an interview, if you're asked what named ports are, it basically creates a very explicit mapping between the original name in the module declaration and the instantiated ports in my current module.
Trong một buổi phỏng vấn, nếu bạn được hỏi named ports là gì, thì về cơ bản nó tạo ra một ánh xạ rất tường minh giữa tên gốc trong khai báo module và các cổng được khởi tạo trong module hiện tại của tôi.
So that's named ports, again, the recommended style to actually create hierarchies in our design.
Đó là named ports, một lần nữa, là phong cách được khuyến nghị để tạo ra các phân cấp trong thiết kế của chúng ta.
Questions? So by default here, there's one bit.
Có câu hỏi nào không? Mặc định ở đây là một bit.
Right, so here in the original box, right? So it's basically one bit, right? So now we have two bits. So we pass this value to the individual, to the input mux.
Đúng không, ở đây, trong khối gốc, đúng không? Vậy về cơ bản là một bit, đúng không? Còn bây giờ chúng ta có hai bit. Vậy ta truyền giá trị này cho từng mux đầu vào.
So we either, like, the zero element of select is passed to the module or the first element is passed to the module.
Tức là phần tử số không của select được truyền cho module, hoặc phần tử thứ nhất được truyền cho module.
So it's still one bit in the end, but we have this array, so it makes it easier to instantiate.
Vậy cuối cùng nó vẫn là một bit, nhưng ta có mảng này nên việc khởi tạo dễ dàng hơn.
The input of the module will be empty. So it means just, and it's not connected to anything. No, no, that's illegal.
Đầu vào của module sẽ để trống. Nghĩa là nó không được nối với thứ gì cả. Không, không, như vậy là không hợp lệ.
So you need to make sure all the ports are actually connected to that. You may think about hardware, right? It's basically like we talk about functionality there, right?
Vì vậy bạn cần đảm bảo tất cả các cổng đều được kết nối. Bạn có thể nghĩ đến phần cứng, đúng không? Về cơ bản là ta đang nói về chức năng ở đó, đúng không?
If anything is undefined, right? We don't know what to do with that. So we'll actually talk about later, always have default value. So you're not supposed to actually, I think.
Nếu cái gì đó không được xác định, ta không biết phải làm gì với nó. Vì vậy sau này ta sẽ nói đến việc luôn có giá trị mặc định. Nên bạn không được phép làm vậy, tôi nghĩ thế.
And you don't need this syntax and you should provide them to make port. Yes, yes. So we always use this dot name syntax here. There's a dot there.
Và bạn không cần cú pháp này, mà nên cung cấp chúng để nối cổng. Vâng. Vậy ta luôn dùng cú pháp dấu chấm và tên ở đây. Có một dấu chấm ở đó.
Okay. So we'll see, again, we'll have another example of the instantiation. We'll go through this a little bit, I guess we actually already talked about in the adder example, right?
Được rồi. Ta sẽ lại thấy một ví dụ khác về khởi tạo. Ta sẽ xem qua một chút, tôi nghĩ ta đã nói đến nó trong ví dụ bộ cộng rồi, đúng không?
So again, we have a full adder. Each one is a single bit, right? We have three inputs, two outputs. And one way we discuss a different ways of building adders.
Vậy một lần nữa, ta có một bộ cộng đầy đủ. Mỗi bộ là một bit đơn, đúng không? Ta có ba đầu vào, hai đầu ra. Và ta đã bàn về nhiều cách khác nhau để xây dựng bộ cộng.
One way of building an adder is what people call ripple adder or ripple-carry adder. We'll see. Don't worry about those modules too much.
Một cách xây dựng bộ cộng là cái mà người ta gọi là ripple adder hay ripple-carry adder. Ta sẽ thấy. Đừng lo quá về các module đó.
We'll actually talk about adder in depth in a couple of months. But what ripple-carry adder does is basically have the carry out of the previous adder become the carry in.
Ta sẽ nói sâu về bộ cộng trong vài tháng nữa. Nhưng ripple-carry adder về cơ bản làm cho nhớ ra của bộ cộng trước trở thành nhớ vào.
It's basically like the way we're doing addition, right? We have this carry propagates through every bits of our design, right? So with that, it's again, it's always useful to use name ports.
Về cơ bản nó giống cách ta làm phép cộng, đúng không? Ta có nhớ lan truyền qua mọi bit trong thiết kế, đúng không? Vì vậy, một lần nữa, luôn hữu ích khi dùng named ports.
Of course, first hierarchy, right? So we first have this module declaration and then we instantiate multiple modules here. The rest is straightforward.
Tất nhiên, trước hết là phân cấp, đúng không? Vậy trước tiên ta có khai báo module này rồi sau đó khởi tạo nhiều module ở đây. Phần còn lại thì đơn giản.
I think what we want to say, we'll pay a little bit more attention for the carry, right? Because we want to actually create this kind of ripple-carry propagation.
Tôi nghĩ điều ta muốn nói là, ta sẽ chú ý nhiều hơn một chút đến tín hiệu nhớ, đúng không? Vì chúng ta thực sự muốn tạo ra kiểu lan truyền nhớ ripple-carry này.
So we want to make sure all the different wires are connected correctly from output of one adder cell to the input of the next adder cell, right?
Nên chúng ta muốn đảm bảo tất cả các dây khác nhau được nối đúng, từ đầu ra của một adder cell đến đầu vào của adder cell kế tiếp, đúng không?
And then we have array of ports here. Just another example of naming ports and creating hierarchy and more other uses. So this is a ripple carry adder, similar to the MUX example.
Và ở đây chúng ta còn có một mảng các cổng. Đây chỉ là một ví dụ khác về việc đặt tên cổng, tạo phân cấp và nhiều cách dùng khác. Vậy đây là một bộ cộng ripple carry, tương tự ví dụ MUX.
We created a hierarchy. And another, like, you may be wondering what kind of operators are supported in Verilog. It's actually pretty, like, all the commonly used gates or functionalities are actually supported.
Chúng ta đã tạo ra một phân cấp. Và một điều nữa, có thể các bạn đang thắc mắc Verilog hỗ trợ những toán tử nào. Thực ra là khá đầy đủ, tất cả các cổng hay chức năng thường dùng đều được hỗ trợ.
So we actually, most of the time, as I mentioned earlier, we don't need to actually write structural Verilog.
Như tôi đã đề cập trước đó, phần lớn thời gian chúng ta không cần viết structural Verilog.
We can actually just use those operators directly for common, like, bitwise operation, logical or arithmetic operation. All of those are generally supported. We'll not go through all of these; very similar to C.
Chúng ta có thể dùng trực tiếp các toán tử đó cho các phép thao tác bitwise, logic hoặc số học thông thường. Tất cả những thứ đó nhìn chung đều được hỗ trợ. Chúng ta sẽ không đi qua hết; nó rất giống C.
So Verilog also has a very similar flavor once you actually get a little bit more comfortable with Verilog. So always refer back to see what kind of operators are supported for those generic functions.
Verilog cũng có phong cách rất giống khi bạn đã quen hơn một chút với Verilog. Vậy hãy luôn tra lại xem những toán tử nào được hỗ trợ cho các chức năng chung đó.
Generally, it is very rare that we actually use structural Verilog. We basically use behavioral Verilog directly. A little bit more about continuous assignment.
Nhìn chung, rất hiếm khi chúng ta dùng structural Verilog. Về cơ bản chúng ta dùng trực tiếp behavioral Verilog. Nói thêm một chút về phép gán liên tục.
I mentioned earlier, it's basically, again, before the equal sign, left-hand side; after the equal sign, right-hand side.
Tôi đã nói trước đó, về cơ bản, một lần nữa, trước dấu bằng là vế trái; sau dấu bằng là vế phải.
So continuous assignment, as the name suggests, it's always, it continues to happen, right? Whenever certain things happen, changes, on the right-hand side, it's always just immediately propagated to the left-hand side, right?
Phép gán liên tục, như tên gọi cho thấy, luôn luôn tiếp diễn, đúng không? Bất cứ khi nào có thay đổi nào đó ở vế phải, nó đều được lan truyền ngay lập tức sang vế trái, đúng không?
So this is a great way to model combinational logic, right? Combinational logic is like, whenever, remember, combinational logic, whenever input changes, output changes, right? Versus sequential logic, there is also a state element.
Vậy đây là cách tuyệt vời để mô hình hóa logic tổ hợp, đúng không? Logic tổ hợp là, hãy nhớ, logic tổ hợp hễ đầu vào thay đổi thì đầu ra thay đổi, đúng không? Còn logic tuần tự thì có thêm phần tử trạng thái.
But for combinational logic, whenever input changes, output changes. We'll go through some of the principles later. There are generally two ways of describing combinational logic.
Nhưng với logic tổ hợp, hễ đầu vào thay đổi thì đầu ra thay đổi. Lát nữa chúng ta sẽ đi qua một số nguyên tắc. Nhìn chung có hai cách mô tả logic tổ hợp.
This is one of the mostly used ways of describing combinational logic, is basically using the assign statement.
Đây là một trong những cách được dùng nhiều nhất để mô tả logic tổ hợp, đó là dùng câu lệnh assign.
Whenever you use that, you can just think of it as like, create a combinational logic with input and output.
Mỗi khi dùng nó, bạn có thể hình dung như là tạo ra một khối logic tổ hợp có đầu vào và đầu ra.
And again, it's very similar, a lot of, like, operator, like, Ternary operators also exist in Verilog. So a lot of C operators, generally supported by C, are also supported in Verilog.
Và một lần nữa, nó rất giống, nhiều toán tử, chẳng hạn toán tử ba ngôi (ternary) cũng có trong Verilog. Nhiều toán tử của C, nhìn chung được C hỗ trợ, cũng được Verilog hỗ trợ.
So those are different. I won't go through it, but we can actually do a lot of different behavior Verilog assignments directly, using behavior Verilog.
Vậy những cái này là khác nhau. Tôi sẽ không đi qua hết, nhưng chúng ta có thể thực hiện trực tiếp rất nhiều phép gán behavioral Verilog khác nhau, bằng cách dùng behavioral Verilog.
So this is one way of doing combinational logic. There's also another way of doing combinational logic, and that's a little bit shared with how we would actually describe sequential logic.
Vậy đây là một cách để tạo logic tổ hợp. Còn một cách khác để mô tả logic tổ hợp, và cách này có phần dùng chung với cách chúng ta mô tả logic tuần tự.
So I will do that in a minute, but before we move on, any questions about declaration, instantiation, Verilog? What?
Lát nữa tôi sẽ nói về nó, nhưng trước khi tiếp tục, có câu hỏi nào về khai báo, khởi tạo thể hiện, hay Verilog không? Gì vậy?
For the arithmetic operator, we say, use it with care. Where did I say you? Oh, arithmetic operators, use it with care. That's a good question.
Với toán tử số học, ta nói là dùng cẩn thận. Tôi đã nói câu đó ở đâu vậy? À, toán tử số học, dùng cẩn thận. Câu hỏi hay đấy.
Yeah, I guess one thing I can think of is make sure you have enough bits to cover everything, right? Because like the adder and the multiplier example, the output can actually have more bits.
Ừ, một điều tôi nghĩ tới là hãy đảm bảo bạn có đủ số bit để chứa mọi kết quả, đúng không? Vì chẳng hạn như ví dụ bộ cộng và bộ nhân, đầu ra thực tế có thể có nhiều bit hơn.
So you always make sure the bits are actually there.
Nên bạn luôn phải đảm bảo các bit đó thực sự có mặt.
I think that's something I run into, just like not very hard to, I guess that's something I, maybe another thing is make it, oh, I guess one thing is also, when you think about whether it's actually logical operator or arithmetic operation, whether you're doing a logical operation or arithmetic operation,
Tôi nghĩ đây là chuyện tôi từng gặp, cũng không quá khó, tôi đoán đó là điều mà tôi, có lẽ một điều nữa là làm cho nó, à, tôi nghĩ còn một điều nữa, khi bạn cân nhắc xem đó là toán tử logic hay phép toán số học, tức là bạn đang thực hiện phép toán logic hay phép toán số học,
that could also potentially affect. So just be careful which operator we're using. I'll look into this. There's a history of this slide here, but good catch. Question?
thì điều đó cũng có thể ảnh hưởng đến kết quả. Vì vậy hãy cẩn thận xem ta đang dùng toán tử nào. Tôi sẽ xem lại chỗ này. Slide này có một lịch sử riêng, nhưng bạn phát hiện tốt lắm. Câu hỏi tiếp?
Oh, that's a good question. So everything is actually operated at bit level. So there's not like integer, floating point.
À, câu hỏi hay đấy. Mọi thứ thực chất đều được xử lý ở mức bit. Nên không có kiểu số nguyên hay dấu phẩy động sẵn.
You can actually describe, define your own floating point data structure, but everything is at the bit level. So you literally need to map into the bit representation of the floating point.
Bạn có thể tự mô tả, định nghĩa cấu trúc dữ liệu dấu phẩy động của riêng mình, nhưng mọi thứ đều ở mức bit. Nên bạn phải ánh xạ đúng vào biểu diễn bit của số dấu phẩy động.
You cannot just declare a floating point in Verilog. It doesn't exist. Everything is actually at bit level.
Bạn không thể chỉ khai báo một số dấu phẩy động trong Verilog. Nó không tồn tại. Mọi thứ thực chất đều ở mức bit.
You can actually describe like the sign bit, the exponent, the mantissa in floating point representation, but there's no floating point in Verilog. Everything is at the bit level.
Bạn có thể mô tả bit dấu, phần mũ, phần định trị trong biểu diễn dấu phẩy động, nhưng Verilog không có dấu phẩy động. Mọi thứ đều ở mức bit.
But you could, let's say, build a floating point library or build a floating point module that actually maps the floating point operation onto the bit level here.
Nhưng bạn có thể, chẳng hạn, xây dựng một thư viện dấu phẩy động hoặc một module dấu phẩy động để ánh xạ phép toán dấu phẩy động xuống mức bit ở đây.
But everything is bit level here. All right. So I'm looking at the line, the sign p equal to x multiplied by one. Mm-hmm.
Nhưng ở đây mọi thứ đều ở mức bit. Được rồi. Tôi đang nhìn dòng p bằng x nhân một. Ừm.
Isn't multiplication kind of hard to implement in terms of like wires? If I just write x times y, the synthesis does everything for me? Yeah, today's...
Phép nhân chẳng phải khá khó thực hiện bằng dây dẫn sao? Nếu tôi chỉ viết x nhân y thì công cụ tổng hợp làm hết cho tôi à? Ừ, ngày nay...
again, we'll talk about multiplier design later, but today's synthesis tool is actually pretty good. It will actually synthesize a pretty good multiplier for you, yeah.
chúng ta sẽ nói về thiết kế bộ nhân sau, nhưng công cụ tổng hợp ngày nay khá tốt. Nó sẽ tổng hợp cho bạn một bộ nhân khá tốt, đúng vậy.
And it might have like eight times, it's like two to the, like seven times seven. And p is what they read. It's just gonna chop off the thing. Oh, yeah, yes.
Và có thể là tám nhân, kiểu hai mũ, như bảy nhân bảy. Còn p là cái họ đọc. Nó sẽ cắt bớt phần dư. À, vâng.
So basically, yeah, it will also basically, everything overflow, it will just keep the lower bit, yeah. And like, we're designing a module. Do you have any access to the C power library?
Về cơ bản, nó cũng vậy, mọi thứ tràn, nó sẽ chỉ giữ lại các bit thấp, đúng vậy. Và, chúng ta đang thiết kế một module. Bạn có truy cập được thư viện C power không?
Basically what I'm using, like the ripple library, we actually write to the C power library.
Về cơ bản cái tôi đang dùng, như thư viện ripple, chúng ta thực sự ghi vào thư viện C power.
If you use a ripple-carry adder, you actually write, oh, you mean whether you will actually have overflow issues if you're actually using that?
Nếu bạn dùng bộ cộng ripple-carry, thì thực ra bạn viết, ồ, ý bạn là liệu thực sự có vấn đề tràn số hay không nếu dùng nó phải không?
Yeah, and I'll be aware of, but this, I wouldn't know whether my overflow happens. You wouldn't, but if the input is seven bits, the output is only four bits, right?
Vâng, và tôi sẽ để ý, nhưng như vậy thì tôi sẽ không biết liệu tràn số có xảy ra hay không. Bạn sẽ không biết, nhưng nếu đầu vào là bảy bit mà đầu ra chỉ có bốn bit, đúng không?
So when you look at the input and output, like the port declaration, you will actually see there will be an overflow issue, right?
Vậy khi nhìn vào đầu vào và đầu ra, tức là phần khai báo cổng, bạn sẽ thấy là có vấn đề tràn số, đúng không?
If X is seven, Y is seven bits, D will be seven bits. It's still overflow, right? Potentially. It's still potentially overflow, right?
Nếu X là bảy bit, Y là bảy bit, thì D sẽ là bảy bit. Vẫn tràn số, đúng không? Có thể. Vẫn có khả năng tràn số, đúng không?
So those general, like adder, multiplier, those have actually very strict rules, right?
Vì vậy những module thông dụng như bộ cộng, bộ nhân, thực ra có những quy tắc rất nghiêm ngặt, đúng không?
So if you, like for adders, you always need to make sure you have one more carry bit to save the carry bit.
Với bộ cộng chẳng hạn, bạn luôn phải đảm bảo có thêm một bit nhớ để lưu bit nhớ.
For multiplier, you always need input and output added together to actually save, Make sure you actually get the full multiplied result.
Với bộ nhân, bạn luôn cần độ rộng đầu ra bằng tổng độ rộng các đầu vào để lưu được đầy đủ kết quả phép nhân.
So it's actually up to the designer to make sure that the tool will basically truncate the output if you actually not declare that directly.
Vì vậy nhà thiết kế phải tự đảm bảo điều này, vì công cụ sẽ tự cắt bớt đầu ra nếu bạn không khai báo trực tiếp như vậy.
That could also be a reason why the, with clear, right? So you make sure, otherwise the tool will truncate that for you.
Đó cũng có thể là một lý do, với clear, đúng không? Nên bạn phải đảm bảo, nếu không công cụ sẽ cắt bớt giúp bạn.
No matter whether you're using your own module or using like the module from the tools, right? Always make sure you have enough bit widths there. Mm-hmm.
Dù bạn dùng module của chính mình hay module có sẵn từ công cụ, đúng không? Luôn đảm bảo có đủ độ rộng bit ở đó. Ừm.
So though I'm assigned to use a three and then you said that, Mm-hmm. Is it still in bits that you use when you're in hex, when you write B?
Vậy tôi được giao dùng số ba, rồi bạn nói là, ừm. Khi viết hex, viết B, thì đó vẫn là tính theo bit chứ?
It's still in bits, but you can actually write in hex. It's easier to write.
Vẫn là theo bit, nhưng bạn có thể viết bằng hex cho dễ viết.
Yeah, so that's why we have hex here, or you can also do a bit of B here, but then you just, it's easier to write with hex.
Vâng, đó là lý do ở đây ta dùng hex, hoặc bạn cũng có thể dùng dạng nhị phân B ở đây, nhưng viết bằng hex thì dễ hơn.
Yeah, it's a more readability benefit, which is very So it's still in bits? Yes, it's a number of bits.
Vâng, lợi ích là dễ đọc hơn. Vậy vẫn là theo bit chứ? Đúng, đó là số bit.
Okay, so we'll see more questions.
Được rồi, ta sẽ xem thêm các câu hỏi.
Well, again, we'll just set up, again, set up a structure here.
Ừ, ta sẽ dựng lại một cấu trúc ở đây.
You will actually get to practice a lot of those, and we'll also see a little bit more examples later when we see more different Verilog modules for different things.
Bạn sẽ được luyện tập rất nhiều về những điều này, và ta cũng sẽ xem thêm một vài ví dụ sau khi gặp thêm các module Verilog khác nhau cho những mục đích khác nhau.
So I mentioned earlier, for combinational logic, there are two ways. One is actually using continuous assignment. Well, since we're talking about continuous assignment, a natural question is, what about non-continuous assignment, right?
Như tôi đã nói trước đó, với logic tổ hợp có hai cách. Một là dùng phép gán liên tục. Vì đang nói về phép gán liên tục, một câu hỏi tự nhiên là, vậy còn phép gán không liên tục thì sao?
When do we actually need non-continuous assignment? So this is basically, say the assignment doesn't happen automatically. Our continuous assignment is always input changes, output changes, right?
Khi nào ta thực sự cần phép gán không liên tục? Tức là phép gán không xảy ra tự động. Phép gán liên tục thì luôn là đầu vào đổi thì đầu ra đổi, đúng không?
Non-continuous assignment means that the output only changes under certain conditions, right? So it's why it's non-continuous. And then to specify that condition, we have this always block, right?
Phép gán không liên tục nghĩa là đầu ra chỉ thay đổi khi thỏa những điều kiện nhất định, đúng không? Đó là lý do nó không liên tục. Và để chỉ định điều kiện đó, ta có khối always này, đúng không?
So when we mentioned non-continuous assignment, we basically mean there's no always block. So we have this always block, And the condition is basically specified in the parenthesis here.
Vậy khi nói đến phép gán không liên tục, về cơ bản ta muốn nói là có khối always. Vậy ta có khối always này, Và điều kiện về cơ bản được chỉ định trong dấu ngoặc đơn ở đây.
Or sometimes you may hear people calling it sensitivity list, right? So this is basically to specify under what condition we actually updates my output here.
Hoặc đôi khi bạn có thể nghe người ta gọi nó là danh sách độ nhạy (sensitivity list), đúng không? Vậy nó về cơ bản dùng để chỉ định trong điều kiện nào thì chúng ta cập nhật đầu ra của mình ở đây.
So like, for example, in this example, we have AND OR gate, right? So you would draw the gate in the one, and two, and the input three, right?
Ví dụ, trong ví dụ này, chúng ta có một cổng AND-OR, đúng không? Bạn sẽ vẽ cổng này với đầu vào một, hai, và đầu vào ba, đúng không?
So we first go through an AND gate first, and then we do a OR gate, right? So this is the hardware that we're building, right? So this is still a combinational logic, right?
Đầu tiên chúng ta đi qua một cổng AND trước, rồi sau đó đến một cổng OR, đúng không? Đây chính là phần cứng mà chúng ta đang xây dựng, đúng không? Đây vẫn là một mạch logic tổ hợp, đúng không?
So one way to actually describe this combinational logic is to use the always block, where we actually specify the sensitivity list or the condition list here.
Vậy một cách để mô tả mạch logic tổ hợp này là dùng khối always, trong đó chúng ta chỉ định danh sách độ nhạy hay danh sách điều kiện ở đây.
Basically, whenever any of the input changes, we update the output. This is my output, right?
Về cơ bản, bất cứ khi nào có đầu vào nào thay đổi, chúng ta cập nhật đầu ra. Đây là đầu ra của tôi, đúng không?
So this doesn't happen continuously, because we have this always block. But in this particular example, right? If any of the input changes, right? My output changes.
Vậy việc này không xảy ra liên tục, vì chúng ta có khối always này. Nhưng trong ví dụ cụ thể này thì sao? Nếu bất kỳ đầu vào nào thay đổi, đầu ra của tôi thay đổi.
This is actually the same as our continuous assignments, what we have earlier, right? We actually could just potentially write this in one line instead of using this always block, right?
Điều này thực ra giống với phép gán liên tục mà chúng ta đã thấy trước đó, đúng không? Thực ra chúng ta hoàn toàn có thể viết điều này trong một dòng thay vì dùng khối always này, đúng không?
This is actually the same functionality. Both are describing a combinational logic, this combinational logic we draw here, right?
Chức năng thực ra là như nhau. Cả hai đều mô tả một mạch logic tổ hợp, chính là mạch logic tổ hợp mà chúng ta vẽ ở đây, đúng không?
The reason for that is that when we actually use always block to describe a combinational logic, we could, this is again, more syntax issue, not necessarily related to hardware, is when we use this always block, we can actually use a richer set of syntax and describe the hardware.
Lý do là khi chúng ta dùng khối always để mô tả một mạch logic tổ hợp, chúng ta có thể, đây lại là vấn đề cú pháp nhiều hơn, không nhất thiết liên quan đến phần cứng, là khi chúng ta dùng khối always này, chúng ta có thể dùng một tập cú pháp phong phú hơn để mô tả phần cứng.
What do we mean by that? So when we actually have always block, we actually can use some constructs.
Ý tôi là gì? Khi có khối always, chúng ta có thể dùng một số cấu trúc.
That's actually a little bit hard to describe in just using assignment. One of the construct is similar, again, very similar to C, if you look at the language carefully.
Những cấu trúc đó khá khó mô tả nếu chỉ dùng phép gán. Một trong các cấu trúc đó tương tự, lại rất giống C, nếu bạn xem kỹ ngôn ngữ này.
So similar to a switch statement in C, we can also have a case statement, right? Case statement is basically, Again, very similar to a switch statement.
Tương tự câu lệnh switch trong C, chúng ta cũng có câu lệnh case, đúng không? Câu lệnh case về cơ bản, lại là rất giống câu lệnh switch.
It basically depends on a particular select signal. We actually choose different modules or different code sequences we actually execute, right? So it specifies a condition.
Nó về cơ bản phụ thuộc vào một tín hiệu chọn cụ thể. Chúng ta chọn các mô-đun khác nhau hoặc các đoạn mã khác nhau để thực thi, đúng không? Vậy nó chỉ định một điều kiện.
So now, based on the select signal, if the select signal is zero, zero, so output... so this is very simple. This is another four input mux, right?
Giờ thì, dựa trên tín hiệu chọn, nếu tín hiệu chọn là không, không, thì đầu ra... cái này rất đơn giản. Đây là một bộ dồn kênh bốn đầu vào nữa, đúng không?
So input zero, input one, two, input three, and then we have an output, and then we have a select signal, and this select signal is two bits, right?
Có đầu vào không, đầu vào một, hai, đầu vào ba, và sau đó chúng ta có một đầu ra, và chúng ta có một tín hiệu chọn, và tín hiệu chọn này có hai bit, đúng không?
So this is basically the hardware we describe, right? So using this always block, using this always block, we could actually use the case statement.
Vậy đây về cơ bản là phần cứng mà chúng ta mô tả, đúng không? Vậy khi dùng khối always này, dùng khối always này, chúng ta thực ra có thể dùng câu lệnh case.
It's also a lot easier to use and we can actually describe the operation that we have in this four input mux, and then we can actually factor it in, in this case switch, to choose different conditions.
Nó cũng dễ dùng hơn nhiều và chúng ta có thể mô tả hoạt động mà ta có trong bộ dồn kênh bốn đầu vào này, rồi chúng ta có thể đưa nó vào, trong trường hợp này là switch, để chọn các điều kiện khác nhau.
And we put in the slides, this can also be done potentially using nested if, right? So we could just go through, especially in a pure programming sense, right?
Và như chúng tôi có đưa vào slide, việc này cũng có thể làm bằng if lồng nhau, đúng không? Tức là ta có thể duyệt lần lượt, nhất là xét theo cách lập trình thuần túy, đúng không?
We could actually just go through a range of nested if-else statements, right? We could actually build a similar... it can act similarly as a switch statement, or specifically as a case statement here, right?
Ta có thể duyệt qua một loạt câu lệnh if-else lồng nhau, đúng không? Ta có thể xây dựng một cấu trúc tương tự... nó có thể hoạt động tương tự như câu lệnh switch, hay cụ thể ở đây là câu lệnh case, đúng không?
They are not exactly the same, and the difference is actually from a hardware perspective. So we are actually using a nested if-else statement, right?
Chúng không hoàn toàn giống nhau, và sự khác biệt nằm ở góc độ phần cứng. Vậy là chúng ta đang dùng câu lệnh if-else lồng nhau, đúng không?
So we are actually operating, performing the same operation, right? Choosing different select signals, and then we assign output to different select signals.
Tức là chúng ta đang thực hiện cùng một phép toán, đúng không? Chọn theo các tín hiệu select khác nhau, rồi gán đầu ra tương ứng với từng tín hiệu select.
This case, just like this, leads to potentially priority decoding or priority logic. It's mostly because of how this is actually turned into hardware.
Trường hợp này, đúng như thế này, có thể dẫn đến giải mã ưu tiên hay logic ưu tiên. Chủ yếu là do cách nó được chuyển thành phần cứng.
So the order actually matters in hardware. In this case, let's say if the, for input zero, we always get arbitrated very early, right? We always take a look at select.
Vì vậy thứ tự thực sự quan trọng trong phần cứng. Trong trường hợp này, giả sử với đầu vào zero, nó luôn được phân xử rất sớm, đúng không? Ta luôn xem xét select trước.
Whether select is zero, we arbitrate the input zero.
Nếu select bằng zero thì ta chọn đầu vào zero.
Versus if actually, let's say select is actually one, one, where we actually get to choose input three, it doesn't happen until very end because we're actually keep doing, you can think about it like a tree, right?
Còn nếu giả sử select là một, một, khi đó ta chọn đầu vào ba, thì điều đó chỉ xảy ra ở rất cuối vì ta cứ phải tiếp tục, bạn có thể hình dung như một cái cây, đúng không?
We'll keep actually navigating the tree until we reach the point where select, we didn't specify the condition because it's a last else statement, right?
Ta cứ đi dọc theo cây cho đến khi tới điểm mà select, ta không chỉ rõ điều kiện vì đó là câu lệnh else cuối cùng, đúng không?
But the last condition in basic select is two'b11. This condition is not triggered until the very end, which means that we actually want to pass the value from input three to output.
Nhưng điều kiện cuối cùng của select cơ bản là 2'b11. Điều kiện này không được kích hoạt cho đến tận cuối, nghĩa là khi ta muốn chuyển giá trị từ đầu vào ba ra đầu ra.
That will actually take longer compared to passing value from input zero to output. So that's why when we actually describe a mux operation, always use a case statement that we've discussed earlier.
Việc đó sẽ mất nhiều thời gian hơn so với chuyển giá trị từ đầu vào zero ra đầu ra. Vì vậy khi chúng ta mô tả một phép toán mux, hãy luôn dùng câu lệnh case như đã thảo luận trước đó.
This is actually, we'll synthesize hardware into everything is treated fairly versus this nested if-else statement, which will actually generate a priority, like you can think of this like a tree navigation logic and different branches of the tree will actually get different delay.
Khi đó phần cứng được tổng hợp ra sẽ đối xử với mọi đầu vào khá công bằng, so với câu lệnh if-else lồng nhau này, vốn sẽ tạo ra một cơ chế ưu tiên, bạn có thể hình dung như logic duyệt cây và các nhánh khác nhau của cây sẽ có độ trễ khác nhau.
So this is not recommended.
Vì vậy cách này không được khuyến nghị.
And if we actually have a scenario, this mux, or when you do your CPU design, you also look at different opcodes and look at which one you want to use, always use the case statement that will actually treat everyone equally.
Và nếu có một tình huống như mux này, hay khi bạn thiết kế CPU, bạn cũng sẽ xem các opcode khác nhau và xem muốn dùng cái nào, hãy luôn dùng câu lệnh case, vì nó sẽ đối xử với mọi đầu vào như nhau.
What is the same delay that's between all simultaneously? Yeah, everything simultaneously is internal.
Độ trễ giữa tất cả chúng có giống nhau, đồng thời không? Vâng, mọi thứ diễn ra đồng thời bên trong.
Oh, that's a great question. So we are actually getting there.
Ồ, câu hỏi rất hay. Vậy là chúng ta đang tới đó rồi.
We will get there, but eventually if you actually don't have anything defined, that's actually very dangerous.
Chúng ta sẽ nói tới, nhưng nếu cuối cùng bạn không định nghĩa gì cả, thì điều đó thực sự rất nguy hiểm.
That will either create a latch in your design due to unintentional behaviors, always have everything defined and core have a default value. Otherwise it will actually generate hardware.
Điều đó sẽ tạo ra một latch trong thiết kế của bạn do những hành vi không chủ ý, nên hãy luôn định nghĩa mọi thứ và có một giá trị mặc định. Nếu không, nó sẽ thực sự sinh ra phần cứng.
The tool will think you have some other intentions, will actually generate a temporal value. It will actually generate a sequential logic instead of a combinational logic.
Công cụ sẽ nghĩ rằng bạn có ý định khác, và sẽ sinh ra một giá trị lưu trữ theo thời gian. Nó sẽ sinh ra logic tuần tự thay vì logic tổ hợp.
So I always have everything defined and have a default value for the case statement. You also explain why we should register this, right? That's a good question.
Vì vậy tôi luôn định nghĩa mọi thứ và có một giá trị mặc định cho câu lệnh case. Bạn cũng giải thích tại sao ta phải khai báo là reg nhỉ? Câu hỏi hay.
So another very important syntax here with always block is all the assignments that happen in an always block need to be registered.
Vậy một cú pháp rất quan trọng khác ở đây với khối always là mọi phép gán xảy ra trong một khối always đều phải là reg.
It doesn't mean it will eventually turn into a hardware register, because in this case it's a combinational logic. We don't really have a register. Again, this is just a syntax of the language.
Điều đó không có nghĩa là cuối cùng nó sẽ thành một thanh ghi phần cứng, vì trong trường hợp này đó là logic tổ hợp. Chúng ta thực sự không có thanh ghi nào. Một lần nữa, đây chỉ là cú pháp của ngôn ngữ.
Any value being assigned in that always block needs to be declared as a reg type.
Bất kỳ giá trị nào được gán trong khối always đó đều phải được khai báo với kiểu reg.
So a Verilog reg type doesn't necessarily mean we're getting a register, but when we assign a value in an always block, the output always needs to be a reg type, a Verilog type.
Vậy kiểu reg của Verilog không nhất thiết có nghĩa là ta có một thanh ghi, nhưng khi ta gán một giá trị trong khối always, đầu ra luôn phải là kiểu reg, một kiểu của Verilog.
It's just a syntax. It's just a syntax. It doesn't, yes, sometimes people don't like Verilog because it has some very weird syntax group.
Đó chỉ là cú pháp. Chỉ là cú pháp thôi. Đúng vậy, đôi khi người ta không thích Verilog vì nó có một số nhóm cú pháp rất kỳ lạ.
We'll get to the sequential Verilog later and we'll see sometimes it does mean it's actually, it's a register being synthesized. But here in combinational logic, it's just a syntax thing.
Chúng ta sẽ nói về Verilog tuần tự sau và sẽ thấy đôi khi nó thực sự có nghĩa là một thanh ghi được tổng hợp ra. Nhưng ở đây, với logic tổ hợp, đó chỉ là vấn đề cú pháp.
When we actually write a value inside an always block, it needs to be a register. It needs to be a reg type. Mm-hmm.
Khi ta ghi một giá trị bên trong khối always, nó phải là một reg. Nó phải có kiểu reg. Ừm.
So we are using these declarations as sort of a tagging, like you're tagging in one instance, but you're tagging out an output here.
Vậy chúng ta dùng các khai báo này như một kiểu gắn thẻ, như thể bạn gắn thẻ ở một chỗ, nhưng ở đây bạn gắn thẻ cho một đầu ra.
What do you mean by tagging here?
Ý bạn gắn thẻ ở đây là gì?
Like, for example, when you upload an image or a video on the internet, you put a tag on it which the search algorithm can help search for it.
Ví dụ, khi bạn tải một hình ảnh hoặc video lên internet, bạn gắn một thẻ vào đó để thuật toán tìm kiếm có thể giúp tìm ra nó.
So here, you put a piece of metadata on there that would help the simulator know what type of wires. I see. I wouldn't use tagging.
Ở đây cũng vậy, bạn đặt một mẩu siêu dữ liệu vào đó để giúp trình mô phỏng biết đó là loại dây nào. Tôi hiểu. Tôi sẽ không dùng từ gắn thẻ.
I don't think people use that to describe that, but what you said as a metadata is correct.
Tôi không nghĩ người ta dùng từ đó để mô tả việc này, nhưng điều bạn nói về siêu dữ liệu là đúng.
So this basically defines an attribute of the variable actually being used, whether it's an input or output, or whether it's a reg type that will be assigned. We'll also see that wire type earlier.
Về cơ bản, nó định nghĩa một thuộc tính của biến đang thực sự được dùng, dù là đầu vào hay đầu ra, hay là kiểu reg sẽ được gán giá trị. Chúng ta cũng đã thấy kiểu wire ở trước.
What signal, what type is the signal and how they can potentially be used. In different Verilog syntax.
Tín hiệu thuộc loại nào và chúng có thể được dùng ra sao. Trong các cú pháp Verilog khác nhau.
For example, reg can only be assigned inside always block, but wire can be assigned outside the Verilog, the always block. Omar. Well, once that now, we're going to launch at the new type.
Ví dụ, reg chỉ có thể được gán bên trong khối always, nhưng wire có thể được gán bên ngoài, ngoài khối always. Omar. Vâng, giờ chúng ta sẽ khai báo một kiểu mới.
So then, we're going to have two variables in the same way. Yeah, yeah. So you could also, sometimes, I think more commonly, you would just output the reg.
Vậy thì chúng ta sẽ có hai biến theo cùng một cách. Ừ, ừ. Đôi khi, và tôi nghĩ phổ biến hơn, bạn sẽ chỉ xuất ra reg.
It's actually easier instead of having to, both are supported, but especially when you write it more comfortably later, you'll just combine them together.
Thực ra như vậy dễ hơn thay vì phải làm cả hai, cả hai đều được hỗ trợ, nhưng nhất là khi sau này bạn viết thoải mái hơn, bạn sẽ gộp chúng lại với nhau.
I see. So you have multiple always block. So first, I always think this has hardware meanings, right? So you have two always block, typically means two different circuits, right?
Tôi hiểu rồi. Vậy là bạn có nhiều khối always. Trước hết, tôi luôn nghĩ rằng điều này có ý nghĩa về phần cứng, đúng không? Có hai khối always thường nghĩa là hai mạch khác nhau, đúng không?
Two different modules. And then, so again, reg here means where the output of the circuit, right?
Hai module khác nhau. Và một lần nữa, reg ở đây có nghĩa là đầu ra của mạch, đúng không?
So then they basically, generally, they have actually two different outputs for those two modules, two always blocks, right? So then they should be different, right? There's no reason you want to reuse this.
Vậy nên về cơ bản, nói chung, hai module đó thực ra có hai đầu ra khác nhau, hai khối always, đúng không? Vậy chúng nên khác nhau, đúng không? Không có lý do gì để bạn dùng lại cùng một cái.
It doesn't save you anything. Always think about hardware implications. If there are two separate circuits generating two different outputs, they need to be different.
Việc đó chẳng tiết kiệm được gì. Luôn nghĩ đến tác động lên phần cứng. Nếu có hai mạch riêng biệt tạo ra hai đầu ra khác nhau, thì chúng cần phải khác nhau.
Or, so reg is activity. Oh. Yeah, so sometimes you can also skip, or it means basically anything of this changes, we change.
Hoặc, vậy reg là hoạt động. Ồ. Vâng, đôi khi bạn cũng có thể bỏ qua, hoặc về cơ bản nó có nghĩa là bất cứ thứ gì trong đây thay đổi thì chúng ta thay đổi.
Oh, this is just a Verilog syntax. We just add certain conditions. It's always up here. It's always, whenever you say always, yeah. It's just a syntax.
Ồ, đây chỉ là cú pháp Verilog. Chúng ta chỉ thêm một số điều kiện nhất định. Nó luôn ở trên này. Luôn luôn, bất cứ khi nào bạn nói always, vâng. Đó chỉ là cú pháp.
You always add certain conditions. This block is triggered. Again, we'll see a little bit more example later. So this is another way of using always block to write combinational logic.
Bạn luôn thêm một số điều kiện nhất định. Khối này được kích hoạt. Một lần nữa, lát nữa chúng ta sẽ xem thêm vài ví dụ. Đây là một cách khác dùng khối always để viết logic tổ hợp.
And the difference with continuous assignment, the assigned statement that we saw earlier, is that we can use case statement, like a richer syntax to describe.
Và điểm khác với phép gán liên tục, tức câu lệnh assign mà chúng ta đã thấy trước đó, là chúng ta có thể dùng câu lệnh case, một cú pháp phong phú hơn để mô tả.
And as some of the questions we discussed earlier, this need to be assigned to a reg type, but it doesn't always mean a register.
Và như một số câu hỏi chúng ta đã thảo luận trước đó, cái này cần được gán cho kiểu reg, nhưng không phải lúc nào nó cũng có nghĩa là một thanh ghi.
Well, we'll come back to the always block in a minute because there's something also important here. So always block, we'll skip this. This is a ripple carry example mentioned earlier.
Chúng ta sẽ quay lại khối always trong một phút nữa vì ở đây còn có một điều quan trọng. Vậy khối always, chúng ta sẽ bỏ qua cái này. Đây là ví dụ ripple carry đã nhắc đến trước đó.
One thing we want to, this is the same. One thing we brought it here is this, this still looks a little bit tedious, right? So this is like a four-bit ripple carry adder.
Một điều chúng ta muốn, cái này vẫn như cũ. Một điều chúng ta đưa ra ở đây là cái này vẫn trông hơi dài dòng, đúng không? Đây là bộ cộng ripple carry bốn bit.
Sometimes you want to do like 16-bit, 8-bit, 32-bit, right? All the different positions.
Đôi khi bạn muốn làm 16 bit, 8 bit, 32 bit, đúng không? Tất cả các độ rộng khác nhau.
How we can actually do this in a more parameterized fashion so we don't need to actually instantiate or write modules for all the different adders?
Làm sao chúng ta có thể làm việc này theo cách tham số hóa hơn để không cần phải tạo thể hiện hay viết module cho tất cả các bộ cộng khác nhau?
So this is another commonly used feature in Verilog, is to build generators with generate statement.
Đây là một tính năng thường dùng khác trong Verilog, là xây dựng các bộ sinh bằng câu lệnh generate.
This is another syntax you will see a lot when you actually build a parameterized design. So for the adder example, right?
Đây là một cú pháp khác bạn sẽ gặp nhiều khi bạn thực sự xây dựng một thiết kế tham số hóa. Vậy với ví dụ bộ cộng, đúng không?
So we basically, no matter how many different adders, different bit widths we have, right? We always build this kind of propagated adder design, right?
Về cơ bản, dù có bao nhiêu bộ cộng khác nhau, với độ rộng bit khác nhau đi nữa, đúng không? Chúng ta luôn xây dựng thiết kế bộ cộng lan truyền nhớ kiểu này, đúng không?
So what we can alternatively, instead of doing everyone instantiate everyone differently, we can have this parameter here.
Vậy thay vào đó, chúng ta có thể thay vì khởi tạo từng bộ một cách khác nhau, dùng tham số này ở đây.
We use n here to say this parameter represent the number of bits actually used for the adder design.
Ta dùng n ở đây để nói rằng tham số này biểu diễn số bit thực sự được dùng cho thiết kế bộ cộng.
And then we can use this generate syntax to actually write this more like a for loop fashion, right? So this is purely software. This is again for productivity reason, all right?
Rồi ta có thể dùng cú pháp generate này để viết theo kiểu giống vòng lặp for hơn, đúng không? Đây hoàn toàn là phần mềm. Một lần nữa, đây là vì năng suất, được chứ?
So it's actually not a hardware syntax. This is just a software syntax, meaning that we basically want to replicate this full adder cell n times, right?
Vậy nên nó thực ra không phải cú pháp phần cứng. Đây chỉ là cú pháp phần mềm, nghĩa là về cơ bản ta muốn nhân bản ô bộ cộng đầy đủ này n lần, đúng không?
n is the number of bits that we want to, whether it's a 4-bit adder, 16-bit adder, or 32-bit adder that we'll actually use later, right?
n là số bit mà ta muốn, dù là bộ cộng 4 bit, 16 bit, hay bộ cộng 32 bit mà sau này ta sẽ dùng, đúng không?
So again, this comes pretty handy to get parameterized design, because sometimes you don't know what the bit width is and you don't want to actually design a separate module for each of the bit widths, right?
Vậy nên cách này khá tiện để có được thiết kế tham số hóa, vì đôi khi bạn không biết độ rộng bit là bao nhiêu và bạn không muốn thiết kế một module riêng cho từng độ rộng bit, đúng không?
So you want to actually use this generate statement to build a hardware generator that then you can actually instantiate.
Vì thế bạn muốn dùng câu lệnh generate này để xây dựng một bộ sinh phần cứng mà sau đó bạn có thể khởi tạo.
So when you actually instantiate, right, you also pass the n parameter here. This is the parameter defined here.
Khi khởi tạo, bạn cũng truyền tham số n vào đây. Đây là tham số được định nghĩa ở đây.
So here, it means we are building a 64-bit adder, right?
Ở đây nghĩa là ta đang xây dựng một bộ cộng 64 bit, đúng không?
So we don't need to actually write all the lines tediously, and this can be very easy to use to actually instantiate adders of different bit widths.
Vậy ta không cần phải viết từng dòng một cách tẻ nhạt, và cách này rất dễ dùng để khởi tạo các bộ cộng có độ rộng bit khác nhau.
That's another important, very useful syntax of Verilog. So just a quick recap. I like to do this very simplified, very hollow, Verilog's a pretty rich language.
Đó là một cú pháp quan trọng và rất hữu ích khác của Verilog. Vậy xin tóm tắt nhanh. Tôi thích trình bày rất đơn giản, rất sơ lược, vì Verilog là một ngôn ngữ khá phong phú.
We'll actually enforce this with discussions and labs.
Chúng ta sẽ củng cố điều này qua các buổi thảo luận và bài thực hành.
Your TA will also offer more in-depth understanding, but at a high level, the principle I like to follow is we use Verilog to describe combinational logic, right?
Trợ giảng cũng sẽ giúp bạn hiểu sâu hơn, nhưng ở mức tổng quát, nguyên tắc tôi thích theo là dùng Verilog để mô tả logic tổ hợp, đúng không?
There are two ways to describe it. One is what we discussed earlier, continuous assignment, right? So this is basically using the assign syntax, right, to describe how input is propagated to the output.
Có hai cách để mô tả. Một là cách ta đã bàn trước đó, phép gán liên tục, đúng không? Về cơ bản là dùng cú pháp assign, để mô tả cách đầu vào được lan truyền tới đầu ra.
So whenever we use an assign statement, the output is a wire, right? Because it's combinational, right? It is a wire, right? It is, I guess, a metadata we discussed earlier.
Vậy khi dùng câu lệnh assign, đầu ra là một wire, đúng không? Vì nó là tổ hợp, đúng không? Nó là một wire. Tôi đoán đó là siêu dữ liệu mà ta đã bàn trước đó.
There is also another way to describe combinational logic using the always block, always at. Generally, I would always, I just always recommend you to have the star here.
Còn một cách khác để mô tả logic tổ hợp là dùng khối always, always at. Nói chung, tôi luôn khuyên bạn nên có dấu sao ở đây.
You can do always at star, right? So instead of a list, even a lot of times, but especially when we're describing combinational logic. Whenever input changes, output changes, right?
Bạn có thể viết always at sao, đúng không? Thay vì một danh sách, nhiều khi, nhưng đặc biệt là khi ta mô tả logic tổ hợp. Bất cứ khi nào đầu vào thay đổi thì đầu ra thay đổi, đúng không?
Instead of enumerating all the different sensitivity lists, all the different input signals, which you can certainly do, if we're actually describing a combinational logic, especially whenever input changes, output changes, you could actually put this star signal, star here.
Thay vì liệt kê tất cả các danh sách độ nhạy khác nhau, tất cả các tín hiệu đầu vào khác nhau, điều này chắc chắn là làm được, nếu chúng ta đang mô tả một mạch logic tổ hợp, đặc biệt là khi đầu vào thay đổi, thì đầu ra thay đổi, bạn có thể đặt dấu sao này, dấu * ở đây.
It basically means all the inputs. Whenever a certain input changes, we trigger the always block, right? So when we use an always block to describe combinational logic, always at star.
Về cơ bản nó có nghĩa là tất cả các đầu vào. Bất cứ khi nào một đầu vào nào đó thay đổi, ta kích hoạt khối always, đúng không? Vậy khi dùng một khối always để mô tả logic tổ hợp, ta viết always @(*).
This is a combination we want to use. And then you will use always statement. It has to be a reg, right?
Đây là dạng mà chúng ta muốn dùng. Và sau đó bạn sẽ dùng câu lệnh always. Nó phải là reg, đúng không?
So the output has to be declared as a reg type in Verilog, though it doesn't necessarily mean it will, especially in combinational logic, it will not synthesize into a register, right?
Vì vậy đầu ra phải được khai báo kiểu reg trong Verilog, mặc dù điều đó không nhất thiết có nghĩa là nó sẽ, đặc biệt trong logic tổ hợp, nó sẽ không được tổng hợp thành một thanh ghi, đúng không?
We'll talk about how reg is used for sequential logic. But those are basically two ways, a high level principle that we use to describe combinational logic.
Chúng ta sẽ nói về cách reg được dùng cho logic tuần tự. Nhưng về cơ bản đó là hai cách, một nguyên tắc ở mức cao mà ta dùng để mô tả logic tổ hợp.
Either assign statement, assign to a wire, and then, or, an always at star statement and assign to reg. So those are the two styles that we use to describe combinational logic. Question?
Hoặc là câu lệnh assign, gán cho một wire, hoặc là câu lệnh always @(*) và gán cho reg. Đó là hai phong cách mà ta dùng để mô tả logic tổ hợp. Có câu hỏi không?
So like, if you have all the input, output, and then you have all the input, A, B, C, D, and E, the star should be the same as the input A, B, C, D?
Ví dụ, nếu bạn có tất cả đầu vào, đầu ra, rồi bạn có tất cả các đầu vào A, B, C, D, và E, thì dấu sao có giống với các đầu vào A, B, C, D không?
Give you all the input A, B, C, D, yeah. Any of the input changes, it triggers, yeah. Even if it's not used within the block, yeah.
Nó cho bạn tất cả các đầu vào A, B, C, D, đúng vậy. Bất kỳ đầu vào nào thay đổi thì nó cũng kích hoạt, đúng vậy. Kể cả khi nó không được dùng trong khối, đúng vậy.
Yeah, we're saying it's sort of the same thing. They are the same thing. They're just two different ways of writing a combinational logic. Again, with always block, you can use case statements.
Vâng, có thể nói là giống nhau. Chúng là một. Chỉ là hai cách viết khác nhau cho một mạch logic tổ hợp. Ngoài ra, với khối always, bạn có thể dùng câu lệnh case.
That's something nice to have. Question?
Đó là điều rất tiện. Có câu hỏi không?
Have everything, even if it's combinational logic? No, you cannot do that. It's supposed to be, it has to be a wire. You will get a synthesis error, a stretch.
Có thể dùng reg cho mọi thứ, kể cả khi đó là logic tổ hợp không? Không, bạn không thể làm vậy. Nó phải là wire. Bạn sẽ gặp lỗi tổng hợp.
So if it's actually a combinational logic and we're using the assign statement, the output need to be a wire. Yeah, it is a wire. So I guess follow on to that question.
Vậy nếu đó là logic tổ hợp và ta dùng câu lệnh assign, thì đầu ra cần phải là wire. Đúng, nó là wire. Vậy em hỏi tiếp câu này.
Since assign can always be there, so I guess it can always be there. Why am I, if I'm lazy, I just type everything I put and I only use always?
Vì assign lúc nào cũng dùng được, nên em nghĩ nó có thể luôn được dùng. Nếu em lười, em chỉ gõ mọi thứ là reg và chỉ dùng always thì sao?
You can't do that. You can do, you just be careful. You will actually not use reg outside the always block. Yeah, so reg is always, is only used inside the always block.
Bạn không thể làm vậy. Bạn làm được, nhưng phải cẩn thận. Bạn sẽ không dùng reg bên ngoài khối always. Vâng, reg chỉ được dùng bên trong khối always.
So especially with complex logic, assign is actually handy with simple logic, but some of the complex, the combinational logic, you will have to use always statement actually.
Đặc biệt với logic phức tạp, assign tiện với logic đơn giản, nhưng với một số logic tổ hợp phức tạp, thực ra bạn sẽ phải dùng câu lệnh always.
Okay, so that's combinational. We'll see a little bit more example. It may seem like a little bit weird why we actually do that, because always block is also used in sequential logic.
Được rồi, đó là logic tổ hợp. Chúng ta sẽ xem thêm một vài ví dụ. Có thể thấy hơi kỳ lạ tại sao ta lại làm như vậy, vì khối always cũng được dùng trong logic tuần tự.
So that's why it's a little bit, we want to differentiate the way in combinational logic and sequential logic here.
Vì thế nó hơi, chúng ta muốn phân biệt cách viết giữa logic tổ hợp và logic tuần tự ở đây.
Okay, so with that, we're going to go through a couple quick questions. Just see, we're designing a combinational circuit. We have three examples of Verilog implementation.
Được rồi, với phần đó, chúng ta sẽ đi qua một vài câu hỏi nhanh. Hãy xem nhé, chúng ta đang thiết kế một mạch tổ hợp. Chúng ta có ba ví dụ về cách cài đặt bằng Verilog.
Again, they are combinational logic. Let's see whether those circuits are implemented correctly. We have three examples, three different Verilog styles.
Một lần nữa, chúng đều là logic tổ hợp. Hãy xem các mạch đó có được cài đặt đúng hay không. Chúng ta có ba ví dụ, ba phong cách Verilog khác nhau.
And then let's see whether it's actually done correctly or not. Let's do, let's give like one minute. You can go through all of them to see whether it actually matches your understanding.
Rồi hãy xem thực sự chúng có đúng hay không. Chúng ta dành khoảng một phút. Các bạn có thể xem qua tất cả để kiểm tra xem chúng có khớp với cách các bạn hiểu hay không.
So here's what I remember. Let me try to mute some of the folks on Zoom.
Đây là những gì tôi nhớ. Để tôi thử tắt tiếng một số bạn trên Zoom.
For folks, you are, please use raise hand if you want to talk so that I can also take a look at, get to you.
Với các bạn đang hãy dùng nút giơ tay nếu muốn phát biểu để tôi cũng có thể xem và gọi đến bạn.
So we have three examples. Feel free to talk to others as we want to discuss.
Chúng ta có ba ví dụ. Cứ thoải mái trao đổi với người khác nếu muốn thảo luận.
All of those are supposed to be combinational circuits. I've already seen that the proper, you know, like metadata has been running. Yeah, you'll kind of see on me how it's assigned correctly.
Tất cả chúng đều được cho là các mạch tổ hợp. Tôi đã thấy là siêu dữ liệu phù hợp đã được chạy. Vâng, các bạn sẽ thấy qua tôi việc nó được gán đúng như thế nào.
Okay, let's see whether those implementations are correct. I don't think there are non-trivial numbers that are actually online. Good to see you all. Okay, we'll go through all of them together.
Được rồi, hãy xem các cách cài đặt đó có đúng không. Tôi không nghĩ là có những con số không tầm thường nào thực sự đang trực tuyến. Rất vui được gặp các bạn. Được rồi, chúng ta sẽ cùng đi qua tất cả.
Let's go through the first one. I'll do the first one with students on Zoom. We look at example A, we want to build a three-input adder. Is this always block correct?
Hãy xem ví dụ đầu tiên. Tôi sẽ làm ví dụ đầu tiên cùng các bạn trên Zoom. Chúng ta xem ví dụ A, ta muốn xây dựng một bộ cộng ba đầu vào. Khối always này có đúng không?
For folks on Zoom, if you want to respond, Raise your hand or the chat window. Okay, so a couple say no. Yeah, a few say no. What are the reasons?
Với các bạn trên Zoom, nếu muốn trả lời, hãy giơ tay hoặc dùng cửa sổ chat. Được rồi, một vài bạn nói không. Vâng, một số bạn nói không. Lý do là gì?
Because of the, so does not update on C change. Yes, so here, the Verilog error: missing C sensitivity, right? So we have a three-input adder, right?
Vì nó không cập nhật khi C thay đổi. Đúng, ở đây là lỗi Verilog: thiếu C trong danh sách độ nhạy, đúng không? Chúng ta có một bộ cộng ba đầu vào, đúng không?
So output is supposed to change when either of the inputs actually changes, right?
Vậy đầu ra phải thay đổi khi một trong các đầu vào thực sự thay đổi, đúng không?
So here, our sensitivity list only includes A and B, A or B, but it could be after C changes, we also want to trigger the logic.
Ở đây, danh sách độ nhạy của ta chỉ gồm A và B, A hoặc B, nhưng có thể sau khi C thay đổi, ta cũng muốn kích hoạt logic.
Question? Is Verilog a really good error or just happily compiled? It's just happily compiled because it doesn't know your intention.
Câu hỏi: Verilog có báo lỗi thật sự hay chỉ biên dịch bình thường? Nó chỉ biên dịch bình thường vì nó không biết ý định của bạn.
Yeah, sometimes in a weird fashion, you may actually want to design a circuit like this.
Vâng, đôi khi theo một cách kỳ lạ, bạn có thể thật sự muốn thiết kế một mạch như thế này.
So unfortunately, yeah, I think there are some more research topic is actually to make Verilog either a little bit more user-friendly or some stronger type system to actually enforce certain rules.
Nên đáng tiếc là, tôi nghĩ có một số chủ đề nghiên cứu nhằm làm cho Verilog thân thiện với người dùng hơn một chút hoặc có hệ thống kiểu mạnh hơn để thực thi một số quy tắc nhất định.
But unfortunately, it's just happily compiled. Get the unintentional. Question?
Nhưng đáng tiếc là nó chỉ biên dịch bình thường, dẫn đến kết quả không chủ ý. Câu hỏi?
Could you do this if you define a C to be a constant?
Bạn có thể làm vậy nếu định nghĩa C là một hằng số không?
Yeah, I guess this function, again, we actually mentioned we want to do a three-input adder. I guess I can make it even more explicit. Three inputs, each of them are actually variables.
Vâng, tôi nghĩ hàm này, một lần nữa, chúng ta đã nói là muốn làm một bộ cộng ba đầu vào. Tôi có thể nói rõ hơn nữa. Ba đầu vào, mỗi đầu vào đều là biến.
Yeah, but if you could just replace C with constant here. Well, it's not the example, it's the intention to design here, right? So there's a question there.
Vâng, nhưng bạn có thể thay C bằng một hằng số ở đây. À, vấn đề không phải ví dụ, mà là ý định thiết kế ở đây, đúng không? Vậy có một câu hỏi ở đây.
What kind of hardware could this be even synthesized to? That's a good question.
Thậm chí phần cứng nào có thể được tổng hợp ra từ đoạn mã này? Câu hỏi hay đấy.
So in this case, so this will actually, sometimes you will actually, that's a good question, sometimes you will actually get inferred or they will actually say, you will actually unintentionally create A, B, and C, create a latch here that store the temporal value of C.
Trong trường hợp này, đôi khi bạn sẽ thấy, câu hỏi hay đấy, đôi khi bạn sẽ thấy công cụ suy ra hoặc có thể nói là bạn vô tình tạo ra A, B, và C, tạo ra một latch ở đây lưu giá trị tạm thời của C.
So you will actually do still, let's do this as adder block to get output, but we will be basically using the old value. You will actually create a storage element.
Nên bạn vẫn có khối bộ cộng để cho ra đầu ra, nhưng về cơ bản nó sẽ dùng giá trị cũ. Bạn sẽ tạo ra một phần tử lưu trữ.
If that's the intention, you want to actually do that separately. But again, we are actually designing, again, this is a combinational logic. You are creating, this is actually becoming a sequential logic.
Nếu đó là chủ ý, bạn nên làm điều đó một cách riêng biệt. Nhưng ở đây ta đang thiết kế một mạch tổ hợp. Bạn đang tạo ra, và nó trở thành một mạch tuần tự.
We need to store the old value of C. So again, we're talking about combinational logic. If we actually want to use always @, I will just always do star, right?
Ta cần lưu giá trị cũ của C. Vậy một lần nữa, ta đang nói về mạch tổ hợp. Nếu ta muốn dùng always @, tôi sẽ chỉ dùng always @ dấu sao, đúng không?
So it just, all the inputs are on the sensitivity, this. How would you update C? Do you have another always block with just C?
Như vậy tất cả các đầu vào đều nằm trong danh sách độ nhạy này. Bạn cập nhật C thế nào? Bạn có một khối always khác chỉ cho C không?
How do we update C? Yeah, you just say always @ C again. It depends, but let's say if this is my module, it will be basically an input, right?
Làm sao cập nhật C? Vâng, bạn chỉ cần viết lại always @ C. Còn tùy, nhưng giả sử đây là module của tôi, thì nó về cơ bản là một đầu vào, đúng không?
Whenever input changes. You mean? Like, if it's here, when I assign a prediction, it's gonna make a set of latches. Right. Oh. Yeah, there'll be a clock signal, right?
Mỗi khi đầu vào thay đổi. Ý bạn là vậy? Ví dụ, nếu ở đây, khi tôi gán một giá trị dự đoán, nó sẽ tạo ra một tập các latch. Đúng. Ồ. Vâng, sẽ có một tín hiệu xung nhịp, đúng không?
So this will be a sequential, yeah. This will be a sequential. So this is, again, not the intention, no. We are building a combinational circuit here.
Vậy nó sẽ là mạch tuần tự, vâng. Nó sẽ là mạch tuần tự. Vì vậy đây lại không phải chủ ý, không. Ở đây ta đang xây dựng một mạch tổ hợp.
Okay, so again, the high-level principle, always @ star for combinational circuit to have a more clarified, just get a clear vision of how we actually want to do this.
Được rồi, một lần nữa, nguyên tắc cấp cao là always @ dấu sao cho mạch tổ hợp để rõ ràng hơn, và có cái nhìn rõ về cách ta thực sự muốn làm việc này.
Go through the other a little bit quickly. Example B, we have an assign statement here. Is that right or wrong?
Ta sẽ lướt qua các ví dụ còn lại khá nhanh. Ví dụ B, ta có một câu lệnh assign ở đây. Đúng hay sai?
Exactly, we already briefly mentioned this earlier, right? So we have two signals in, out. We go through AND gate, but then we actually have this combinatorial loop, right?
Chính xác, ta đã nhắc sơ qua điều này trước đó rồi, đúng không? Vậy ta có hai tín hiệu vào, ra. Ta đi qua cổng AND, nhưng sau đó lại có vòng lặp tổ hợp này, đúng không?
With this, this is basically an incorrect circuit, right? We don't know what's the intention of the circuit. The circuit will always oscillate, so it will not actually reach a value, because it's always toggling.
Như vậy về cơ bản đây là một mạch không đúng, phải không? Ta không biết chủ ý của mạch này là gì. Mạch sẽ luôn dao động, nên nó sẽ không bao giờ đạt tới một giá trị, vì nó luôn đảo trạng thái.
So we don't do this combinational. Combinatorial loop in our design. So always keep an eye on this.
Vì vậy ta không làm thế này với mạch tổ hợp. Vòng lặp tổ hợp trong thiết kế của ta. Nên luôn để mắt tới điều này.
Sometimes you see tools actually, so when design gets a little bit more complex, It's not as straightforward as this, but the tool sometimes will actually complain: we're actually observing a combinatorial loop, right?
Đôi khi bạn thấy các công cụ khi thiết kế phức tạp hơn một chút, thì nó không đơn giản như thế này, nhưng đôi khi công cụ sẽ cảnh báo: chúng ta đang thấy một vòng lặp tổ hợp (combinatorial loop), đúng không?
So you need to actually take a look at what's going on. Question?
Vì vậy bạn cần xem xét kỹ chuyện gì đang xảy ra. Có câu hỏi không?
Yeah, so sometimes, so today's tool is also getting better. You could also link to it. So you can basically, this will be a tool. You will actually also see that in your synthesis flow.
Vâng, đôi khi, các công cụ ngày nay cũng đang tốt hơn. Bạn cũng có thể liên kết tới nó. Về cơ bản, đây sẽ là một công cụ. Bạn cũng sẽ thấy điều đó trong quy trình tổng hợp (synthesis flow) của mình.
It basically gives you warnings of potential very long syntax errors that actually show up in your design. So always lint, especially the bitwise mismatch, the tools are actually getting better.
Về cơ bản nó đưa ra cảnh báo về những lỗi cú pháp rất dài có thể xảy ra xuất hiện trong thiết kế của bạn. Vì vậy hãy luôn chạy lint, đặc biệt là với lỗi không khớp bit (bitwise mismatch), các công cụ đang ngày càng tốt hơn.
Verilog is actually pretty good at handling this because you can actually do that automatically. So you can always use the lint tools to actually check some of the syntax errors here.
Verilog xử lý việc này khá tốt vì bạn có thể làm điều đó một cách tự động. Vì vậy bạn luôn có thể dùng các công cụ lint để kiểm tra một số lỗi cú pháp ở đây.
But some of the errors, Verilog is today's tool, because they don't know your intention, right?
Nhưng với một số lỗi, Verilog, tức công cụ ngày nay, vì chúng không biết ý định của bạn, đúng không?
Sometimes maybe people do have certain intentions to do certain things, but always using a lint tool is actually pretty good to catch some of the errors. So finally, example C, the last combinational logic.
Đôi khi có thể người ta có ý định nhất định để làm một việc nào đó, nhưng luôn dùng công cụ lint là khá tốt để bắt một số lỗi. Cuối cùng, ví dụ C, đoạn logic tổ hợp cuối cùng.
Is this one correct or not?
Đoạn này đúng hay sai?
Immediately, immediately I noticed that output is input one, one on top of my input. So that's the last, so that's the reason. Exactly. So this is another very common error.
Ngay lập tức, tôi nhận ra rằng đầu ra là đầu vào một, một nằm trên đầu vào của tôi. Đó là cái cuối cùng, đó chính là lý do. Chính xác. Đây là một lỗi rất phổ biến khác.
You always want to either have a default value so that we can always go back to the default value or cover all the different scenarios.
Bạn luôn muốn hoặc là có một giá trị mặc định để chúng ta luôn có thể quay về giá trị mặc định hoặc là bao phủ tất cả các trường hợp khác nhau.
So those are also other things to keep an eye on when we actually use the case statement here.
Đó cũng là những điều khác cần lưu ý khi chúng ta dùng câu lệnh case ở đây.
You mean, when do we prefer using a default value? I mean, it depends.
Ý bạn là khi nào chúng ta ưu tiên dùng giá trị mặc định? Tùy trường hợp.
If the functionality actually does support different scenarios, very distinct scenarios, you want to actually make sure you specify just scenario clarity.
Nếu chức năng thực sự hỗ trợ các trường hợp khác nhau, những trường hợp rất riêng biệt, bạn nên đảm bảo chỉ rõ từng trường hợp cho rõ ràng.
But maybe in a scenario, even if you have, you use like three bits, there could be like eight different conditions, but you only care, I don't know, five of those.
Nhưng có thể trong một trường hợp, dù bạn dùng chẳng hạn ba bit, có thể có tám điều kiện khác nhau, nhưng bạn chỉ quan tâm, tôi không rõ, năm điều kiện trong đó.
The rest, you don't really care. That having a, it's more like writeability, which is easier to write, right? Having a default value, you don't need to specify all the different conditions.
Phần còn lại, bạn không thực sự quan tâm. Khi đó việc có giá trị mặc định thiên về tính dễ viết hơn, tức là cái nào dễ viết hơn, đúng không? Có giá trị mặc định thì bạn không cần chỉ rõ tất cả các điều kiện khác nhau.
If each different condition does actually have a supposed expected behavior, you'll want to actually do that explicitly. Yeah, so, no one, one case here, what would that?
Nếu mỗi điều kiện khác nhau thực sự có một hành vi mong đợi nhất định, bạn nên viết tường minh như vậy. Vâng, vậy không ai, một trường hợp ở đây thì sẽ thế nào?
So this is as, I think Ryan, well, as we discussed earlier, we'll actually create, it becomes a sequential element because we actually store the previous value so that we can actually use it later.
Như tôi nghĩ Ryan, như chúng ta đã thảo luận trước đó, chúng ta sẽ tạo ra, nó trở thành một phần tử tuần tự vì chúng ta lưu giá trị trước đó để có thể dùng nó sau này.
It doesn't do anything, but we need to store that value, yeah. So it becomes a sequential.
Nó không làm gì cả, nhưng chúng ta cần lưu giá trị đó, vâng. Vì vậy nó trở thành mạch tuần tự.
Oh, you want me to, what?
Ồ, bạn muốn tôi, gì cơ?
Well, that still doesn't fix it, right, because you still have this combinational, combinatorial loop, right?
Chà, như vậy vẫn chưa giải quyết được, đúng không, vì bạn vẫn còn vòng lặp tổ hợp này, đúng không?
What kind of scenario do you actually want to declare the variable as an inout? What's that? Not necessarily.
Trong trường hợp nào thì bạn thực sự muốn khai báo biến là inout? Sao cơ? Không nhất thiết.
I think sometimes actually you don't know, and the tool will actually synthesize accordingly, whether it's an input or an output. I think it's actually more for writeability.
Em nghĩ đôi khi mình không biết trước, và công cụ sẽ tự tổng hợp cho phù hợp, xem đó là đầu vào hay đầu ra. Em nghĩ nó chủ yếu để viết mã cho tiện.
I need to get back to you to find a good example that actually makes sense. I need to.
Em cần quay lại với bạn sau để tìm một ví dụ hay, thực sự hợp lý. Em cần làm vậy.
But you still actually determine that you don't want to actually have this kind of loop. You're actually overwriting.
Nhưng bạn vẫn phải xác định rằng mình không muốn có kiểu vòng lặp này. Bạn đang ghi đè lên nó.
I think we actually, generally, when I use that actually, it's a little bit tedious to figure out whether it's an input or output, so I use inout, and then the tool actually assigns input and output for me, instead of explicit.
Em nghĩ nói chung khi em dùng nó, việc xác định là đầu vào hay đầu ra hơi mất công, nên em dùng inout, rồi công cụ tự gán đầu vào và đầu ra cho em, thay vì khai báo tường minh.
But I'll get back to you on this. Good question.
Nhưng em sẽ quay lại với bạn về chuyện này. Câu hỏi hay.
If you didn't have any statement, say, after one of these statements, does it default to the next one, or is there no default for the case statement? You mean for the case statement?
Nếu không có câu lệnh nào, chẳng hạn sau một trong các câu lệnh này, nó có mặc định chạy sang câu tiếp theo không, hay câu lệnh case không có mặc định? Ý bạn là với câu lệnh case phải không?
If you don't have a default statement, it will actually not fall through, and then it will actually store the previous value.
Nếu không có câu lệnh default, nó sẽ không chạy tiếp xuống các nhánh sau, và nó sẽ lưu giá trị trước đó.
Or even, like, let's say you have multiple statements and you want all of them in one statement, or do you have to do the best that you can find?
Hoặc ví dụ, giả sử bạn có nhiều câu lệnh và muốn gộp tất cả vào một câu lệnh, hay là phải làm cách tốt nhất mà bạn tìm được?
So you mean for each of the conditions, there are actually multiple things going on? No, no, no.
Ý bạn là với mỗi điều kiện, có nhiều việc cùng diễn ra phải không? Không, không, không.
Let's just say you wanted the timeout to be zero in the zero, zero case and the zero, one case. Uh-oh, you can't just... Both two will actually go through the same.
Giả sử bạn muốn timeout bằng 0 trong trường hợp 0, 0 và trường hợp 0, 1. Ồ, bạn không thể chỉ... Cả hai trường hợp sẽ cùng đi qua một xử lý.
Yeah, I need to also double-check the syntax. Sometimes what people do is, actually, if there's some uncommon case, common scenario, actually do that before the case statement.
Vâng, em cũng cần kiểm tra lại cú pháp. Đôi khi người ta làm thế này: nếu có một trường hợp ít gặp, hoặc một tình huống chung, thì xử lý trước câu lệnh case.
So that's basically all the logic actually goes through. For this, I think it will actually go through each individual. It's not actually executed sequentially. It actually goes through each individual.
Như vậy về cơ bản mọi logic đều đi qua đó. Với trường hợp này, em nghĩ nó sẽ xét từng nhánh riêng lẻ. Nó không được thực thi tuần tự. Nó xét từng nhánh riêng lẻ.
But if there's some common logic, you can actually do that before the case statement, and that will always be executed. Okay, a lot of interesting syntax about combinational logic.
Nhưng nếu có một số logic chung, bạn có thể đặt nó trước câu lệnh case, và nó sẽ luôn được thực thi. Được rồi, có rất nhiều cú pháp thú vị về logic tổ hợp.
Oh, announcement. So we have homework one out last week. It's due this Friday. All the discussions will also start this week.
À, thông báo. Bài tập về nhà 1 đã được đăng tuần trước. Hạn nộp là thứ Sáu này. Tất cả các buổi thảo luận cũng sẽ bắt đầu từ tuần này.
And I think we only started one Friday discussion, and we have an early discussion today. But all the discussions will start this week. Lab two also starts this week.
Em nghĩ mới chỉ có một buổi thảo luận thứ Sáu bắt đầu, và hôm nay có một buổi thảo luận sớm. Nhưng tất cả các buổi thảo luận sẽ bắt đầu từ tuần này. Lab 2 cũng bắt đầu tuần này.
So since lab two, everyone should get your assigned, either FPGA or ASIC lab, and then go to your assigned lab. And we'll use that to figure out the deadline for each of you.
Vì vậy từ lab 2, mọi người sẽ được giao lab FPGA hoặc ASIC của mình, rồi vào phòng lab được phân công của mình. Và chúng tôi sẽ dựa vào đó để xác định hạn nộp cho từng bạn.
Any questions on the logistics side? Makes sense? Clear? No questions? Okay, great.
Có câu hỏi nào về phần thông báo không? Rõ chưa? Rõ rồi chứ? Không có câu hỏi à? Được, tuyệt.
So in today's lecture, we started a very long discussion. We talked about the combinational circuit. I mentioned a design statement and always block.
Vậy trong bài giảng hôm nay, chúng ta đã bắt đầu một phần thảo luận rất dài. Chúng ta đã nói về mạch tổ hợp. Tôi đã đề cập đến câu lệnh khai báo thiết kế và khối always.
Next, we're going to talk about sequential circuit. And one thing you will see is that always block is also used here.
Tiếp theo, chúng ta sẽ nói về mạch tuần tự. Và một điều các bạn sẽ thấy là khối always cũng được dùng ở đây.
So that's why we actually have different ways of actually using always block for combinational and sequential logic. So just a quick recap of sequential logic. We went through this last time.
Chính vì vậy mà thực ra có những cách khác nhau để dùng khối always cho logic tổ hợp và logic tuần tự. Xin nhắc lại nhanh về logic tuần tự, chúng ta đã học ở buổi trước.
It's basically output. It's not just a combination of input, but also some internal state, right? So here we actually have storage element or memory element. So this is actually being stored.
Về cơ bản, đầu ra không chỉ là một tổ hợp của đầu vào mà còn phụ thuộc vào một trạng thái bên trong, đúng không? Vì vậy ở đây ta có phần tử lưu trữ, hay phần tử nhớ. Tức là giá trị này đang được lưu lại.
So that's why it's actually a sequential element. So for the majority of the discussion, we want to use a register or flip-flop that actually in our sequential logic.
Đó là lý do nó là một phần tử tuần tự. Vì vậy trong phần lớn nội dung thảo luận, chúng ta muốn dùng thanh ghi hoặc flip-flop trong logic tuần tự của mình.
So it's basically, we mentioned earlier, if input changes, output actually doesn't change immediately. Output actually changes only after clock signal. So we have this triggering of clock signal here, right?
Như đã nói trước đó, nếu đầu vào thay đổi thì đầu ra không thay đổi ngay lập tức. Đầu ra chỉ thay đổi sau tín hiệu xung nhịp. Vậy ở đây ta có sự kích hoạt bởi tín hiệu xung nhịp, đúng không?
So output is actually propagated or simple the input value after the clock signal. So this is the difference. So continuous assignment output always changes whenever input changes.
Đầu ra được truyền đi, hay đơn giản là nhận giá trị đầu vào, sau tín hiệu xung nhịp. Đây chính là điểm khác biệt. Với phép gán liên tục, đầu ra luôn thay đổi mỗi khi đầu vào thay đổi.
And this is actually changes only after the clock signal. So registers are actually what we'll be actually using in building sequential logic. Did you define the delay, or sorry?
Còn ở đây, nó chỉ thay đổi sau tín hiệu xung nhịp. Vì vậy thanh ghi chính là thứ chúng ta sẽ dùng để xây dựng logic tuần tự. Bạn có định nghĩa độ trễ không, à xin lỗi?
Is that, that's actually, we don't get to define the delay. That's actually technology dependent.
Chúng ta không định nghĩa độ trễ. Nó phụ thuộc vào công nghệ.
So this, we'll actually talk a little bit more later when we get to timing, but this clock to queue delay is actually characterized by technology.
Chúng ta sẽ nói thêm một chút về điều này khi học đến định thời, nhưng độ trễ từ xung nhịp đến đầu ra này được đặc trưng bởi công nghệ.
Yeah, we don't control. So in parallel, it's not, you don't define it? There is a place you define it, is actually in the testbench.
Vâng, chúng ta không điều khiển nó. Vậy với song song thì bạn cũng không định nghĩa nó? Nơi bạn có thể định nghĩa nó là trong testbench.
You can actually define when certain things actually show up, but that's actually not generated hardware. It's actually in testbenches, yeah.
Bạn có thể xác định khi nào một số thứ xuất hiện, nhưng đó không phải là phần cứng được tạo ra. Nó chỉ nằm trong testbench thôi.
So for registers, again, we mentioned this. You can also have multi-bit registers. And whenever we have this slash here, it means multi-bits.
Về thanh ghi, chúng ta cũng đã đề cập điều này. Bạn cũng có thể có thanh ghi nhiều bit. Và khi có dấu gạch chéo ở đây, nghĩa là nhiều bit.
And then the register is basically this triangle, but we always trigger by register.
Còn thanh ghi về cơ bản là hình tam giác này, nhưng chúng ta luôn kích hoạt bằng thanh ghi.
One thing with sequential logic is that to use, to build sequential logic in Verilog, we basically always use, oh yeah, it's always block because this actually makes sense thinking from a sensitivity point of view, right?
Một điều với logic tuần tự là để dùng, để xây dựng logic tuần tự trong Verilog, về cơ bản chúng ta luôn dùng, à đúng rồi, khối always, vì điều này hợp lý khi suy nghĩ theo quan điểm về danh sách độ nhạy, đúng không?
Because we have this triggering of clock signal, Right? So we want to assign output to the expected values whenever clock is triggered.
Bởi vì ta có sự kích hoạt bởi tín hiệu xung nhịp, đúng không? Nên ta muốn gán đầu ra cho giá trị mong đợi giá trị mỗi khi xung clock được kích hoạt.
And we use always at block to describe this behavior, right? But here, again, the same keywords, always at, right?
Và ta dùng khối always để mô tả hành vi này, đúng không? Nhưng ở đây, vẫn là từ khóa always @ đó, đúng không?
But now in the sensitivity list, we actually describe the clock signal here, because we mentioned earlier, the output is actually sampled whenever we have a triggering of the clock signal, right?
Nhưng bây giờ trong danh sách độ nhạy, ta mô tả tín hiệu clock ở đây, vì như đã nói ở trên, đầu ra thực sự được lấy mẫu mỗi khi có một lần kích hoạt của tín hiệu clock, đúng không?
It can be pulse edge, basically from, it's possible like from low to high. This is a pulse edge clock. Sometimes we also see neck edge. So it's basically from high to low, right?
Đó có thể là cạnh lên, tức là chuyển từ thấp lên cao. Đây là clock cạnh lên. Đôi khi ta cũng thấy cạnh xuống. Tức là chuyển từ cao xuống thấp, đúng không?
So it's either pulse edge or neck edge. So that specifies the design with register, right? Whenever the clock is triggered, we now actually sample the input.
Vậy là hoặc cạnh lên hoặc cạnh xuống. Như vậy là ta đã chỉ định thiết kế có thanh ghi, đúng không? Mỗi khi clock được kích hoạt, lúc này ta mới lấy mẫu đầu vào.
So it's not actually sensitive input. It actually depends on the clock. And then of course, the register behaviors, we can also reset.
Vậy nên nó không thực sự nhạy với đầu vào. Nó thực sự phụ thuộc vào clock. Và tất nhiên, với hành vi của thanh ghi, ta cũng có thể reset.
So in this case, reset is actually triggered also after, so we need to trigger clock first.
Trong trường hợp này, reset cũng chỉ được kích hoạt sau, nên trước hết cần có xung clock kích hoạt.
So that's why it's called synchronous set and reset, because set and reset is also synchronous with clock, right?
Đó là lý do nó được gọi là set và reset đồng bộ, vì set và reset cũng đồng bộ với clock, đúng không?
So again, in this case, when you'll see this red syntax, it does mean actually a register, because we are actually building sequential logic.
Vậy nên, khi bạn thấy cú pháp màu đỏ này, nó thực sự có nghĩa là một thanh ghi, vì ta đang xây dựng logic tuần tự.
We are actually assigning values to the sequential, to the register. We are actually instantiating a register. So two different styles of using always block.
Ta đang gán giá trị cho phần tử tuần tự, cho thanh ghi. Ta đang tạo ra (instantiate) một thanh ghi. Vậy là có hai kiểu dùng khối always khác nhau.
With combinational logic, we have this always at star here, although it's also reg output, but it's actually a combinational logic. We have always star.
Với logic tổ hợp, ta có always @ * ở đây, mặc dù đầu ra cũng khai báo là reg, nhưng thực chất nó là logic tổ hợp. Ta có always @ *.
Again, the high level with a sequential logic, we do always have pulse edge clock.
Còn ở mức tổng quát, với logic tuần tự, ta luôn có always @ posedge clock.
So this signals that we are actually changing the hardware based on the clock signal, but that's why it's a sequential logic. So the generated hardware will be something like this.
Điều này báo hiệu rằng ta đang thay đổi phần cứng dựa trên tín hiệu clock, và đó là lý do nó là logic tuần tự. Phần cứng được sinh ra sẽ trông giống như thế này.
We'll get a combinational hardware. We will use always at star and we'll also, we'll generate a sequential circuit with our clock edge triggering with sequential, with always at pulse edge.
Ta sẽ có phần cứng tổ hợp. Ta dùng always @ * và cũng sẽ sinh ra mạch tuần tự được kích hoạt bởi cạnh clock với always @ posedge.
Again, so there are high level general ways of defining that. You may already notice that we're using a slightly different assignment. Instead of this equal sign, we have this less-than-or-equal sign here.
Một lần nữa, đây là những cách tổng quát để định nghĩa chúng. Có thể bạn đã nhận ra ta đang dùng phép gán hơi khác. Thay vì dấu bằng, ở đây ta có dấu nhỏ hơn hoặc bằng.
We'll talk about that later, next lecture, related with blocking and non-blocking assignment in sequential logic.
Ta sẽ nói về điều này sau, ở bài giảng tới, liên quan đến phép gán blocking và non-blocking trong logic tuần tự.
But always block can be used in both combinational and sequential, and for combinational, always use always @ star as a syntax, and for sequential, we will do the always @ posedge.
Nhưng khối always có thể dùng cho cả logic tổ hợp và tuần tự, với logic tổ hợp, luôn dùng cú pháp always @ *, còn với logic tuần tự, ta dùng always @ posedge.
We'll talk about how we describe different sequential circuits and the blocking and non-blocking assignment next lecture. Okay, so already almost the end of the lecture.
Ta sẽ nói về cách mô tả các mạch tuần tự khác nhau và phép gán blocking và non-blocking ở bài giảng tới. Được rồi, vậy là gần hết bài giảng.
Great to see you all, and I'll see you this Thursday.
Rất vui được gặp các bạn, và hẹn gặp lại vào thứ Năm này.
Đăng nhập để đánh giá học liệu này.
Đăng nhập để bình luận — chưa ai bình luận về học liệu này.
Không có khóa học liên quan.