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ả.
Okay, well, good morning everyone. Great to see you out here. Welcome to EECS 151/251A, Introduction to Digital Design and Integrated Circuits. I think we're really the last mile of our discussion.
Được rồi, chào buổi sáng cả lớp. Rất vui được gặp các bạn ở đây. 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. Tôi nghĩ chúng ta đang ở chặng cuối của phần thảo luận này.
We're going to see how we actually build different sequential logic. We start talking about the timing analysis, how the different components of timing affect our sequential circuits.
Chúng ta sẽ xem thực sự xây dựng các loại logic tuần tự khác nhau như thế nào. Chúng ta bắt đầu nói về phân tích thời gian, về việc các thành phần thời gian khác nhau ảnh hưởng đến các mạch tuần tự của chúng ta ra sao.
We'll actually dig deeper into how we build sequential circuit elements, specifically flip-flops and SRAMs, in today's lecture and also next Tuesday, to actually think how we actually can build fairly complex circuits.
Chúng ta sẽ đi sâu hơn vào cách xây dựng các phần tử mạch tuần tự, cụ thể là flip-flop và SRAM, trong bài giảng hôm nay và cả thứ Ba tuần sau, để nghĩ xem làm thế nào thực sự xây dựng được những mạch khá phức tạp.
Since we're talking about building systems, they should be already pretty familiar with, for all of you, the Tapeout class. I heard they have a huge enrollment. I think they're with us.
Vì chúng ta đang nói về việc xây dựng hệ thống, nên các bạn hẳn đã khá quen thuộc với lớp Tapeout, với tất cả các bạn. Tôi nghe nói lớp đó có lượng đăng ký rất lớn. Tôi nghĩ các bạn ấy đang ở đây với chúng ta.
Those are actually full. Last time I heard, they're still aiming to actually clear the waitlist. So if you are either enrolled or on the waitlist, good news. I think they will actually accept everyone.
Lớp đó đã đầy. Lần trước tôi nghe thì họ vẫn đang cố gắng xử lý hết danh sách chờ. Vì vậy nếu bạn đã đăng ký hoặc đang trong danh sách chờ, có tin vui đây. Tôi nghĩ họ sẽ nhận tất cả mọi người.
I'm not sure how they plan to actually expand further, but this is a really cool class and it's really great.
Tôi không chắc họ định mở rộng thêm bằng cách nào, nhưng đây là một lớp rất thú vị và rất tuyệt.
Every year, I see 151 students actually graduate from 151 and start joining the Tapeout and the Bring-Up class. The instructors are fairly ambitious.
Năm nào tôi cũng thấy sinh viên hoàn thành 151 rồi bắt đầu tham gia lớp Tapeout và lớp Bring-Up. Các giảng viên khá tham vọng.
This year, they are talking about the possibility of taking out three chips in one semester in the Tapeout class. That's massive.
Năm nay, họ đang bàn đến khả năng chế tạo ba con chip trong một học kỳ ở lớp Tapeout. Thật là lớn.
When they do two chips, I already think that's a lot of work, but they're actually talking about considering at least building three chips. So I think this will be a fun class.
Khi họ làm hai chip, tôi đã nghĩ đó là rất nhiều việc rồi, vậy mà họ đang cân nhắc làm ít nhất ba chip. Vì vậy tôi nghĩ đây sẽ là một lớp thú vị.
A lot of students actually really enjoy the class.
Rất nhiều sinh viên thực sự yêu thích lớp này.
They learn a lot through that process and this really gets you a feeling of when 151 gives you the structure, how we actually do things, but that class actually goes all the way through the flow and you actually get the chip back later that year.
Các bạn học được rất nhiều qua quá trình đó và nó cho bạn cảm nhận rằng 151 cho bạn khung cấu trúc, cách chúng ta làm mọi việc, nhưng lớp kia thì đi trọn vẹn toàn bộ quy trình và bạn nhận lại con chip vào cuối năm đó.
I think the Beardy ML chip is already back this month. I think they're getting ready to test it. So you will do Tapeout class and you can do Bring-Up class.
Tôi nghĩ chip Beardy ML đã về trong tháng này. Tôi nghĩ họ đang chuẩn bị kiểm tra nó. Vậy bạn sẽ học lớp Tapeout và có thể học lớp Bring-Up.
It's a really nice sequence. You do 151, Taipao, then BringUp. Then you actually get to see the entire flow of doing a very complex chip design these days.
Đó là một chuỗi môn rất hay. Bạn học 151, Tapeout, rồi Bring-Up. Khi đó bạn được thấy toàn bộ quy trình thiết kế một con chip rất phức tạp ngày nay.
That's a very rare experience, especially for undergrads. So for folks who are interested, definitely check it out and also see some of the past designs the students actually did in the past semester.
Đó là trải nghiệm rất hiếm, đặc biệt với sinh viên đại học. Vì vậy với những bạn quan tâm, nhất định hãy tìm hiểu và xem thêm một số thiết kế mà sinh viên đã làm trong các học kỳ trước.
We are very excited to actually further support the class and also graduate students from 151 to that class. That's basically the biggest source of students in that class.
Chúng tôi rất hào hứng được hỗ trợ thêm cho lớp đó và cả các sinh viên sau đại học từ 151 sang lớp đó. Đó về cơ bản là nguồn sinh viên lớn nhất của lớp đó.
The majority of them actually have done 151 and get excited about hardware.
Phần lớn họ đã học 151 và trở nên hứng thú với phần cứng.
So with that, since we're talking about sequential logic, so last lecture we talked about timing analysis, thinking about different fast and slow paths and how we can actually make sure that we can actually meet the timing requirements, setup time and hold time requirements for modern circuits.
Vậy nên, vì chúng ta đang nói về logic tuần tự, Bài giảng trước chúng ta đã nói về phân tích thời gian, xét các đường nhanh và đường chậm khác nhau, và làm thế nào để thực sự đảm bảo rằng chúng ta có thể đáp ứng các yêu cầu về thời gian, tức là yêu cầu về thời gian thiết lập và thời gian giữ của các mạch hiện đại.
We didn't actually talk about how we actually build it. We talked about the timing requirements, everything there is a delay cost, but how we actually build that. What are we talking about the transistor?
Nhưng chúng ta chưa nói về việc thực sự xây dựng nó như thế nào. Chúng ta đã nói về các yêu cầu thời gian, mọi thứ ở đó đều có chi phí độ trễ, nhưng còn việc thực sự xây dựng nó thì sao. Chúng ta đang nói về transistor thì sao?
How about how we can use transistor to build a combinational logic? All the different gates, we talked about that. How about sequential logic? How we actually use transistors to build sequential logic?
Làm thế nào để dùng transistor xây dựng logic tổ hợp? Các loại cổng khác nhau thì chúng ta đã nói rồi. Còn logic tuần tự thì sao? Làm thế nào để thực sự dùng transistor xây dựng logic tuần tự?
That will be the key discussion that we'll have for today's lecture. So the first part, whenever we talk about storage elements, you will see this a lot.
Đó sẽ là nội dung thảo luận chính của bài giảng hôm nay. Vậy phần đầu tiên: mỗi khi nói về các phần tử lưu trữ, bạn sẽ thấy điều này rất nhiều.
We already hinted early on when we actually have the inverters and we talked about FPGA.
Chúng ta đã gợi ý từ sớm, khi nói về các bộ đảo và về FPGA.
We also showed some of the diagram and you can always see this a pair of inverters in all the different configuration bits, configuration elements.
Chúng ta cũng đã cho xem một số sơ đồ, và bạn luôn thấy một cặp bộ đảo trong tất cả các bit cấu hình khác nhau, các phần tử cấu hình.
Whenever we start talking about sequential elements, whenever we are talking about storage elements, this a pair of inverters, or what people call cross-coupled inverters, it's always very common and that's how we actually, the fundamental building blocks that we use to store data.
Mỗi khi bắt đầu nói về các phần tử tuần tự, mỗi khi nói về các phần tử lưu trữ, thì cặp bộ đảo này, hay còn gọi là các bộ đảo mắc chéo (cross-coupled inverters), luôn rất phổ biến, và đó chính là cách chúng ta, khối cơ bản mà chúng ta dùng để lưu dữ liệu.
So we have two inverters which create this positive feedback that we can actually store elements here.
Vậy ta có hai bộ đảo tạo ra hồi tiếp dương này để có thể lưu phần tử ở đây.
Let's say we have zero here, it will be a one, one got feedback to the input to the next inverter and then we get another, we get the same zero, right?
Giả sử ở đây ta có số không, đầu ra sẽ là một, số một được hồi tiếp về đầu vào của bộ đảo tiếp theo và rồi ta lại nhận được số không như cũ, đúng không?
So this is a very nice feedback element that we can actually get to reach, we can reach a stable state and then we can actually store this element.
Đây là một phần tử hồi tiếp rất hay mà ta có thể đạt tới, ta có thể đạt đến trạng thái ổn định và nhờ đó lưu được phần tử này.
This is a key building block for any of the sequential elements. You will see this a lot whenever we talk about sequential elements, right?
Đây là khối cơ bản của mọi phần tử tuần tự. Bạn sẽ thấy nó rất nhiều khi nói về các phần tử tuần tự, đúng không?
The fundamental cell, the fundamental logic that we use to store the data is basically a pair of inverters.
Ô cơ bản, logic cơ bản mà ta dùng để lưu dữ liệu về cơ bản là một cặp bộ đảo.
Really using this positive feedback, we get to actually reach this stable stage that we can actually store elements, right? So inverter is a pretty cool element we keep bringing back, right?
Thực sự là nhờ dùng hồi tiếp dương này, ta đạt được trạng thái ổn định này để có thể lưu phần tử, đúng không? Vậy bộ đảo là một phần tử khá thú vị mà ta cứ nhắc lại, đúng không?
We use inverters for the majority of the discussion, right? So this is always the first element, very important, and to actually do a store data. So that's a cross-coupled inverter.
Ta dùng bộ đảo trong phần lớn các nội dung thảo luận, đúng không? Vậy đây luôn là phần tử đầu tiên, rất quan trọng, và để thực sự lưu dữ liệu. Đó là bộ đảo mắc chéo.
That's the first element that we'll see a lot. The second element that we'll see a lot when we actually talk about storage elements is really how we actually access the story.
Đó là phần tử đầu tiên mà ta sẽ gặp nhiều. Phần tử thứ hai mà ta sẽ gặp nhiều khi nói về các phần tử lưu trữ chính là cách ta truy cập vào phần lưu trữ.
Like we talked about the inverter, right? Once we have a cross-coupled inverter, right? We can actually store data, right?
Như ta đã nói về bộ đảo, đúng không? Một khi có bộ đảo mắc chéo, đúng không? Ta có thể lưu dữ liệu, đúng không?
There's always a question how we access the data, how we perform read and write, right? How we actually access the components, the element actually stored in the cross-coupled inverter.
Luôn có câu hỏi là làm sao truy cập dữ liệu, cách chúng ta thực hiện đọc và ghi, đúng không? Cách chúng ta truy cập các thành phần, phần tử thực sự được lưu trong cặp inverter nối chéo.
Another common way actually when we talk get to the storage element, not part of the really thinking about how we store the data, that's the first part, the cross-coupled inverter, right?
Một cách phổ biến khác khi nói đến phần tử lưu trữ, không phải là phần nghĩ về cách ta lưu dữ liệu, đó là phần đầu tiên, cặp inverter nối chéo, đúng không?
But how we actually access it, how we perform read and write operations so that we can actually control how we access the data. Another very common component is what people call transmission gate.
Mà là cách ta truy cập nó, cách ta thực hiện thao tác đọc và ghi để ta có thể điều khiển cách truy cập dữ liệu. Một thành phần rất phổ biến khác là cái mà người ta gọi là transmission gate.
It's basically a switch.
Về cơ bản nó là một công tắc.
It's basically a switch, and we use both NMOS transistor and PMOS transistor so that we can pass value from input to output, right?
Về cơ bản nó là một công tắc, và ta dùng cả transistor NMOS lẫn transistor PMOS để có thể truyền giá trị từ đầu vào ra đầu ra, đúng không?
So it's still a pair of NMOS and PMOS transistors.
Vậy nó vẫn là một cặp transistor NMOS và PMOS.
What we want to do is that if the signal, let's say the signal is on, we want to actually pass the value from input to output, right?
Điều ta muốn là nếu tín hiệu, giả sử tín hiệu đang bật, thì ta muốn truyền giá trị từ đầu vào ra đầu ra, đúng không?
So it basically acts like a switch, right? So we have both transistors here. We have both PMOS and NMOS transistor here.
Vậy về cơ bản nó hoạt động như một công tắc, đúng không? Ở đây ta có cả hai transistor. Ở đây ta có cả transistor PMOS và NMOS.
Remember when we talk about PMOS and NMOS, we mentioned NMOS is very good of passing.
Hãy nhớ khi ta nói về PMOS và NMOS, ta đã nhắc rằng NMOS truyền rất tốt.
Exactly. NMOS is very good passing zero, right? Because we can actually get the ground, while PMOS is very good at passing one, right?
Chính xác. NMOS truyền số không rất tốt, đúng không? Vì ta có thể nối được với đất, còn PMOS truyền số một rất tốt, đúng không?
Because we can connect to the VDD directly, right? So similar idea, right? We want NMOS to pass strong zeros and PMOS to pass strong ones, right?
Vì ta có thể nối trực tiếp với VDD, đúng không? Ý tưởng tương tự nhau. Ta muốn NMOS truyền số không mạnh và PMOS truyền số một mạnh, đúng không?
So this is basically a switch using both PMOS and NMOS. The idea is, again, we want to have both strong ones and strong zeros.
Vậy đây về cơ bản là một công tắc dùng cả PMOS và NMOS. Ý tưởng, một lần nữa, là ta muốn có cả số một mạnh và số không mạnh.
So we have this pair of NMOS and PMOS transistor act as a switch that we can pass both zero and one.
Vậy ta có cặp transistor NMOS và PMOS này đóng vai trò công tắc để truyền được cả số không và số một.
We'll see actually how we use that, use this switch to actually access our storage element, right? So that's basically the second part on FPGA.
Ta sẽ xem cách ta dùng nó, dùng công tắc này để truy cập phần tử lưu trữ của mình, đúng không? Vậy đó về cơ bản là phần thứ hai trên FPGA.
We'll see this pattern showing up a lot in our sequential element discussion, basically cross-coupled inverter for storage and transmission gate to pass, to control it so that we have both strong zero and strong one.
Ta sẽ thấy mẫu này xuất hiện nhiều trong phần bàn về phần tử tuần tự, về cơ bản là cặp inverter nối chéo để lưu trữ và transmission gate để truyền, để điều khiển nó sao cho ta có cả số không mạnh và số một mạnh.
So those are the two fundamental building blocks, right? So then how we actually build sequential elements, right? How we actually build like different sequential elements.
Đó là hai khối xây dựng cơ bản, đúng không? Vậy tiếp theo ta xây dựng các phần tử tuần tự như thế nào, đúng không? Ta xây dựng các phần tử tuần tự khác nhau như thế nào.
The first sequential elements we want to discuss first is latches, all right? We already talked about, right? Latches can be either transparent high or transparent low, right?
Phần tử tuần tự đầu tiên ta muốn thảo luận là latch, được chứ? Ta đã nói về nó rồi, đúng không? Latch có thể là transparent high hoặc transparent low, đúng không?
So if we talk about negative latch, it's basically transparent low, right? When clock is zero, we pass the data, otherwise we keep the data. And if a positive latch, it's basically transparent high, right?
Nếu nói về latch âm, về cơ bản nó là transparent low, đúng không? Khi xung nhịp bằng không, ta truyền dữ liệu, còn không thì ta giữ dữ liệu. Còn latch dương thì về cơ bản là transparent high, đúng không?
If the clock is high, we pass the data, otherwise we keep the data, right? So instead, the edge trigger is more level sensitive.
Nếu xung nhịp ở mức cao, ta truyền dữ liệu, còn không thì ta giữ dữ liệu, đúng không? Như vậy, khác với kích theo cạnh, latch nhạy theo mức hơn.
It really depends on whether the clock is low or high, whether we actually pass the data or keep the current data, right? So that's basically what a latch is, right?
Nó phụ thuộc vào việc xung nhịp ở mức thấp hay cao, tức là ta truyền dữ liệu hay giữ dữ liệu hiện tại, đúng không? Vậy đó về cơ bản là latch, đúng không?
We can actually write it as a mux here, right? So based on the value of clock, right? The clock, so here for a negative latch, right?
Thực ra ta có thể viết nó dưới dạng một mux ở đây, đúng không? Tức là dựa trên giá trị của xung clock, đúng không? Clock, ở đây là với latch âm, đúng không?
The clock is zero, the input is passed to Q, right? So it's basically right into the latch, right? So it's transparent low, right? But if the input, the clock is one, right?
Khi clock bằng không, đầu vào được truyền tới Q, đúng không? Tức là về cơ bản nó đi thẳng vào latch, đúng không? Vậy nó là trong suốt khi clock ở mức thấp, đúng không? Nhưng nếu đầu vào, ý tôi là clock bằng một, đúng không?
We have this feedback loop and we get to keep the data, right? So that's why it's transparent low. When clock is low, negative latch, we actually pass the data.
Ta có vòng hồi tiếp này và ta giữ được dữ liệu, đúng không? Đó là lý do nó trong suốt ở mức thấp. Khi clock ở mức thấp, với latch âm, ta truyền dữ liệu qua.
Otherwise, okay, we actually keep the current data, right? We can basically convert this into the two things that we talked about earlier, right? The two components. One is cross-coupled inverters, right?
Nếu không thì, ta giữ nguyên dữ liệu hiện tại, đúng không? Về cơ bản ta có thể chuyển nó thành hai thứ mà ta đã nói ở trước, đúng không? Hai thành phần. Một là các bộ đảo mắc chéo (cross-coupled inverters), đúng không?
We have this, ignore the muxes for now. This is our cross-coupled inverters, right? So this is our cross-coupled inverters, right? We also have this cross-coupled inverters here, right?
Ta có cái này, tạm thời bỏ qua các mux. Đây là các bộ đảo mắc chéo của ta, đúng không? Vậy đây là các bộ đảo mắc chéo của ta, đúng không? Ta cũng có các bộ đảo mắc chéo này ở đây, đúng không?
To actually save the data, right? We want to have this cross-coupled inverter to actually save the storage, to save the data, right? But we also like to read and write into the data, right?
Để lưu dữ liệu, đúng không? Ta muốn có các bộ đảo mắc chéo này để lưu trữ để lưu dữ liệu, đúng không? Nhưng ta cũng muốn đọc và ghi dữ liệu, đúng không?
We like to control, right? How we actually pass the data. For example, when clock is zero, we actually pass the data, right? So then we actually have our access part.
Ta muốn kiểm soát, đúng không? Cách ta truyền dữ liệu qua. Ví dụ, khi clock bằng không thì ta truyền dữ liệu qua, đúng không? Vậy ta có phần truy cập.
We have this transmission gate controlled by clock. There's both inputs, both PMOS and NMOS here, so that we can actually write into our storage element, right?
Ta có cổng truyền (transmission gate) này được điều khiển bởi clock. Có cả hai đầu vào, cả PMOS và NMOS ở đây, để ta có thể ghi vào phần tử lưu trữ của mình, đúng không?
We add this, we add an inverter here for the polarity, right? Because if we get the Q here, it's actually inverted, Right?
Ta thêm một bộ đảo ở đây để đảm bảo cực tính, đúng không? Vì nếu lấy Q ở đây thì nó thực ra bị đảo, đúng không?
So for the polarity, we also add an inverter here in the input part, right? So in this case, let's see.
Nên để đúng cực tính, ta cũng thêm một bộ đảo ở phần đầu vào, đúng không? Vậy trong trường hợp này, để xem nào.
In this case, when we actually, oh, this is actually a positive latch, right? So when the clock is one, right?
Trong trường hợp này, khi ta, ồ, đây thực ra là latch dương, đúng không? Vậy khi clock bằng một, đúng không?
So the data is actually passed through our transmission gate and gets converted to the output, right?
Thì dữ liệu được truyền qua cổng truyền của ta và được chuyển tới đầu ra, đúng không?
So this is actually a positive latch here, right? Let's see, if the clock is one, right?
Vậy đây thực ra là một latch dương, đúng không? Xem nào, nếu clock bằng một, đúng không?
So we pass the data from the input to the output Q, right? The switches are on, right?
Thì ta truyền dữ liệu từ đầu vào tới đầu ra Q, đúng không? Các công tắc đang bật, đúng không?
So things are connected, and then we write into this, so that we pass the data from B to Q, from input to output, right? Does this part make sense?
Nên mọi thứ được nối với nhau, rồi ta ghi vào đây, để ta truyền dữ liệu từ B tới Q, từ đầu vào tới đầu ra, đúng không? Phần này có dễ hiểu không?
We actually get the data passed when clock is one, we pass the data from input to output.
Dữ liệu được truyền qua khi clock bằng một, ta truyền dữ liệu từ đầu vào tới đầu ra.
Right, so if the clock is one, right? So if clock is one, so this is the inverted clock, right?
Đúng rồi, vậy nếu clock bằng một, đúng không? Vậy nếu clock bằng một, thì đây là clock đảo, đúng không?
So here clock is zero, and this is inverted clock, so here if clock is one, this is also zero. The top transmission gate, is that on or off?
Vậy ở đây clock bằng 0, và đây là clock đảo, nên ở đây nếu clock bằng 1 thì cái này cũng bằng 0. Cổng truyền ở trên, nó đang bật hay tắt?
So let's say this is the transmission gate one, this is transmission gate two, right? So you're talking about T1 or T2? T2, okay. The bottom, okay.
Giả sử đây là cổng truyền một, đây là cổng truyền hai, đúng không? Bạn đang hỏi T1 hay T2? T2, được rồi. Cái ở dưới, được.
So the bottom is controlled, the PMOS is controlled by clock, the NMOS is controlled by clock bar. Oh yeah, there is a bar here, I guess I overwrote it, there's a bar here, right?
Vậy cái ở dưới được điều khiển, PMOS được điều khiển bởi clock, còn NMOS được điều khiển bởi clock bar. À đúng rồi, ở đây có một dấu gạch trên, chắc tôi đã viết đè lên, ở đây có dấu gạch, đúng không?
So when actually clock is one, T1 is on, right? So that we can get into that, but T2 is off, right? So T2 is off, so this cross-coupled, this feedback loop doesn't exist, right?
Vậy khi clock bằng 1, T1 bật, đúng không? Để dữ liệu đi vào được, nhưng T2 tắt, đúng không? Vậy T2 tắt, nên vòng phản hồi mắc chéo này không tồn tại, đúng không?
So when clock is one, right? T1, let's say T1, T2, right? So T1 is on, T2 is off, right?
Vậy khi clock bằng 1, đúng không? T1, giả sử là T1, T2, đúng không? Vậy T1 bật, T2 tắt, đúng không?
So that feedback, we break that feedback loop, and then we can actually pass the value from input to output, right? And then when clock is low, it's zero. Is there a question?
Như vậy vòng phản hồi đó bị ngắt, và khi đó ta có thể truyền giá trị từ đầu vào ra đầu ra, đúng không? Và khi clock ở mức thấp, tức là bằng 0. Có câu hỏi không?
Where is the clock on the PMOS? Wouldn't the, oh, clock is, clock is one here, right?
Clock nối vào PMOS ở đâu? Chẳng phải là, ồ, clock là clock bằng 1 ở đây, đúng không?
For the PMOS, it's a PMOS on the top.
Với PMOS, ở trên là một PMOS.
Yeah, so clock bar is in the middle, but the both, this and this is a clock, but the bottom is controlling an NMOS, the top is controlling a PMOS.
Đúng, clock bar ở giữa, còn cả cái này và cái này là clock, nhưng cái ở dưới điều khiển một NMOS, cái ở trên điều khiển một PMOS.
Yeah, oh yeah, so that's why T2 is off both ways, right? Okay, so that's how we actually, basically the transparent phase, right?
Đúng rồi, vì vậy T2 tắt trong cả hai trường hợp, đúng không? Được rồi, vậy về cơ bản đó là pha trong suốt (transparent phase), đúng không?
How we get input to output, right? And then the feedback phase is basically when clock is flipped. Any other questions on the transparent phase before we get to the feedback phase?
Cách ta đưa đầu vào ra đầu ra, đúng không? Còn pha phản hồi về cơ bản là khi clock đảo trạng thái. Có câu hỏi nào khác về pha trong suốt trước khi sang pha phản hồi không?
Carol?
Carol?
You are not using the cross-coupled inverter, we just have a, oh, you were not using cross-coupled inverters.
Bạn không dùng bộ đảo mắc chéo, ta chỉ có một, à, bạn không dùng các bộ đảo mắc chéo.
Oh, you just have a wire passing the data. But how we store the data, how it keeps the data there?
À, bạn chỉ có một sợi dây truyền dữ liệu. Nhưng làm sao lưu được dữ liệu, làm sao giữ được dữ liệu ở đó?
So you would say this is the inputs, this is the outputs, this is our D, this is our Q, we just have a wire here, right?
Vậy bạn nói đây là đầu vào, đây là đầu ra, đây là D, đây là Q, ta chỉ có một sợi dây ở đây, đúng không?
So then it's not even, it's not even level triggered, it's not edge triggered, whenever input change, output change, right? So storage element is still transparent under a certain condition.
Thế thì nó thậm chí không được kích theo mức, cũng không kích theo cạnh, hễ đầu vào đổi thì đầu ra đổi, đúng không? Còn phần tử lưu trữ thì vẫn trong suốt trong một điều kiện nhất định.
For latch, it's level triggered, it's either transparent high or low, but there is an opaque phase, right? So after the clock doesn't meet the condition, we stay the value.
Với latch, nó được kích theo mức, hoặc trong suốt khi cao hoặc khi thấp, nhưng có một pha đục (opaque), đúng không? Vậy khi clock không thỏa điều kiện, ta giữ nguyên giá trị.
For a flip-flop, it's edge triggered, so after the triggering phase, it acts like a wire, so we do want to pass the data.
Với flip-flop, nó được kích theo cạnh, nên sau pha kích, nó hoạt động như một sợi dây, vì ta muốn truyền dữ liệu đi.
But there is an opaque phase, we don't want to pass the data, we want to store the data. The cross-coupled inverter is used to store the data.
Nhưng có một pha đục, ta không muốn truyền dữ liệu, mà muốn lưu dữ liệu. Bộ đảo mắc chéo được dùng để lưu dữ liệu.
Both the latency and also really the feedback loop, you get this polarity, nice feedback going on here, right? So it's basically have this feedback loop to enforce this data, stay there.
Cả độ trễ và cả vòng phản hồi nữa, ở đây bạn có một phản hồi đúng cực tính, rất tốt, đúng không? Về cơ bản, ta có vòng hồi tiếp này để giữ cho dữ liệu ở yên đó.
All right, so with this cross-coupled inverter, right, so it's T1, T2, and they are actually enforcing each other, right?
Được rồi, với cặp bộ đảo mắc chéo này, gồm T1, T2, chúng thực ra củng cố lẫn nhau, đúng không?
So this is basically a storage element that we use to actually keep the data there. We wanted to actually have this positive feedback state so that they can stabilize, right?
Vậy đây về cơ bản là một phần tử lưu trữ mà ta dùng để giữ dữ liệu lại đó. Ta muốn có trạng thái hồi tiếp dương này để chúng có thể ổn định, đúng không?
So that's why we use this to store the data. If we just use a wire, it's transparent, it's always transparent. It's not even level-sensitive or edge-sensitive, just a wire.
Đó là lý do ta dùng nó để lưu dữ liệu. Nếu chỉ dùng một sợi dây thì nó trong suốt, lúc nào cũng trong suốt. Nó thậm chí không nhạy theo mức hay nhạy theo cạnh, chỉ là một sợi dây.
It's too transparent, right? So we talk about the transparent case, right? So we just pass the value.
Nó quá trong suốt, đúng không? Vậy ta nói về trường hợp trong suốt, đúng không? Khi đó ta chỉ truyền giá trị qua.
And then there is also, we talk about the opaque phase, where we like to keep the value, right?
Và ta cũng nói về pha đục, là lúc ta muốn giữ giá trị lại, đúng không?
So this basically, we want to have this cross-coupled inverter so that we can actually keep the value. So this value is actually not sensitive to the input. The input can always change.
Vậy ở đây, ta muốn có cặp bộ đảo mắc chéo này để có thể giữ được giá trị. Giá trị này không nhạy với đầu vào. Đầu vào lúc nào cũng có thể thay đổi.
Input can change to whatever it wants, but now we have this nice feedback loop here so that we can keep the value, so it's actually not transparent. That's what we want to do, right?
Đầu vào muốn đổi thành gì cũng được, nhưng giờ ta có vòng hồi tiếp tốt này để giữ giá trị, nên nó thực ra không trong suốt. Đó là điều ta muốn làm, đúng không?
For the positive latch, if the clock is low, is zero, it's not transparent. We can actually keep the value, right? So if the clock is low, right, clock is zero, right?
Với latch dương, nếu xung clock thấp, tức bằng không, thì nó không trong suốt. Ta có thể giữ giá trị lại, đúng không? Vậy nếu clock thấp, tức clock bằng không, đúng không?
So T1 is off, right? So that's how we actually break the dependency between input and output, right? So now D can change to whatever it wants, right?
Thì T1 tắt, đúng không? Đó là cách ta cắt đứt sự phụ thuộc giữa đầu vào và đầu ra, đúng không? Bây giờ D muốn đổi thành gì cũng được, đúng không?
So we can do operations on D, we can actually have different computation on D, but T2 is on, which creates this nice feedback so that we can actually, the value we read from the output actually can be still, right?
Ta có thể thực hiện các phép toán trên D, có thể có những phép tính khác nhau trên D, nhưng T2 bật, tạo ra vòng hồi tiếp tốt này để ta có thể, giá trị ta đọc từ đầu ra vẫn được giữ nguyên, đúng không?
We can actually read the value we stored no matter how input is actually changing. So we actually break the dependencies between input and output.
Ta có thể đọc giá trị đã lưu bất kể đầu vào thay đổi thế nào. Vậy ta đã cắt đứt sự phụ thuộc giữa đầu vào và đầu ra.
If D can change whatever it wants, but T1 is off, we're not dependent on D, it's not a wire, but we have this cross-coupled inverter, we can actually store the element and we can read the data that we want to store, right?
D có thể đổi thành bất cứ gì, nhưng T1 tắt, ta không phụ thuộc vào D, nó không phải là dây dẫn, mà ta có cặp bộ đảo mắc chéo này, ta có thể lưu phần tử đó và đọc dữ liệu mà ta muốn lưu, đúng không?
So that's basically how we actually store. Like, this is level trigger, you can see already from our discussion, right?
Vậy về cơ bản đó là cách ta lưu trữ. Cái này kích theo mức, bạn có thể thấy qua phần thảo luận của ta rồi, đúng không?
It's really based on whether the clock is low or high, so that's why it's a latch. We'll talk about a flip-flop later, edge trigger.
Nó thực sự dựa vào việc clock ở mức thấp hay cao, nên đó là lý do nó là latch. Lát nữa ta sẽ nói về flip-flop, kích theo cạnh.
You can actually see we can basically build flip-flop out of latches, and latches basically the building blocks. There are two phases, there are transparent phase, right?
Bạn có thể thấy ta có thể xây dựng flip-flop từ các latch, và latch về cơ bản là các khối xây dựng. Có hai pha, có pha trong suốt, đúng không?
Transparent phase, what we discussed earlier, the green path, right? The transparent, we actually pass the data when the level condition actually met, right?
Pha trong suốt, điều ta đã bàn lúc nãy, đường màu xanh lá, đúng không? Ở pha trong suốt, ta cho dữ liệu đi qua khi điều kiện về mức được thỏa mãn, đúng không?
And then there's also the opaque phase where we actually want to read the stored data and we break the dependency between input and output, and we can actually do things on our input, right?
Và sau đó còn có pha đục (opaque) nơi chúng ta thực sự muốn đọc dữ liệu đã lưu và cắt đứt sự phụ thuộc giữa đầu vào và đầu ra, và lúc đó ta có thể làm nhiều việc trên đầu vào, đúng không?
Without worrying that it's actually contaminate our output, right? So that's basically how a latch, a level-sensitive latch actually works, right? Again, two things, cross-coupled inverters and transmission gates. Questions?
Mà không phải lo nó làm nhiễu đầu ra của mình, đúng không? Vậy về cơ bản đó là cách một latch, một latch nhạy theo mức, hoạt động, đúng không? Một lần nữa, có hai thành phần: các bộ đảo mắc chéo và các cổng truyền. Có câu hỏi nào không?
The storage happens not because of the delay, because the value is actually settled too, yeah.
Việc lưu trữ xảy ra không phải do độ trễ, mà vì giá trị cũng đã ổn định rồi, vâng.
The change is instantaneous to these inverters, okay, and how would that affect?
Với các bộ đảo này thì sự thay đổi xảy ra tức thời, được chứ, vậy nó sẽ ảnh hưởng thế nào?
Yeah, okay.
Vâng, được rồi.
So let's say the input is one here, let me use a different color. So input is one, so to the first inverter, right? I1, and then the output is zero, right?
Giả sử đầu vào ở đây là một, để tôi dùng màu khác. Vậy đầu vào là một, đi vào bộ đảo đầu tiên, đúng không? I1, và đầu ra là không, đúng không?
And then this zero is connected to the second inverter, and after it's inverted, it also produces a one, which is the same as the input.
Rồi số không này được nối với bộ đảo thứ hai, và sau khi bị đảo, nó lại cho ra một, giống với đầu vào.
So they're not, it's the same, it's the same, so that's why they stabilize. It's actually, I know, it's actually the same, that's why they still, it's not like they resonate, right?
Nên chúng giống nhau, giống nhau, vì thế mà chúng ổn định. Thật ra, tôi biết, nó thật sự giống nhau, nên chúng vẫn giữ nguyên, không phải là chúng dao động, đúng không?
It's actually the same, so that's why we have this nice feature, then they just, Yeah, yeah, without delays, they're the same. That's why we can use it to store elements.
Nó thật sự giống nhau, nên chúng ta có đặc tính tốt này, rồi chúng cứ thế, vâng, không có độ trễ, chúng giống nhau. Đó là lý do ta dùng nó để làm phần tử lưu trữ.
Right, so latches, again, two parts: cross-coupled inverter and the transmission gate, two phases, transparent and opaque, right? So for now, we're just thinking about the level-sensitive, right?
Vậy, latch, một lần nữa, có hai phần: bộ đảo mắc chéo và cổng truyền, hai pha, pha trong suốt và pha đục, đúng không? Hiện giờ ta chỉ đang nghĩ đến loại nhạy theo mức, đúng không?
By using those components, we can have either the transparent, the green paths, or the opaque, the blue paths to actually store the value, right?
Bằng cách dùng các thành phần đó, ta có thể có hoặc là pha trong suốt, các đường màu xanh lá, hoặc là pha đục, các đường màu xanh dương để lưu giá trị, đúng không?
So that's how we actually store the value into using this, so that's how we actually design a latch. So this is a pretty common way of design.
Vậy đó là cách ta lưu giá trị bằng cái này, và đó là cách ta thiết kế một latch. Đây là một cách thiết kế khá phổ biến.
Another way we also see, also using a cross-coupled inverter, we still see this cross-coupled inverter here, but instead of using, if you remember, I show it here, right?
Một cách khác mà ta cũng gặp, cũng dùng bộ đảo mắc chéo, ta vẫn thấy bộ đảo mắc chéo ở đây, nhưng thay vì dùng, nếu nhớ thì tôi đã chỉ ở đây, đúng không?
You have what we have here, T1, T2, right? We have actually two transmission gates that we can clearly break the dependency between the transparent and also the opaque state, right?
Ở đây ta có T1, T2, đúng không? Ta có hai cổng truyền để có thể cắt đứt rõ ràng sự phụ thuộc giữa trạng thái trong suốt và trạng thái đục, đúng không?
There's another way of doing that, using basically a single transmission gate instead of using two to actually reduce some of the area, is to actually basically using a single, it's basically treated as switch, right?
Còn có một cách khác để làm điều đó, về cơ bản là dùng một cổng truyền duy nhất thay vì hai để giảm bớt diện tích, tức là dùng một cổng, về cơ bản được coi như một công tắc, đúng không?
So we basically use this transmission gate to actually decide whether we want to either pass the data or not, right?
Vậy ta dùng cổng truyền này để quyết định có cho dữ liệu đi qua hay không, đúng không?
So this is, sometime you will see this, just for your information, we will see this, this is still a latch, this is a direct way of building a switch, right?
Thỉnh thoảng bạn sẽ thấy cái này, chỉ để bạn biết, ta sẽ thấy cái này, đây vẫn là một latch, đây là cách trực tiếp để xây dựng một công tắc, đúng không?
But literally using transmission gates of building the switch here, but this doesn't have the T2 here, right? So it does not actually explicitly break the dependency between the cross-coupled inverter, right?
Nhưng nghĩa đen là dùng các cổng truyền để xây dựng công tắc ở đây, nhưng ở đây không có T2, đúng không? Vì vậy nó không thực sự phá vỡ một cách tường minh sự phụ thuộc giữa các bộ đảo mắc chéo, đúng không?
So it's actually always have this cross-coupled inverters, but try to actually write into the storage element.
Nên thực ra lúc nào cũng có các bộ đảo mắc chéo này, nhưng vẫn phải cố ghi vào phần tử lưu trữ.
So for this, instead, so because we cannot break this dependencies, but when we actually still want to write the data, We actually need to actually size the data correctly so that we have a stronger drive, so we can overwrite the data, right?
Vì thế, do không thể phá vỡ các phụ thuộc này, mà ta vẫn muốn ghi dữ liệu, ta cần chọn kích thước transistor cho đúng để có khả năng điều khiển mạnh hơn, nhờ đó ta ghi đè được dữ liệu, đúng không?
I think this is a question you were wondering earlier, right?
Tôi nghĩ đây là câu hỏi mà các bạn đã thắc mắc lúc trước, đúng không?
It's not in a steady state, they're stable, nothing to worry about, but here you want to change the state, we do want to worry, we do want to be careful so that we can overwrite the old data, right?
Khi không ở trạng thái chuyển, chúng ổn định, không có gì phải lo, nhưng ở đây bạn muốn thay đổi trạng thái, thì ta phải để ý, phải cẩn thận để có thể ghi đè dữ liệu cũ, đúng không?
So this is the alternative way to save a pair of transmission gates, but we will see a little bit more when we talk about SRAM, right?
Đây là cách thay thế để tiết kiệm một cặp cổng truyền, nhưng chúng ta sẽ xem kỹ hơn một chút khi nói về SRAM, đúng không?
Sizing is actually a very important part, because we actually want to overwrite the value, right?
Việc chọn kích thước là một phần rất quan trọng, vì ta thực sự muốn ghi đè giá trị, đúng không?
When we actually write it, we want to overwrite, so we actually have a stronger drive on the writing path instead of the feedback path.
Khi ghi, ta muốn ghi đè, nên ta cần có khả năng điều khiển mạnh hơn ở đường ghi thay vì đường hồi tiếp.
We'll see a little bit more, but you will see that, don't get surprised, that's also a latch.
Chúng ta sẽ xem thêm một chút, nhưng bạn sẽ thấy rằng, đừng ngạc nhiên, đó cũng là một latch.
This is, well, so in this clock is zero, it is on, so yeah, this is a negative latch, so we have a bar here, yeah.
Đây là, à, khi xung clock bằng 0 thì nó bật, vậy đây là latch âm, nên ta có dấu gạch trên ở đây.
Any other questions? Okay, so we talked about latches, right?
Còn câu hỏi nào khác không? Được rồi, vậy chúng ta đã nói về latch, đúng không?
And we already mentioned flip-flops actually just used from latches, so how do we actually use flip-flops, use latches to actually build flip-flops?
Và chúng ta cũng đã nhắc rằng flip-flop được xây dựng từ latch, vậy làm thế nào dùng latch để xây dựng flip-flop?
The key thing is that instead of level trigger, we're actually doing edge trigger, right? So how do we actually use latches to build flip-flops? It's actually not that hard, it's pretty easy.
Điểm mấu chốt là thay vì kích theo mức, ta kích theo cạnh, đúng không? Vậy làm thế nào dùng latch để xây dựng flip-flop? Thực ra không khó, khá dễ.
We can basically easily just use a pair of latches, so we mentioned latch is level trigger, so either transparent high or transparent low, but for flip-flops, we're really looking for the edges or edge case, right, during the transition.
Về cơ bản ta chỉ cần dùng một cặp latch, chúng ta đã nói latch kích theo mức, tức là trong suốt ở mức cao hoặc trong suốt ở mức thấp, nhưng với flip-flop, ta thực sự quan tâm đến các cạnh, đúng không, trong lúc chuyển mức.
So we'll talk about this in a minute, how we actually do that, but you can basically have a pair, you have two latches, basically. One is transparent low, the other is transparent high.
Lát nữa chúng ta sẽ nói cách thực hiện điều đó, nhưng về cơ bản bạn có một cặp, tức là hai latch. Một cái trong suốt ở mức thấp, cái còn lại trong suốt ở mức cao.
So when clock is actually triggered with this, so this is the final output Q, right? So D to Q, right? So this is our flip-flop.
Khi xung clock được kích với cấu trúc này, thì đây là đầu ra cuối cùng Q, đúng không? Vậy từ D đến Q, đúng không? Đây chính là flip-flop của chúng ta.
We'll see in a minute the details, but basically, we can actually start passing data when the clock is low, because this is a negative latch, level when it's low is transparent.
Lát nữa ta sẽ xem chi tiết, nhưng về cơ bản, ta có thể bắt đầu truyền dữ liệu khi clock ở mức thấp, vì đây là latch âm, ở mức thấp thì nó trong suốt.
And then once we get the data, let's say this is a Q intermediate, right?
Và khi đã nhận được dữ liệu, giả sử đây là Q trung gian, đúng không?
And then we actually flip to the high clock, and then we can actually capture the edge to actually trigger the storage element to trigger from input to output.
Sau đó ta chuyển sang clock mức cao, và sau đó chúng ta thực sự có thể bắt được cạnh xung để kích hoạt phần tử lưu trữ truyền dữ liệu từ đầu vào ra đầu ra.
We'll see in a minute how we actually, the internals of this latch pair, how we actually capture these latch transitions.
Lát nữa chúng ta sẽ thấy cấu trúc bên trong của cặp latch này, và cách chúng bắt các chuyển trạng thái của latch.
But basically, we can actually build a flip-flop using two latches, first one and the second one, so that's a latch pair.
Nhưng về cơ bản, ta có thể xây dựng một flip-flop bằng hai latch, cái thứ nhất và cái thứ hai, đó là một cặp latch.
Another way you will see actually in some of the high-performance computing, or like to actually want to build even more efficient latches, is actually what they use is pulse-triggered latches.
Một cách khác mà bạn sẽ thấy trong một số hệ thống tính toán hiệu năng cao, hoặc khi muốn xây dựng các latch còn hiệu quả hơn nữa, là họ dùng các latch kích hoạt bằng xung (pulse-triggered latch).
They basically say latch is level-sensitive, right? What if we have just a very short period of pulses here, right? You have a very short period of pulses, right?
Họ nói rằng latch nhạy theo mức, đúng không? Vậy nếu ta chỉ có một xung rất hẹp ở đây thì sao? Bạn có một xung có độ rộng rất ngắn, đúng không?
So then, it's only transparent using that during that short, very short period, and then you zoom out, and always that pulse is actually short enough, right? It feels like an edge trigger also, right?
Khi đó nó chỉ trong suốt trong khoảng thời gian rất ngắn đó, rồi nếu bạn thu nhỏ lại, và xung đó luôn đủ ngắn, đúng không? Thì nó cũng giống như kích cạnh vậy, đúng không?
Just like latch the data directly. This, that one is actually a lot, is less common. It's like we actually will actually push for high-performance computing.
Giống như chốt dữ liệu trực tiếp. Cách này ít phổ biến hơn nhiều. Chúng ta sẽ dùng nó khi hướng tới tính toán hiệu năng cao.
We actually do that, but there is also a lot more. It's a lot more harder and also need to actually meet different timing requirements.
Chúng ta có làm vậy, nhưng nó còn nhiều thứ phức tạp hơn. Nó khó hơn nhiều và cũng cần đáp ứng các yêu cầu về thời gian khác nhau.
So the first one, we're mostly focusing on the first one. We have actually a pair of latches and how we actually propagate data from input to output.
Vì vậy ở đây chúng ta chủ yếu tập trung vào cách đầu tiên. Chúng ta có một cặp latch và cách chúng truyền dữ liệu từ đầu vào ra đầu ra.
Okay, so we talked about latch pair, right? Question?
Được rồi, vậy là ta đã nói về cặp latch. Có câu hỏi không?
We need an edge. We need an edge. Well, we need one edge. One positive, yeah, yeah, for a flip-flop, it's a, it's one edge.
Cần một cạnh xung. Cần một cạnh. À, ta cần một cạnh. Một cạnh lên, vâng, với flip-flop thì chỉ là một cạnh.
We need two levels. We have two latches. We need two levels. Well, we are using latches to build flip-flops.
Ta cần hai mức. Ta có hai latch. Ta cần hai mức. Chúng ta dùng các latch để xây dựng flip-flop.
The flip-flop eventually is edge-triggered, so we, each latch is sensitive to one level of the clock. So we have two levels. With those two levels, we actually have this edge, right?
Flip-flop cuối cùng là kích cạnh, nên mỗi latch nhạy với một mức của xung clock. Vậy ta có hai mức. Với hai mức đó, ta có được cạnh xung này.
So that's why flip-flop is actually edge-triggered. So we'll see.
Đó là lý do flip-flop được kích cạnh. Ta sẽ thấy rõ hơn.
Right, yeah, so there's an active latch here and a positive latch here. Yeah, this is a bubble of input to the clock, while when we actually describe flip-flop, we have a triangle.
Vâng, ở đây có một latch tích cực và một latch dương. Vâng, đây là một vòng tròn đảo ở ngõ vào clock, còn khi mô tả flip-flop thì ta vẽ một tam giác.
So as a triangle, we actually indicate this, this edge transition, right? But we have two levels. Those two levels actually builds and contributes to this edge.
Tam giác này cho biết sự chuyển trạng thái theo cạnh, đúng không? Nhưng ta có hai mức. Hai mức đó cùng tạo nên và đóng góp vào cạnh xung này.
We'll see a little bit more in, in a more detailed zoom-in view of how we actually do that, right? So this is our latch pair. We already hinted, right?
Ta sẽ xem kỹ hơn một chút trong một hình phóng to chi tiết hơn về cách ta thực hiện điều đó. Đây là cặp latch của chúng ta. Ta đã gợi ý từ trước rồi.
So if we have two latches, we have, and then the clock actually comes in to pass the data, right?
Nếu ta có hai latch, ta có và rồi clock đi vào để truyền dữ liệu, đúng không?
I find it, it's slightly easier before we actually get to the transistor view, just see the MUX view that we saw earlier, just to see how this works, right?
Tôi thấy sẽ dễ hơn một chút nếu trước khi chuyển sang cách nhìn ở mức transistor, ta xem lại cách nhìn bằng MUX mà ta đã thấy trước đó để xem nó hoạt động ra sao.
So we talk about, we have two latches. The first latch, one, L2, right? So we have clock controlling that, right?
Vậy ta có hai latch. Latch thứ nhất, một, L2, đúng không? Có clock điều khiển nó, đúng không?
What we want is to have an edge change scenario when clock goes from low to high, we actually pass the data from input to output.
Điều ta muốn là có một tình huống thay đổi theo cạnh khi xung clock chuyển từ thấp lên cao, thì dữ liệu thực sự được truyền từ đầu vào sang đầu ra.
So this is input and this output, and we have an immediate queue, right, in the middle between those two latches, right? So how does this work? Right, so we have a clock coming in.
Đây là đầu vào và đây là đầu ra, và ta có một giá trị trung gian, đúng không, nằm ở giữa hai latch này. Vậy nó hoạt động thế nào? Ta có xung clock đi vào.
As we discussed earlier, The clock, we have two latches. The first one is a negative latch, right? So it is, the data is passed when the clock is zero, right?
Như đã thảo luận trước đó, ta có hai latch. Latch đầu tiên là latch âm, đúng không? Tức là dữ liệu được truyền qua khi clock bằng 0.
The data is passed when the clock is zero, and the second one is a positive latch. The data is actually passed when the clock is one, where the clock is high, right?
Dữ liệu được truyền qua khi clock bằng 0, còn latch thứ hai là latch dương. Dữ liệu thực sự được truyền qua khi clock bằng 1, tức là khi clock ở mức cao.
So when the first, when the clock is low, right? We think about how this, how we actually build up this edge triggered scenario, right? So first, clock is low, right?
Vậy khi clock ở mức thấp thì sao? Ta hãy nghĩ xem làm thế nào ta xây dựng được cơ chế kích hoạt theo sườn này. Đầu tiên, clock ở mức thấp.
We are somewhere here, right? We are passing through the first latch, L1, right? Because it is a negative latch, right? When clock is zero, data actually passes through the input, right?
Ta đang ở đâu đó quanh đây. Ta đang truyền qua latch đầu tiên, L1. Vì nó là latch âm. Khi clock bằng 0, dữ liệu thực sự đi qua từ đầu vào.
So you will actually, let's see, let me use a different color. So we are in this space, right? So for this part, data is passed, right? So this is transparent low, right?
Để xem nào, để tôi dùng một màu khác. Vậy ta đang ở vùng này. Ở phần này, dữ liệu được truyền qua. Đây là trong suốt ở mức thấp.
So when clock is zero, low, data is actually passed from Q to intermediate, sorry, from D, the input, to the intermediate Q, right?
Khi clock bằng 0, mức thấp, dữ liệu thực sự được truyền từ Q sang giá trị trung gian, xin lỗi, từ D, đầu vào, sang Q trung gian.
For the L2, because it is a positive latch, it's actually not sensitive to the input, so it is in its own feedback loop, right?
Còn với L2, vì là latch dương nên nó thực sự không nhạy với đầu vào, mà nằm trong vòng hồi tiếp của chính nó.
So next, we have this transition where clock actually transitions to high, right?
Tiếp theo, ta có chuyển tiếp này, khi clock chuyển lên mức cao.
When clock transitions to high, in the first phase, in the L1, in the first latch, right? So that gets into this feedback loop, right? Because it's not transparent now, it's actually opaque, right?
Khi clock chuyển lên cao, trong pha đầu tiên, ở L1, tức là latch đầu tiên, nó đi vào vòng hồi tiếp này. Vì bây giờ nó không còn trong suốt mà là đục (opaque).
But for the second latch, now clock is one, right? The intermediate value that we got earlier gets to pass from Q intermediate to output, right?
Nhưng với latch thứ hai, bây giờ clock bằng 1. Giá trị trung gian mà ta có được trước đó được truyền từ Q trung gian ra đầu ra.
To the final Q, right? So that's how we actually transition. We have our, let me go back to this.
Tới Q cuối cùng. Đó là cách nó chuyển tiếp. Để tôi quay lại phần này.
So we have this space, the clock is low phase, zero phase, and then we have the clock one, right?
Ta có vùng này, pha clock mức thấp, pha 0, và sau đó là clock bằng 1.
So the green part and the, so there are two levels, we still have two levels. Those two levels contribute to this edge scenario, right?
Phần màu xanh lá và, vậy là có hai mức, ta vẫn có hai mức. Hai mức này cùng tạo nên cơ chế theo sườn.
Once the clock is transitioning, when the first clock is low, the first latch is transparent, we latch the data to the intermediate Q, and then we transition from low to high.
Khi clock chuyển tiếp, lúc clock đầu tiên ở mức thấp, latch đầu tiên trong suốt, ta chốt dữ liệu vào Q trung gian, rồi ta chuyển từ thấp lên cao.
We have this edge-trigger scenario. Once we transition from low to high, this first latch shuts down, right? It's opaque, and then the second latch becomes transparent.
Ta có cơ chế kích hoạt theo sườn này. Khi chuyển từ thấp lên cao, latch đầu tiên đóng lại. Nó trở nên đục, còn latch thứ hai trở nên trong suốt.
That's how we actually grab the intermediate data to the final output, right? By having these two latches, we can actually build up this edge-trigger scenario.
Đó là cách ta lấy dữ liệu trung gian đưa ra đầu ra cuối cùng, đúng không? Nhờ có hai latch này, chúng ta có thể xây dựng kịch bản kích hoạt theo cạnh này.
With this edge, our input is actually sampled from D to Q, from the input of the flip-flop to the output, the Q, the final output of the flip-flops.
Với cạnh xung này, đầu vào được lấy mẫu từ D sang Q, từ đầu vào của flip-flop đến đầu ra, tức là Q, đầu ra cuối cùng của flip-flop.
Before we get to the transistor view, any questions?
Trước khi chuyển sang góc nhìn ở mức transistor, các bạn có câu hỏi nào không?
Make sense how we use two latches now to actually build a flip-flop? Okay, great. So now we see the connection.
Các bạn đã hiểu cách dùng hai latch để xây dựng một flip-flop chưa? Được rồi, tốt. Vậy là giờ chúng ta đã thấy mối liên hệ.
Accidentally? In what sense?
Vô tình ư? Ý bạn là theo nghĩa nào?
So generally, it's very unlikely because they are actually combinational logic, right? So they are actually your, whatever the signal in your data has or control it.
Nói chung, điều đó rất khó xảy ra vì chúng là logic tổ hợp, đúng không? Chúng chính là tín hiệu nào đó trong dữ liệu hay điều khiển của bạn.
So here, specifically, we're talking about clock behavior, where the data actually latched or clocked during the clock edge, right? So that's why it's actually, that's why it's actually state, right?
Ở đây, cụ thể là chúng ta đang nói về hành vi của xung clock, khi dữ liệu được chốt hay được lấy theo clock tại cạnh xung clock, đúng không? Cho nên đó mới là trạng thái, đúng không?
It actually stays during the clock transition.
Nó được giữ nguyên trong lúc clock chuyển trạng thái.
But generally, you can use MUX, right, in your design, but they are fully, they're really just a data, yeah, so combinational logic, they're just, they're part of the data path.
Nhưng nói chung, bạn có thể dùng MUX trong thiết kế của mình, nhưng chúng thực chất chỉ là dữ liệu thôi, vâng, tức là logic tổ hợp, chúng chỉ là một phần của đường dữ liệu.
They are not actually sensitive to the clock. So here, we are actually registered data as a clock in this particular case, clock edge, right?
Chúng không thực sự nhạy với clock. Còn ở đây, chúng ta đăng ký dữ liệu theo clock trong trường hợp cụ thể này, tức là cạnh clock, đúng không?
Good question. Okay, so now we have seen that, we have seen how that works. It will make it a lot easier when we actually transition to our transistor view.
Câu hỏi hay. Được rồi, vậy là chúng ta đã thấy cách nó hoạt động. Điều này sẽ giúp mọi thứ dễ hơn nhiều khi chúng ta chuyển sang góc nhìn ở mức transistor.
You may see different versions of this in different, like textbooks, different ways, like they basically look like this, but they have different ways of positioning this transmission gate.
Các bạn có thể thấy những phiên bản khác nhau của mạch này ở các sách giáo khoa, theo nhiều cách khác nhau, về cơ bản trông như thế này, nhưng cách bố trí cổng truyền dẫn thì khác nhau.
It looks, Or sharing some of the inverters makes it a little bit harder to view, but generally, this is basically how we use a latch pair, a pair of latches, to build flip-flops.
Trông nó, hoặc việc dùng chung một số bộ đảo sẽ làm khó quan sát hơn một chút, nhưng nói chung, về cơ bản đây là cách chúng ta dùng một cặp latch để xây dựng flip-flop.
So we can still see the general patterns here, even though it's a little bit overwhelming, but we still see the general pattern here. Well, first, we have our D here.
Vậy nên chúng ta vẫn thấy được các mẫu chung ở đây, dù có hơi rối mắt một chút, nhưng chúng ta vẫn thấy mẫu chung ở đây. Trước hết, chúng ta có D ở đây.
We still have our intermediate Q between the first and the second latch. We have our final Q, right? Everything stays the same, right?
Chúng ta vẫn có Q trung gian giữa latch thứ nhất và latch thứ hai. Chúng ta có Q cuối cùng, đúng không? Mọi thứ vẫn giữ nguyên, đúng không?
We still have our two stages, L1, the first latch, and L2, right, the second latch, right?
Chúng ta vẫn có hai tầng, L1, latch thứ nhất, và L2, latch thứ hai, đúng không?
Inside each latch is basically the same one we have seen before, two things: cross-coupled inverter to activate the safe element, transmission gate to turn access on and off, right?
Bên trong mỗi latch về cơ bản vẫn giống cái chúng ta đã thấy trước đây, gồm hai phần: bộ đảo mắc chéo để giữ phần tử lưu trữ, cổng truyền dẫn để đóng mở đường truy cập, đúng không?
So that stays the same.
Phần đó vẫn giữ nguyên.
We do need to generate, one thing you see here, we do generate an inverted clock, right, because we need a transparent low clock for the first stage, for the first latch, and another clock for the second latch, right?
Chúng ta cần tạo ra, một điều bạn thấy ở đây, là chúng ta tạo ra một clock đảo, đúng không, vì chúng ta cần một clock trong suốt ở mức thấp cho tầng đầu, cho latch thứ nhất, và một clock khác cho latch thứ hai, đúng không?
So we have the clock signal coming in. We have this inverter to generate inverted clocks that control the different transmission gates across the two different latches, right?
Vậy là tín hiệu clock đi vào. Chúng ta có bộ đảo này để tạo ra các clock đảo để điều khiển các transmission gate khác nhau trên hai latch khác nhau, đúng không?
So that's basically how we actually build a flip-flop, using the latches and eventually using cross-coupled inverters and transmission, cross-coupled inverter to store the elements, transmission gate to access the value, and also the inverted clock, right?
Về cơ bản, đó là cách chúng ta xây dựng một flip-flop, bằng các latch và cuối cùng là dùng các bộ đảo mắc chéo và transmission gate, bộ đảo mắc chéo để lưu trữ các phần tử, transmission gate để truy cập giá trị, và cả xung nhịp đảo nữa, đúng không?
So to actually control the first and the second latch separately. Questions? Thoughts?
Để điều khiển latch thứ nhất và latch thứ hai một cách riêng biệt. Có câu hỏi hay ý kiến gì không?
Let's see how, or basically this, how we actually can use latches to build flip-flops.
Hãy xem chúng ta có thể dùng latch để xây dựng flip-flop như thế nào.
Oh, how would you do a neg edge clock, neg edge, how would the, exactly, exactly, we just switch the clocks, the key thing there, but we just switch the, basically the control signal to control the transmission gate, right?
À, làm sao để tạo flip-flop kích theo sườn xuống, sườn xuống, đúng vậy, chính xác, chỉ cần hoán đổi xung nhịp, điểm mấu chốt ở đó, nghĩa là chúng ta chỉ hoán đổi tín hiệu điều khiển các transmission gate, đúng không?
So, like the follow-up question, but what if you want to trigger on any, like, outside edge, is that not possible? So, we will, We're going to go over this.
Vậy, câu hỏi tiếp theo, nhưng nếu muốn kích theo bất kỳ sườn nào thì sao, điều đó không thể à? Chúng ta sẽ nói về điều này.
You trigger by any edges.
Bạn kích bởi bất kỳ sườn nào.
You want the signal to trigger by any edges. So, you want to, whenever you see a pass edge transition, you want to pass the value.
Bạn muốn tín hiệu được kích bởi bất kỳ sườn nào. Tức là, bất cứ khi nào thấy một sườn lên, bạn muốn truyền giá trị đi.
Whenever you see a neg edge, I'm just trying to think whether it's actually the same, just using the latches. What kind of scenario is that?
Bất cứ khi nào thấy một sườn xuống, tôi đang nghĩ xem liệu nó có giống nhau không, khi chỉ dùng các latch. Đó là tình huống kiểu gì?
So, you basically want to transition whenever the clock, both clock high, clock low. Basically, you want to transition, you basically just want to use a latch directly, right?
Vậy là về cơ bản bạn muốn chuyển trạng thái bất cứ khi nào xung nhịp ở mức cao, cả mức thấp. Về cơ bản, bạn muốn chuyển trạng thái, thì bạn chỉ cần dùng trực tiếp một latch, đúng không?
Isn't that basically the case, right? It's basically, you just either, like, transparent high or low, right? So, it's basically, you just have two levels there.
Chẳng phải đúng là như vậy sao? Về cơ bản, bạn chỉ có trong suốt ở mức cao hoặc mức thấp, đúng không? Tức là chỉ có hai mức ở đó.
You're not really looking for edges, you're really looking for levels in that sense, right? So, here is really, you're looking for edges, right? In that case, you're just using latches, basically.
Bạn không thực sự tìm các sườn, mà thực sự tìm các mức, theo nghĩa đó, đúng không? Còn ở đây, bạn thực sự tìm các sườn, đúng không? Trong trường hợp đó, về cơ bản bạn chỉ dùng các latch.
So, IBM actually used to, IBM actually has pioneered a lot of, like, for most, the majority of today's design, we're using flip-flop-based design, edge triggered.
IBM trước đây đã, IBM thực ra đã tiên phong rất nhiều về, còn phần lớn các thiết kế ngày nay, chúng ta dùng thiết kế dựa trên flip-flop, kích theo sườn.
So, IBM has done actually a lot of latch-based design, where they basically generate high, like, basically, they are using latches to actually generate their circuit, where they actually have the controls for the high phase and the low phase.
IBM thực ra đã làm rất nhiều thiết kế dựa trên latch, trong đó họ tạo ra mức cao, tức là họ dùng các latch để tạo ra mạch của mình, với các điều khiển cho pha cao và pha thấp.
So, they can actually do some of the hyper, instead of actually waiting for an entire clock cycle, you actually have the half of the clock cycle you can actually play with, right?
Nhờ vậy họ có thể làm một số điều rất tối ưu, thay vì phải chờ cả một chu kỳ xung nhịp, bạn có nửa chu kỳ xung nhịp để linh hoạt sử dụng, đúng không?
You can potentially get some higher performance, faster design using latch-based timing. So, you actually, instead of doing flip-flop-based timing, you can also do latch-based timing.
Có thể bạn sẽ đạt hiệu năng cao hơn, thiết kế nhanh hơn khi dùng định thời dựa trên latch. Tức là, thay vì dùng định thời dựa trên flip-flop, bạn cũng có thể dùng định thời dựa trên latch.
Yeah, it's basically latch, we just use latches, right? You're basically, whenever the clock transitions, you actually just get the data directly, right?
Vâng, về cơ bản là latch, chúng ta chỉ dùng latch, đúng không? Về cơ bản, mỗi khi xung clock chuyển trạng thái, bạn lấy dữ liệu trực tiếp luôn, đúng không?
Any other questions?
Còn câu hỏi nào khác không?
Oh, yeah, that's a good question. What's the setup and hold time for this? What's the setup? Let's look at the setup time. What's the setup?
À, vâng, câu hỏi hay đấy. Thời gian setup và hold của mạch này là bao nhiêu? Setup là bao nhiêu? Hãy xem thời gian setup. Setup là bao nhiêu?
How long do you need to have arrived before the clock? So, why, in this case, do you need to actually arrive before the clock? You know?
Dữ liệu cần đến trước xung clock bao lâu? Vậy, tại sao trong trường hợp này dữ liệu cần phải đến trước xung clock? Bạn biết không?
Exactly. So the D actually needs to actually go through, basically, we need to propagate the value from Q to D to QM, right?
Chính xác. Vậy D thực sự cần đi qua, về cơ bản, chúng ta cần lan truyền giá trị từ Q đến D rồi đến QM, đúng không?
So the input actually goes through the inverter, goes through the transmission gate, and goes through this inverter, right?
Vậy đầu vào đi qua bộ đảo, đi qua cổng truyền, và đi qua bộ đảo này, đúng không?
And to actually have, so that's basically what needs to be actually stable before we even actually transition the clock, because this actually needs to be there, right? What about hold time?
Và để có được, vậy đó về cơ bản là thứ cần phải ổn định trước khi xung clock chuyển trạng thái, vì giá trị này cần phải có ở đó, đúng không? Còn thời gian hold thì sao?
How long, actually, in this design, do we actually hold the value?
Trong thiết kế này, chúng ta giữ giá trị trong bao lâu?
So, QM to Q, right? So, after the clock has arrived, so here, hold time is after the clock has arrived, right?
Vậy, từ QM đến Q, đúng không? Vậy, sau khi xung clock đã đến, ở đây, thời gian hold là sau khi xung clock đã đến, đúng không?
How long does D actually need to be stable after the clock has arrived? Assuming perfect clock, we just have sharp edges, those two clocks are never overlapping.
D cần ổn định bao lâu sau khi xung clock đã đến? Giả sử clock hoàn hảo, chỉ có các sườn xung dốc đứng, hai xung clock đó không bao giờ chồng lấn nhau.
Well, wait, so for hold time, what's the, hold time describes the relationship between who and whom?
Khoan, vậy với thời gian hold, thời gian hold mô tả mối quan hệ giữa cái nào và cái nào?
So, hold time is between Q and the clock, right?
Vậy, thời gian hold là giữa Q và clock, đúng không?
So, how long, so in this design, assuming perfect clock, non-overlapping, how long does D actually need to stay stable?
Vậy, trong thiết kế này, giả sử clock hoàn hảo, không chồng lấn, D thực sự cần giữ ổn định trong bao lâu?
Nothing, yeah, just sharp, perfect step function between D and the clock.
Không cần gì cả, vâng, chỉ là hàm bước nhảy hoàn hảo giữa D và clock.
Any guesses?
Có ai đoán được không?
Well, so we already propagated to here, right, QM, the intermediate Q, right? Now the clock transitions, it's a sharp clock.
Vậy chúng ta đã lan truyền đến đây rồi, đúng không, QM, tức Q trung gian, đúng không? Bây giờ clock chuyển trạng thái, đó là một clock dốc đứng.
It just, it will just go through, right, get to the second phase, right?
Nó cứ thế đi qua, đúng không, sang pha thứ hai, đúng không?
We don't actually, hold time is zero for this design, everything is perfect, like the data, the value has already propagated all the way here, very sharp transition, we just shut down the first latch, turn on the second latch, and then we just grab the data from QM to Q directly, right?
Thời gian hold của thiết kế này bằng không, mọi thứ đều hoàn hảo, dữ liệu, tức giá trị, đã lan truyền hết đến tận đây rồi, chuyển trạng thái rất dốc, chúng ta tắt latch thứ nhất, bật latch thứ hai, rồi lấy dữ liệu từ QM sang Q trực tiếp, đúng không?
Again, for this design, we're in the perfect scenario where we have non-overlapping clock, we have just perfect edge transition. We don't even need to hold it, right? The data is fully registered.
Một lần nữa, với thiết kế này, chúng ta ở trường hợp hoàn hảo là có clock không chồng lấn, và chuyển sườn xung hoàn hảo. Chúng ta thậm chí không cần giữ nó, đúng không? Dữ liệu đã được ghi hoàn toàn.
It just passed through, right? Makes sense?
Nó vừa đi qua rồi, đúng không? Hiểu chưa?
Right. Well, generally it's not perfect, right? So it is a big if, right? It takes time, and even, and we have this inverted clock, right? It's not, and it takes time to ramp up.
Đúng vậy. Nhưng nhìn chung thì nó không hoàn hảo, đúng không? Nên đó là một giả định rất lớn, đúng không? Nó cần thời gian, và ngay cả khi, chúng ta có xung clock đảo này, đúng không? Nó không như vậy, và nó cần thời gian để tăng lên.
It's not a sharp edge, it takes time to ramp up. There is, there could be some overlapping between the first stage and the second stage.
Nó không phải là một sườn xung sắc nét, nó cần thời gian để tăng lên. Có thể có sự chồng lấn giữa tầng thứ nhất và tầng thứ hai.
The whole, like, in ideal scenario, in this case, it's actually, well, we don't need to hold it, it's just passed through, but we do need to actually consider some of the non-ideal scenario.
Toàn bộ, như trong trường hợp lý tưởng này, thực ra là, chúng ta không cần giữ dữ liệu, nó chỉ đi xuyên qua, nhưng chúng ta thực sự cần xem xét một số trường hợp không lý tưởng.
We will not actually go through that. There are actually different ways of actually solving that.
Chúng ta sẽ không đi sâu vào phần đó. Thực ra có nhiều cách khác nhau để giải quyết vấn đề này.
You can actually see, use this, basically a different RC circuit, you can actually even use logical efforts to solve it.
Bạn có thể dùng một mạch RC khác, thậm chí có thể dùng logical effort để giải quyết.
250.1b will actually cover some of the discussions, just how we actually calculate this setup and the whole time with, under different condition, but we will not get to the detail of this.
250.1b sẽ đề cập một số nội dung thảo luận, về cách chúng ta tính thời gian setup và toàn bộ thời gian, trong các điều kiện khác nhau, nhưng chúng ta sẽ không đi vào chi tiết.
But yeah, no ideal perfect world, we just, they're definitely set up, right? We need to actually propagate through, a lot of things happening here, right?
Nhưng trong thế giới không hoàn hảo, chắc chắn là có setup, đúng không? Chúng ta cần truyền dữ liệu qua, có rất nhiều thứ diễn ra ở đây, đúng không?
So that's why there's stages, but yeah, we let the data go.
Đó là lý do có các tầng, nhưng đúng vậy, chúng ta cho dữ liệu đi qua.
Interesting design, right? Interesting how flip-flops just work, right?
Thiết kế thú vị nhỉ? Thú vị là flip-flop hoạt động như vậy, đúng không?
Okay, so, well, talk about flip-flop, how the latches, right? So now all those transistors seem a little bit overwhelming, but yeah, just a couple of transmission gates, inverters, they all make sense, hopefully.
Được rồi, vậy là chúng ta đã nói về flip-flop, về các latch. Giờ đây tất cả những transistor này có vẻ hơi choáng ngợp, nhưng thực ra chỉ là vài cổng truyền dẫn, bộ đảo, hy vọng là các bạn đều hiểu.
Okay, announcement. Well, announcement used to be my favorite part of the lecture, but it's getting harder to announce this these days, but what's new?
Được rồi, phần thông báo. Trước đây phần thông báo là phần tôi thích nhất của bài giảng, nhưng dạo này thông báo khó hơn, mà có gì mới nhỉ?
I understand there are a lot of things going on, and generally this is actually at least from the years that I have been teaching this class, generally this is basically the most challenging part, holidays coming up, like project, all your deadlines are actually around this time.
Tôi hiểu là có rất nhiều việc đang diễn ra, và nhìn chung đây thực ra là ít nhất từ những năm tôi dạy lớp này, nhìn chung đây là giai đoạn thử thách nhất, kỳ nghỉ sắp đến, như đồ án, tất cả hạn nộp của các bạn đều rơi vào khoảng thời gian này.
It is very challenging, and also there's a lot going on here. If anything, I guess the message I want to communicate to all of you is really: stay positive and stay hopeful.
Rất thử thách, và cũng có rất nhiều việc đang diễn ra. Nếu có điều gì, thì thông điệp tôi muốn gửi đến các bạn là: hãy luôn tích cực và giữ hy vọng.
There are so many things outside our control. It's literally outside my control. I need to take a deep breath whenever I think about this.
Có rất nhiều thứ nằm ngoài tầm kiểm soát của chúng ta. Nó thực sự nằm ngoài tầm kiểm soát của tôi. Tôi phải hít thở sâu mỗi khi nghĩ về điều này.
But I think, especially for digital, for hardware designers, I think every time we, well, we try to find opportunities. Hardware design is a very weird industry.
Nhưng tôi nghĩ, đặc biệt với dân thiết kế số, thiết kế phần cứng, mỗi khi chúng ta ừ, chúng ta cố tìm kiếm cơ hội. Thiết kế phần cứng là một ngành rất kỳ lạ.
Honestly, I don't know how this industry still actually works.
Thật lòng, tôi không biết ngành này vẫn vận hành bằng cách nào.
It's always under the premise of some universal golden law, it's going to end, the world is going to end, and there's nothing we can do, and let's try to do something.
Nó luôn dựa trên tiền đề về một quy luật vàng phổ quát nào đó, rằng nó sẽ kết thúc, thế giới sẽ tận thế, và chúng ta chẳng thể làm gì, nhưng hãy cố làm điều gì đó.
This industry also has this weird philosophy, but it's amazing how this industry has really progressed in the past five or six decades, and really thrived, and making a lot of interesting and important innovation that completely changed and transformed how our society even operates.
Ngành này cũng có một triết lý kỳ lạ, nhưng thật tuyệt vời là ngành này đã tiến bộ trong năm sáu thập kỷ qua, và thực sự phát triển mạnh, tạo ra rất nhiều thứ thú vị và quan trọng, đã thay đổi hoàn toàn và biến đổi cách xã hội của chúng ta vận hành.
I think there's a lot of tremendous opportunity here, so I do want to encourage you to stay positive, stay hopeful, as much as you can, given everything going on.
Tôi nghĩ ở đây có rất nhiều cơ hội to lớn, nên tôi muốn khuyến khích các bạn giữ tinh thần tích cực, luôn hy vọng, hết mức có thể, dù đang có nhiều chuyện xảy ra.
In any way, the project, especially the lab, the project part, is a very unique aspect of your learning experience.
Dù sao đi nữa, đồ án, đặc biệt là phần thực hành của đồ án, là một khía cạnh rất độc đáo trong trải nghiệm học tập của các bạn.
This will be a very, I think, of course, especially if you actually do digital design in your career, do a lot of designs in the future, right, but this will be a very unique time.
Tất nhiên, tôi nghĩ đây sẽ là một khoảng thời gian rất đặc biệt, nhất là nếu các bạn thực sự làm thiết kế số trong sự nghiệp, làm nhiều thiết kế trong tương lai, nhưng đây sẽ là một khoảng thời gian rất độc đáo.
Maybe this will just be very unique three or four weeks, where you really think so deep on such a simple microcontroller, and trying to understand every little component of this microcontroller, how it works, right.
Có thể chỉ là ba hay bốn tuần rất độc đáo, khi các bạn thực sự suy nghĩ sâu về một vi điều khiển đơn giản như vậy, và cố gắng hiểu từng thành phần nhỏ của vi điều khiển này, nó hoạt động ra sao.
It's a very unique experience, and you get to basically design your own thing, right.
Đó là một trải nghiệm rất độc đáo, và về cơ bản các bạn được tự thiết kế sản phẩm của mình.
Once you actually do this for a job, do this even for your startup, there's all the other different factors, right.
Khi các bạn làm việc này cho công việc, hay thậm chí cho startup của mình, sẽ có đủ các yếu tố khác nhau.
This is really just for what you want to do, what you like, and try different things, even fail, right. So that's what this project is really about.
Còn ở đây hoàn toàn là vì điều các bạn muốn làm, điều các bạn thích, và thử những cách khác nhau, thậm chí thất bại. Đó chính là ý nghĩa của đồ án này.
So I do want to, In your capacity, if you can still push things forward, try definitely focus on the project, see different things you can do, and see what the project you will build in the end.
Vì vậy, trong khả năng của mình, nếu các bạn vẫn có thể tiếp tục thúc đẩy công việc, hãy tập trung vào đồ án, thử nhiều hướng khác nhau, và xem cuối cùng các bạn xây dựng được đồ án như thế nào.
It will be fun. We are roughly around checkpoint two and checkpoint three. So checkpoint two technically ends this Friday, or the deadline set up to be this Friday.
Sẽ rất vui. Hiện chúng ta đang ở khoảng checkpoint hai và checkpoint ba. Về mặt kỹ thuật, checkpoint hai kết thúc vào thứ Sáu này, hay hạn nộp được đặt vào thứ Sáu này.
It's a soft deadline at this point. We really want to encourage you to follow the timeline that's recommended to actually finish your project on time. So definitely try that as much as possible.
Hiện tại đây là hạn mềm. Chúng tôi thực sự muốn khuyến khích các bạn đi theo tiến độ được đề xuất để hoàn thành đồ án đúng hạn. Vì vậy hãy cố gắng hết mức có thể.
If you can get to the checkpoint to wrap up early, right, you will also have some space, have some time for other courses, for any other things actually in the semester.
Nếu các bạn có thể hoàn tất checkpoint sớm, thì các bạn cũng sẽ có thêm chút khoảng trống, có thời gian cho các môn khác, cho những việc khác trong học kỳ.
It will be lighter for the last couple weeks, because there will be just more things piling up towards the end of the semester.
Vài tuần cuối sẽ nhẹ nhàng hơn, vì càng về cuối học kỳ sẽ càng dồn thêm nhiều việc.
Discussions: we released, we added a link to the discussions from spring 2022.
Về các buổi thảo luận: chúng tôi đã phát hành, đã thêm liên kết đến các buổi thảo luận từ mùa xuân 2022.
The lecture material and the discussions are consistent, so if you want to review the material that we covered, check out the discussion videos there.
Tài liệu bài giảng và các buổi thảo luận khớp với nhau, nên nếu các bạn muốn ôn lại tài liệu đã học, hãy xem các video thảo luận ở đó.
It's a good way to enforce your learning, and to see, go a little bit deeper, and go a little bit into the depths into some of the materials.
Đó là cách tốt để củng cố việc học, và để đi sâu hơn một chút, tìm hiểu kỹ hơn một số nội dung.
We do extend the homework eight, which is actually very short. It's really just, really just hope you to actually review the material.
Chúng tôi có gia hạn bài tập về nhà tám, vốn thực ra rất ngắn. Mục đích chỉ là mong các bạn ôn lại tài liệu.
It's very short, very easy, but I don't want it to collide with the project deadline, which is this Friday, right? So we extend it to next Monday.
Bài rất ngắn, rất dễ, nhưng tôi không muốn nó trùng với hạn nộp đồ án, là thứ Sáu này. Vì vậy chúng tôi gia hạn đến thứ Hai tuần sau.
You just spend a couple hours on it. I think we'll finish. It's really just review the material, take the longest one. Doing the homework will be very quick. It's a very short homework.
Các bạn chỉ cần dành vài giờ cho nó. Tôi nghĩ là sẽ xong. Thực ra chỉ là ôn lại tài liệu thôi, em cứ lấy bài dài nhất. Làm bài tập về nhà sẽ rất nhanh. Đó là một bộ bài tập rất ngắn.
So we have, after that, we have one more, also a very short homework.
Sau đó chúng ta còn một bộ nữa, cũng là bài tập rất ngắn.
It's basically try to encourage you to actually review the material, but still the focus should be on project, and make progress on project, right?
Về cơ bản là để khuyến khích các em thực sự ôn lại tài liệu, nhưng trọng tâm vẫn phải là dự án, và các em phải tiến triển với dự án, đúng không?
Okay, that's some things on my mind. Anything with the course, any questions or comments?
Được rồi, đó là một vài điều thầy đang nghĩ. Có điều gì về môn học không, có câu hỏi hay ý kiến nào không?
Thank you. Well, thank all of you. I think this is an interesting experience. This is definitely a challenging time, but I think we're going through this.
Cảm ơn em. Cảm ơn tất cả các em. Thầy nghĩ đây là một trải nghiệm thú vị. Chắc chắn đây là giai đoạn nhiều thử thách, nhưng thầy nghĩ chúng ta sẽ vượt qua.
As I mentioned, well, stay positive, stay hopeful, right? I think we'll go through, and this will be a very, very unique experience.
Như thầy đã nói, hãy giữ tinh thần tích cực, giữ hy vọng nhé? Thầy nghĩ chúng ta sẽ vượt qua, và đây sẽ là một trải nghiệm rất, rất độc đáo.
What percentage of people, so Ben is asking, what percentage people typically finish? You mean by the end of the semester or by the end of checkpoint two?
Tỉ lệ người, Ben đang hỏi, thường có bao nhiêu phần trăm số người hoàn thành? Ý em là đến cuối học kỳ hay đến cuối checkpoint hai?
The end of the semester? I mean, it depends.
Cuối học kỳ à? Thì còn tùy.
Every semester is different, especially, I'm actually looking for the stats for this semester, how many students finish the project. Roughly from the previous semester, again, we have a smaller sample size.
Mỗi học kỳ một khác, đặc biệt là thầy đang tìm số liệu thống kê của học kỳ này, xem có bao nhiêu sinh viên hoàn thành dự án. Đại khái từ học kỳ trước, mà như thầy nói, mẫu của chúng ta nhỏ hơn.
I think the biggest one we have so far was like 60, 70 students, and this semester in the lab, we have almost 180, 180 students, right?
Thầy nghĩ lớp lớn nhất từ trước đến nay khoảng 60, 70 sinh viên, còn học kỳ này ở phòng thí nghiệm có gần 180, 180 sinh viên, đúng không?
So it's a different scale, but for the smaller number of students that we taught so far, I think roughly half, a little bit more than half of the students could finish the project, basically everything, all the functionality, everything, and then some students are pretty close, maybe not everything, but have the structure up, but yeah, not everyone can finish the project.
Nên quy mô khác nhau, nhưng với số lượng sinh viên nhỏ hơn mà chúng ta đã dạy đến giờ, thầy nghĩ khoảng một nửa, hơn một nửa số sinh viên hoàn thành được dự án, tức là về cơ bản mọi thứ, tất cả chức năng, mọi thứ, còn một số sinh viên khá gần, có thể chưa đủ mọi thứ, nhưng đã dựng xong cấu trúc, nhưng đúng là không phải ai cũng hoàn thành được dự án.
It's part of the process, but even, so that's why I'm trying to just keep making progress, keep making progress, do things. The majority of the class will finish the project.
Đó là một phần của quá trình, nhưng ngay cả, nên thầy mới cố gắng khuyên các em cứ tiếp tục tiến triển, cứ tiếp tục tiến triển, cứ làm. Phần lớn lớp sẽ hoàn thành dự án.
That's basically what we want you to do, what we encourage all of you to try, and even if you don't finish 100%, we'll actually look into it, what exactly, how much you finish, right?
Đó cơ bản là điều thầy muốn các em làm, điều thầy khuyến khích tất cả các em thử, và ngay cả khi các em không hoàn thành 100%, chúng tôi vẫn sẽ xem xét, cụ thể là các em hoàn thành được bao nhiêu, đúng không?
There are also different variation there, so that's, but roughly 50, 60 of the students will finish, will finish the project by the end of the semester. Again, every semester is different.
Ở đó cũng có nhiều mức khác nhau, nên là, nhưng đại khái 50, 60 phần trăm sinh viên sẽ hoàn thành, sẽ hoàn thành dự án vào cuối học kỳ. Nhắc lại, mỗi học kỳ một khác.
My sample size was pretty small. I'm actually looking for the stats for this semester, but keep working on it.
Mẫu của thầy khá nhỏ. Thầy đang tìm số liệu của học kỳ này, nhưng các em cứ tiếp tục làm.
I mean, it may seem like it's a binary scenario, just whether you'll finish everything or not, but this project is so complex, so many things going on, right?
Ý thầy là, có vẻ như đây là tình huống nhị phân, chỉ là hoàn thành hết hay không, nhưng dự án này rất phức tạp, có rất nhiều thứ diễn ra, đúng không?
Just keep making progress, right? The more things you build, the more things you do, it will actually be a very different experience, and I mentioned earlier, this will be just very unique.
Cứ tiếp tục tiến triển nhé? Các em xây dựng càng nhiều, làm càng nhiều, thì trải nghiệm sẽ càng rất khác, và như thầy đã nói lúc nãy, điều này sẽ rất độc đáo.
You won't do this again after this semester.
Sau học kỳ này các em sẽ không làm lại điều này nữa.
It's just, the next couple of weeks will be a very unique time period for you, for all of us, to actually experiment the project, yeah, but just keep making progress.
Chỉ là, vài tuần tới sẽ là khoảng thời gian rất đặc biệt đối với các bạn, đối với tất cả chúng ta, để thực sự thử nghiệm với đồ án, vâng, nhưng cứ tiếp tục tiến triển nhé.
We'll see what you have. It's not a binary, just whether you'll finish it or not. We'll see your design, which we'll see what you have.
Chúng tôi sẽ xem các bạn có gì. Đây không phải chuyện nhị phân, chỉ là bạn hoàn thành hay không. Chúng tôi sẽ xem thiết kế của các bạn, xem các bạn đã làm được gì.
Everything will be factored into the project, and every part is very unique in the design process.
Mọi thứ đều sẽ được tính vào điểm đồ án, và mỗi phần đều rất đặc biệt trong quá trình thiết kế.
Okay, so that's the announcement part, and we talked about sequential elements, right? We talked about latches, flip-flops.
Được rồi, vậy là xong phần thông báo, và chúng ta đã nói về các phần tử tuần tự, đúng không? Chúng ta đã nói về latch và flip-flop.
Next, we're going to talk about SRAM, right? So, that's already the last piece of our digital flow components, right? So, we have different storage elements for smaller things.
Tiếp theo, chúng ta sẽ nói về SRAM, đúng không? Đây đã là mảnh cuối cùng trong các thành phần của luồng thiết kế số của chúng ta, đúng không? Chúng ta có các phần tử lưu trữ khác nhau cho những thứ nhỏ hơn.
We like to store in registers, but for bigger things, right, we, majority of the time, we actually store it in SRAM. We'll talk about just a quick overview.
Chúng ta thích lưu trong thanh ghi, nhưng với những thứ lớn hơn, thì chúng ta, phần lớn thời gian, thực ra là lưu trong SRAM. Chúng ta sẽ có một cái nhìn tổng quan nhanh.
We'll do the internal, how we actually build an individual cell of the SRAM first, and what are the interesting trade-offs or what are the interesting design considerations in building the individual SRAM.
Trước tiên chúng ta sẽ đi vào bên trong, xem thực sự xây dựng một ô nhớ riêng lẻ của SRAM như thế nào, và những đánh đổi thú vị là gì, hay những cân nhắc thiết kế thú vị là gì khi xây dựng từng ô SRAM.
So, we'll talk about how we address this, addressing different lines, different rows of SRAM after next week. So, SRAM, right? So, we basically want to store the data, right?
Sau đó, chúng ta sẽ nói về cách định địa chỉ, tức là địa chỉ hóa các dòng khác nhau, các hàng khác nhau của SRAM, sau tuần tới. Vậy, SRAM, đúng không? Về cơ bản chúng ta muốn lưu trữ dữ liệu, đúng không?
So, SRAM is random access memory, right? We'll talk about DRAM more likely after Thanksgiving, right? But we basically want to store random access, right? Store the data here, right?
SRAM là bộ nhớ truy cập ngẫu nhiên, đúng không? Chúng ta sẽ nói về DRAM nhiều khả năng là sau lễ Tạ ơn, đúng không? Nhưng về cơ bản chúng ta muốn lưu trữ với truy cập ngẫu nhiên, đúng không? Lưu dữ liệu ở đây, đúng không?
We never want to store the data. Basically, we have a linear array of addresses, right? We have some entries. It's like a linear table, right?
Chúng ta không bao giờ muốn lưu dữ liệu. Về cơ bản, chúng ta có một mảng địa chỉ tuyến tính, đúng không? Chúng ta có một số mục. Nó giống như một bảng tuyến tính, đúng không?
We have our address, and then we map it to our table, right? That's our index. We use the index to figure out which entry, what we want to do, right?
Chúng ta có địa chỉ, rồi ánh xạ nó vào bảng, đúng không? Đó là chỉ số của chúng ta. Chúng ta dùng chỉ số để xác định mục nào, chúng ta muốn làm gì, đúng không?
But in reality, more likely, instead of having this like super time skinny arrays where we're doing actually every row only have one word, one element there, a more likely layout is really think about more like a 2D array, right?
Nhưng trong thực tế, nhiều khả năng hơn, thay vì có những mảng siêu mảnh như thế này, trong đó mỗi hàng thực sự chỉ có một từ, một phần tử, cách bố trí thường gặp hơn là nghĩ nó giống một mảng 2D, đúng không?
A square array, right? We have rows and columns, right? When we actually access a particular piece of data, a particular entry, right?
Một mảng vuông, đúng không? Chúng ta có hàng và cột, đúng không? Khi chúng ta truy cập một dữ liệu cụ thể, một mục cụ thể, đúng không?
We generally actually figure out which row we want to access, and we also figure out which column that we want to access, right? That's how we get to this particular entry.
Nhìn chung chúng ta xác định hàng nào mình muốn truy cập, và cũng xác định cột nào mình muốn truy cập, đúng không? Đó là cách chúng ta đến được mục cụ thể này.
That's how we actually read the data, right? So, it's more like a square two-dimensional array element instead of this tasking line, just a linear addresses, right?
Đó là cách chúng ta thực sự đọc dữ liệu, đúng không? Vậy nên nó giống một mảng hai chiều hình vuông gồm các phần tử, thay vì một đường dài mảnh như thế này, chỉ là các địa chỉ tuyến tính, đúng không?
So, when we talk about memory arrays, right? So, generally two parts. The first part is basically our cell array, right? So, array of two-dimensional, right?
Vậy khi nói về các mảng bộ nhớ, đúng không? Nhìn chung có hai phần. Phần đầu tiên về cơ bản là mảng ô nhớ của chúng ta, đúng không? Tức là một mảng hai chiều, đúng không?
So, where we are actually storing the elements, right? We'll see the different terminology.
Tức là nơi chúng ta thực sự lưu trữ các phần tử, đúng không? Chúng ta sẽ gặp các thuật ngữ khác nhau.
I will dig deeper into the terminology later, but yes, as we mentioned, we need row addresses to figure out which row or which word line we like to access.
Lát nữa tôi sẽ đi sâu hơn vào thuật ngữ, nhưng đúng như đã nói, chúng ta cần địa chỉ hàng để xác định hàng nào, hay word line nào, mà ta muốn truy cập.
We also have column addresses to figure out which column, which bit line we like to control, right?
Chúng ta cũng có địa chỉ cột để xác định cột nào, bit line nào mà ta muốn điều khiển, đúng không?
So, that's how we actually index a particular memory cell in our two-dimensional memory array, right?
Đó chính là cách chúng ta đánh chỉ số một ô nhớ cụ thể trong mảng nhớ hai chiều của mình, đúng không?
So, we have each element is basically a cell in the two-dimensional array, and we have word line and bit line to access it, right?
Vậy mỗi phần tử về cơ bản là một ô trong mảng hai chiều, và ta có word line và bit line để truy cập nó, đúng không?
So, that's how the internal or the core part of the array, But we also need to actually decode the address that we use to figure out which row and which column we want to access.
Đó là phần bên trong, hay phần lõi của mảng. Nhưng chúng ta cũng cần giải mã địa chỉ mà ta dùng để xác định hàng nào và cột nào ta muốn truy cập.
We have the address coming in, and then we basically do a one-hot encoding where we actually show which particular row or which particular column we want to access.
Địa chỉ đi vào, rồi ta thực hiện mã hóa one-hot để chỉ ra hàng cụ thể nào hoặc cột cụ thể nào ta muốn truy cập.
That's how we reach this, how we access the individual cell of the array, right? We'll talk about the decoder part of the peripheral logic next week, next lecture.
Đó là cách ta tiếp cận, truy cập từng ô riêng lẻ của mảng, đúng không? Chúng ta sẽ nói về phần bộ giải mã trong logic ngoại vi vào tuần sau, bài giảng sau.
In today's lecture, we're mostly focusing on the core part, the array part, right? Really, actually more specifically, the cell part, right? How we actually do the storage element. We're talking about flip-flops, right?
Trong bài giảng hôm nay, chúng ta chủ yếu tập trung vào phần lõi, tức là phần mảng, đúng không? Thực ra cụ thể hơn nữa là phần ô nhớ, đúng không? Tức là phần tử lưu trữ được thực hiện thế nào. Ta đang nói đến flip-flop, đúng không?
So, that's how we use it as a flip-flop cell, how we actually store that.
Đó là cách ta dùng nó như một ô flip-flop, cách ta lưu dữ liệu.
We also see actually a lot of similarities in the memory cell or SRAM cell, how we actually store the data.
Chúng ta cũng thấy rất nhiều điểm tương đồng ở ô nhớ hay ô SRAM, trong cách lưu dữ liệu.
So, in today's lecture, we're focusing on the cell part, and next lecture we'll transition to the decoder part. So, for the cell, right, when we actually get to see the memory element, right?
Vậy bài giảng hôm nay tập trung vào phần ô nhớ, và bài sau chúng ta sẽ chuyển sang phần bộ giải mã. Vậy với ô nhớ, khi ta xem phần tử nhớ, đúng không?
So, this is our friend again, right? Our cross-coupled inverter, right? So, we have this nice storage element that we can actually get to store our, keep our data there, right?
Đây lại là người bạn cũ của chúng ta, đúng không? Cặp inverter mắc chéo. Ta có phần tử lưu trữ rất tiện này để giữ dữ liệu của mình ở đó, đúng không?
So, this is our cross-coupled inverter. This is the same principle that we have seen in latches. We have this feedback, positive feedback loop, right?
Đây là cặp inverter mắc chéo của chúng ta. Đây là nguyên lý giống như ta đã thấy ở latch. Ta có vòng hồi tiếp, vòng hồi tiếp dương này, đúng không?
So, that's basically our storage. Everything stays the same. We'll still want to leverage this cross-coupled inverter to actually store, to build our memory cell, right?
Đó chính là phần lưu trữ của ta. Mọi thứ vẫn như cũ. Chúng ta vẫn muốn tận dụng cặp inverter mắc chéo này để lưu trữ, để xây dựng ô nhớ của mình, đúng không?
So, then when we think about memory, we want to actually basically access the memory, right? We have the storage element, but we like to access, right?
Vậy khi nghĩ về bộ nhớ, ta muốn truy cập được vào bộ nhớ, đúng không? Ta có phần tử lưu trữ, nhưng ta muốn truy cập nó, đúng không?
We need to read and write into our cross-coupled inverter, right? So, again, of course, we still have our storage element. We have our cross-coupled inverter, right?
Ta cần đọc và ghi vào cặp inverter mắc chéo, đúng không? Vậy dĩ nhiên ta vẫn có phần tử lưu trữ. Ta có cặp inverter mắc chéo, đúng không?
We've already seen a similar design before. Basically, we want to have our Access transistor. We want to have an access transistor so that we can actually read and write, right, right into the inverter.
Ta đã thấy một thiết kế tương tự trước đây. Về cơ bản, ta muốn có transistor truy cập. Ta muốn có một transistor truy cập để có thể đọc và ghi, đúng không, ghi thẳng vào inverter.
We'll talk about the enable signal and how about the control signal later, right? We want to have access transistor so that we can actually write the transistor, right?
Chúng ta sẽ nói về tín hiệu cho phép và tín hiệu điều khiển sau, đúng không? Ta muốn có transistor truy cập để có thể ghi vào, đúng không?
We already have a brief discussion. We talked about latches, right? To break this, because we don't have the transmission gate here, right? To break this dependencies, right?
Chúng ta đã có một thảo luận ngắn về việc này. Chúng ta đã nói về latch, đúng không? Để phá vỡ điều này, vì ở đây chúng ta không có cổng truyền dẫn, đúng không? Để phá vỡ sự phụ thuộc này, đúng không?
We actually need to size this very carefully so that we can override the data right into the storage element, right? But we'll get to that later. We'll actually talk about how we break this.
Chúng ta thực sự cần chọn kích thước của nó rất cẩn thận để có thể ghi đè dữ liệu vào phần tử lưu trữ, đúng không? Nhưng chúng ta sẽ nói về điều đó sau. Chúng ta sẽ nói về cách phá vỡ điều này.
And with this, this is basically a 5T, when people, like, T basically transistor, right? So, five transistors. Whenever we have an inverter, each inverter is a two transistor, PMOS and NMOS.
Và với cấu trúc này, về cơ bản đây là 5T, khi người ta nói T, về cơ bản là transistor, đúng không? Vậy là năm transistor. Mỗi khi có một bộ đảo, mỗi bộ đảo gồm hai transistor, PMOS và NMOS.
So, two inverters, four transistors, and then we have an access transistor, right? Five transistors. So, people say 5T SRAM style. This is basically five transistors.
Vậy hai bộ đảo là bốn transistor, rồi thêm một transistor truy cập, đúng không? Năm transistor. Nên người ta gọi là SRAM kiểu 5T. Về cơ bản đây là năm transistor.
Of course, this can control it, but we have the same problem, right? With NMOS, of course, we can actually write zero, but again, we are writing a weaker one, right?
Tất nhiên, cái này có thể điều khiển được, nhưng chúng ta vẫn gặp cùng một vấn đề, đúng không? Với NMOS, tất nhiên chúng ta có thể ghi số không, nhưng một lần nữa, ta ghi một yếu hơn, đúng không?
Because the same problem with NMOS. It's strong and delivers strong zero, but it delivers a weaker one, right? Of course, we can actually do what we had before, right?
Vì đó vẫn là vấn đề của NMOS. Nó mạnh và cho số không mạnh, nhưng cho số một yếu hơn, đúng không? Tất nhiên, chúng ta có thể làm như trước đây, đúng không?
The cross-coupled transmission gate. So, we can actually write both zero and one, but there's actually a different way. Instead of this single end, only have one node, right?
Cổng truyền dẫn mắc chéo. Như vậy ta có thể ghi cả số không và số một, nhưng thực ra còn một cách khác. Thay vì chỉ có một đầu, chỉ có một nút, đúng không?
One end of the cross-coupled inverter being accessed, we can actually have two-end solution where we can actually read and write data differentially to actually meet the requirement.
Một đầu của cặp bộ đảo mắc chéo được truy cập, ta có thể dùng giải pháp hai đầu, trong đó ta có thể đọc và ghi dữ liệu theo kiểu vi sai để đáp ứng yêu cầu.
So, that's basically contribute, that basically leads to the state of art SRAM design. So, again, the key thing, the core part, we still have this cross-coupled inverter.
Vì vậy, điều đó góp phần, và dẫn đến thiết kế SRAM hiện đại nhất. Một lần nữa, điểm mấu chốt, phần cốt lõi, vẫn là cặp bộ đảo mắc chéo này.
That part is always here, But we mentioned the problem of just having a single NMOS here. It's like we can write zero, but harder to write a strong one, right?
Phần đó luôn có ở đây, Nhưng chúng ta đã nói đến vấn đề khi chỉ có một NMOS ở đây. Tức là ta ghi được số không, nhưng khó ghi một mạnh, đúng không?
Then basically to think about is why we have to write actually one? Can we actually convert that one to zero? Can we actually write zero instead?
Vậy điều cần nghĩ là: tại sao nhất định phải ghi số một? Liệu ta có thể chuyển số một đó thành số không không? Liệu ta có thể ghi số không thay vào đó không?
Because you think about those two ends, right? They are basically inverted because they are basically two ends of the inverters, right?
Vì hãy nghĩ về hai đầu đó, đúng không? Về cơ bản chúng ngược nhau vì chúng là hai đầu của các bộ đảo, đúng không?
So, you will actually write, and both ends, we can actually write zero very strongly, right? We write maybe zero directly. This part will be zero, and this part will be one, right?
Vậy bạn sẽ ghi, và ở cả hai đầu, ta đều có thể ghi số không rất mạnh, đúng không? Chẳng hạn ta ghi trực tiếp số không. Phần này sẽ là không, còn phần này sẽ là một, đúng không?
You will actually want to invert this value, right? Instead of writing one here, which might lead to actually a weaker one, what if we basically write a zero here?
Bạn sẽ muốn đảo giá trị này, đúng không? Thay vì ghi số một ở đây, có thể dẫn đến một yếu hơn, thì nếu ta ghi số không ở đây thì sao?
Write a zero, we can still write a strong zero, and then leveraging the positive feedback, right? We can basically still producing a one on the other end, right?
Ghi số không, ta vẫn ghi được số không mạnh, rồi tận dụng phản hồi dương, đúng không? Về cơ bản ta vẫn tạo ra được số một ở đầu còn lại, đúng không?
So, this is basically, we only want to write zero, but by writing it on the opposite ends, because we have these inverters here, right? Then we can actually have strong values on both ends.
Vậy nên ở đây, chúng ta chỉ muốn ghi giá trị 0, nhưng bằng cách ghi nó ở hai đầu đối diện nhau, vì ở đây chúng ta có các bộ đảo, đúng không? thì chúng ta thực sự có thể có các giá trị mạnh ở cả hai đầu.
Yeah, and we want to create a weak one, because potentially, we can still invert the inverters, but it's still one. It's still, oh, that's a really super weak one, right?
Vâng, và chúng ta muốn tạo ra một mức 1 yếu, vì có thể các bộ đảo vẫn đảo được, nhưng nó vẫn là 1. Nó vẫn là, ồ, đó là một mức 1 cực kỳ yếu, đúng không?
So, you can basically, that's one, but the concern of weaker ones, basically also time, it's going to be slower. A weaker one, you can basically think about basically like a lower voltage, right?
Vậy nên về cơ bản, đó vẫn là 1, nhưng mối lo ngại về mức 1 yếu hơn cũng liên quan đến thời gian, nó sẽ chậm hơn. Mức 1 yếu hơn, bạn có thể hình dung như một điện áp thấp hơn, đúng không?
It's basically what takes slower for the outputs to transition. So, it's like the super weak is just get the wrong solution, wrong answer, right?
Nó khiến các đầu ra chuyển trạng thái chậm hơn. Còn mức cực yếu thì sẽ cho ra kết quả sai, đáp án sai, đúng không?
That's basically the worst case, but a lot of cases, it's not that weak, it's not flipped, the value is not flipped, but it's just very slow, right? It takes time to settle, right?
Đó là trường hợp xấu nhất, nhưng trong nhiều trường hợp, nó không yếu đến vậy, giá trị không bị lật, mà chỉ là rất chậm, đúng không? Nó cần thời gian để ổn định, đúng không?
So, that's basically the concern of a weaker one, right? And here is basically, what if we actually just write zero by actually also opening up the other end?
Vậy đó là mối lo ngại về mức 1 yếu hơn, đúng không? Và ở đây, điều gì sẽ xảy ra nếu chúng ta ghi 0 đồng thời cũng mở nốt đầu còn lại?
So, that leads to the 6-transistor SRAM cell here.
Điều đó dẫn đến ô nhớ SRAM 6 transistor ở đây.
It's a little bit different, although the transistor may seem a little bit overwhelming, but it's basically still, we have inverter here.
Nó hơi khác một chút, mặc dù số transistor có vẻ hơi choáng ngợp, nhưng về cơ bản vẫn là chúng ta có bộ đảo ở đây.
What we basically do is basically adding those two access transistors on both ends, so that we can actually access the data.
Việc chúng ta làm là thêm hai transistor truy cập ở cả hai đầu, để có thể truy cập dữ liệu.
Some of the terminologies to introduce before we get to actually talk about the internals here, right?
Có một số thuật ngữ cần giới thiệu trước khi nói về cấu trúc bên trong, đúng không?
So, first word line here, as we mentioned earlier, this word line basically select whether we actually want to access that transistor.
Đầu tiên là đường từ (word line), như đã đề cập trước đó, đường từ này chọn xem chúng ta có muốn truy cập transistor đó hay không.
So, we mentioned we have two access transistors, they are basically connected by a word line here, so word line is basically select, okay, this is the row that we want to control, this is the cell that I want to control.
Chúng ta đã nói là có hai transistor truy cập, chúng được nối với nhau bằng một đường từ ở đây, nên đường từ dùng để chọn, được rồi, đây là hàng mà chúng ta muốn điều khiển, đây là ô mà tôi muốn điều khiển.
I can perform either read or write operation, but I want to access, I want the access, I want to access whatever is stored in this cross-couple inverter, right?
Tôi có thể thực hiện thao tác đọc hoặc ghi, nhưng tôi muốn truy cập, tôi muốn có quyền truy cập vào bất cứ thứ gì được lưu trong cặp bộ đảo mắc chéo này, đúng không?
So, I have the word line here, so that's word line.
Vậy tôi có đường từ ở đây, đó là đường từ.
We'll talk about the bit line later and how it actually controls, but as I mentioned earlier, we basically want to have the inverted value so that we can actually access or write on both ends.
Chúng ta sẽ nói về đường bit (bit line) sau và cách nó điều khiển, nhưng như tôi đã nói trước đó, chúng ta muốn có giá trị đảo để có thể truy cập hoặc ghi ở cả hai đầu.
That's why we have two bit line, one is the bit line, one is the inverted bit line or bit line bar, right?
Đó là lý do có hai đường bit, một là đường bit, một là đường bit đảo hay bit line bar, đúng không?
So, one on the left, one on the right, so that we can actually access, connect to those access transistors to access what's the value inside, right?
Một bên trái, một bên phải, để chúng ta có thể truy cập, kết nối tới các transistor truy cập để biết giá trị bên trong là gì, đúng không?
So, those are the wires connected to the core of the 3T transistors and also the 3T, right?
Vậy đó là các dây nối với lõi của các transistor 3T và cả 3T nữa, đúng không?
We have two transistors are basically the access transistors that's connected bit line to the cross-coupled inverter to actually store, to actually access the transit, access the value, so that's why it's called access transistor, right?
Chúng ta có hai transistor chính là các transistor truy cập transistor nối với bit line và với cặp inverter mắc chéo để lưu trữ, để truy cập, tức là truy cập giá trị đó, nên mới gọi là access transistor, đúng không?
We have two inverters here, right? Remember, we always have a cross-coupled inverter to store the data. It's a little bit hard to see that, but we have, this is the first inverter, right?
Ở đây chúng ta có hai inverter, đúng không? Hãy nhớ rằng ta luôn dùng cặp inverter mắc chéo để lưu dữ liệu. Hơi khó nhìn một chút, nhưng đây là inverter thứ nhất, đúng không?
So, this is one inverter in our design and we have another inverter, right? So, there's another inverter, right?
Vậy đây là một inverter trong thiết kế của ta, và ta còn một inverter nữa, đúng không? Đây là inverter còn lại, đúng không?
So, we have two inverters in our design and they are cross-coupled, they're inverted, so basically one's input is the other, one's output is the other's input, right?
Vậy trong thiết kế có hai inverter và chúng mắc chéo nhau, đảo nhau, tức là đầu vào của cái này là của cái kia, đầu ra của cái này là đầu vào của cái kia, đúng không?
So, let's see the output of this inverter.
Hãy xem đầu ra của inverter này.
Let me see this, right? The output, okay, so this is the output, right? So, this is the output node of the green inverter is the input of the blue inverter, right?
Để tôi xem nào, đúng không? Đầu ra, được rồi, đây là đầu ra, đúng không? Đây là nút đầu ra của inverter màu xanh lá và là đầu vào của inverter màu xanh dương, đúng không?
And the output of the blue inverter is connected to the input of the green inverter, so that's why we have this loop. This kind of reading looks like the other side.
Còn đầu ra của inverter màu xanh dương được nối với đầu vào của inverter màu xanh lá, nên mới có vòng lặp này. Cách đọc này trông giống như phía bên kia.
Well, we're trying to write like a one, so like we're still having like a loop going on one side and just waiting for it to look like a strong zero.
Khi ta cố ghi giá trị một, thì vẫn có một vòng lặp đang chạy ở một phía và chờ cho nó trở thành một số không mạnh.
Exactly, exactly, so basically we're always focusing on the zero side because, well, one we can write is just a weaker, right?
Chính xác, chính xác, nên về cơ bản ta luôn tập trung vào phía số không, vì giá trị một mà ta ghi được thì yếu hơn, đúng không?
But we always, we'll talk about the read and write in more details actually next, just how we exactly perform that, but yes, we're basically focusing on the zero end.
Nhưng ta sẽ nói chi tiết hơn về đọc và ghi ngay sau đây, cụ thể là thực hiện chúng như thế nào, nhưng đúng, về cơ bản ta tập trung vào phía số không.
Oh, so why the access transistors are NMOS instead of PMOS?
Vậy tại sao các access transistor là NMOS thay vì PMOS?
PMOS, right, so NMOS are generally faster than PMOS. If you actually, before CMOS, a lot of designs are basically NMOS, right?
PMOS, đúng rồi, NMOS nhìn chung nhanh hơn PMOS. Trước thời CMOS, rất nhiều thiết kế về cơ bản là NMOS, đúng không?
So, we really, it's become actually more, more than technology, those two actually become similar, but generally NMOS actually are faster than PMOS.
Thực ra, theo công nghệ, hai loại này ngày càng trở nên tương tự nhau, nhưng nhìn chung NMOS vẫn nhanh hơn PMOS.
Is there any benefits you face to, say, using two NMOSes on either side, instead of just NMOSes on side driving?
Việc dùng hai NMOS ở cả hai phía có lợi ích gì không, thay vì chỉ dùng NMOS để điều khiển ở một phía?
Yeah, still, Bennett, we'll talk about the, how we actually read actually differentially to actually be faster, so when it's come to a read, it's actually faster because we actually get the differential relationship, yeah.
Vâng, Bennett, chúng ta sẽ nói về việc đọc vi sai để nhanh hơn như thế nào, nên khi đọc thì thực ra nhanh hơn vì ta có quan hệ vi sai, vâng.
So, I guess this is a basic, like, we see how the 6T SRAM is actually mapped to our two access transistors and cross-coupled inverters, right?
Vậy tôi nghĩ đây là phần cơ bản, ta thấy SRAM 6T được ánh xạ thế nào sang hai access transistor và cặp inverter mắc chéo, đúng không?
We'll get to the read and the write operation in a minute, but before we get there, let's talk about how we actually make sure that we can perform read and write correctly.
Chúng ta sẽ đến phần thao tác đọc và ghi trong một phút nữa, nhưng trước khi đến đó, hãy nói về cách ta đảm bảo rằng có thể thực hiện đọc và ghi một cách chính xác.
Let's take a look at how we actually do that to support different SRAM operations, right, with this design, 6T SRAM.
Hãy xem chúng ta thực sự làm điều đó như thế nào để hỗ trợ các thao tác SRAM khác nhau, nhỉ, với thiết kế này, SRAM 6T.
So, we think about different SRAM operations here, with first a couple of different ones, right?
Vậy, khi nghĩ về các thao tác SRAM khác nhau ở đây, trước hết là một vài thao tác, đúng không?
Let's say we want to, one of the operations, let's say we want to do a write, we want to write to the SRAM, right?
Giả sử chúng ta muốn, một trong các thao tác, giả sử ta muốn thực hiện ghi, ta muốn ghi vào SRAM, đúng không?
How do we actually control it so that we can write the value here, right?
Vậy ta điều khiển như thế nào để có thể ghi giá trị vào đây?
So, again, whenever we want to access our SRAM cell, right, either perform a read or write, we need to have our enable signal in the word line, right, because no matter what we read and write, we want to access, and the access transistors on both ends are controlled by the word line.
Vậy, một lần nữa, bất cứ khi nào ta muốn truy cập ô SRAM, dù là đọc hay ghi, ta cần có tín hiệu cho phép trên word line, vì dù đọc hay ghi, ta đều muốn truy cập, và các transistor truy cập ở hai đầu đều được điều khiển bởi word line.
The word line is actually controlling the access transistor, right? So, we need to turn on our word line so that we know this is a cell that we want to access, right?
Word line thực sự điều khiển các transistor truy cập, đúng không? Vậy, ta cần bật word line để biết đây là ô mà ta muốn truy cập, đúng không?
And the question we discussed earlier, right, when we write one or when we write a value, right, we basically, depends on the value we want to write, right, we always write inverted values on the two ends of the bit line, right?
Và câu hỏi mà ta đã thảo luận trước đó, khi ta ghi một, hay khi ta ghi một giá trị, về cơ bản, tùy theo giá trị ta muốn ghi, ta luôn ghi các giá trị đảo nhau lên hai đầu của bit line, đúng không?
So, you want to, let's say, write a zero on this side, and then the other side will be one, right, or vice versa.
Chẳng hạn, bạn muốn ghi số không ở phía này, thì phía kia sẽ là một, hoặc ngược lại.
So, the bit line, when we do the write operation, they are always inverted, right, depends on the value that we want to write.
Vậy, các bit line, khi ta thực hiện thao tác ghi, luôn đảo nhau, tùy theo giá trị mà ta muốn ghi.
And that's the value, and then we basically write over, we'll talk about how we do the overwrite, that part is very important, right, How we perform the read and write correctly.
Và đó là giá trị, rồi về cơ bản ta ghi đè lên, chúng ta sẽ nói về cách ghi đè, phần đó rất quan trọng, đó là cách ta thực hiện đọc và ghi cho đúng.
So, here we actually want to overwrite whatever data we actually used to store in our cross-coupled inverter.
Ở đây ta thực sự muốn ghi đè lên bất kỳ dữ liệu nào mà trước đó ta lưu trong cặp inverter mắc chéo.
We'll talk about how we do that, the write stability, in a minute, but that's how we control that from the word line, bit line point of view.
Lát nữa ta sẽ nói về cách làm điều đó, tức độ ổn định khi ghi, nhưng đó là cách ta điều khiển từ góc nhìn của word line và bit line.
That's how we like to control the write operation, right? So, that's a write operation. Before we get to the read, right, there is also, like, the cell.
Đó là cách ta điều khiển thao tác ghi. Vậy, đó là thao tác ghi. Trước khi sang thao tác đọc, còn có các ô khác nữa.
We have a lot of cells, we're not accessing all of them all together, right? We're writing different rows and different columns of the cell, right?
Ta có rất nhiều ô, và không truy cập tất cả cùng lúc, đúng không? Ta đang ghi vào các hàng và cột khác nhau của các ô.
We don't want to do anything to this cell, right? We're accessing other rows, right, accessing other columns, I don't want to do anything, right.
Ta không muốn làm gì với ô này cả, đúng không? Ta đang truy cập các hàng khác, truy cập các cột khác, ta không muốn làm gì với nó.
Again, whenever the word line controls the access of our SRAM cell, right, we don't need access, right?
Một lần nữa, word line điều khiển việc truy cập ô SRAM của ta, nên khi ta không cần truy cập, ta chỉ giữ giá trị, không cần truy cập, thì ta không làm gì với word line.
We just hold the value, we don't need access, we don't do anything, right, to our word line.
When the word line stays low, neither of the access transistors is on, so we don't have access to those transistors. The value stays there, we're not touching the value, right?
Khi word line ở mức thấp, cả hai transistor truy cập đều tắt, nên ta không truy cập được các transistor đó. Giá trị vẫn nằm đó, ta không động đến giá trị, đúng không?
So that's basically the hold state, right, how we actually hold the value in our SRAM cell, right? So that's write and hold, right. Then how about read, right?
Đó về cơ bản là trạng thái giữ, tức là cách ta giữ giá trị trong ô SRAM. Vậy đó là ghi và giữ. Còn đọc thì sao?
Also very important, we'll also talk about how the read stability operations work, right.
Cũng rất quan trọng, chúng ta cũng sẽ nói về cách hoạt động đọc ổn định hoạt động, nhé.
Read, first, again, we never want to access the cell, right, either read or write, we basically need to turn on our access transistor, we need to control our word line so that we have access to our transistor.
Với thao tác đọc, trước hết, một lần nữa, chúng ta không bao giờ muốn truy cập ô nhớ, dù là đọc hay ghi, mà không bật transistor truy cập, chúng ta cần điều khiển word line để có thể truy cập transistor.
So here we don't actually want to overwrite the value, right? What we want to do is really sense the value, what's inside in our SRAM.
Ở đây thực ra chúng ta không muốn ghi đè giá trị, đúng không? Điều chúng ta muốn là thực sự cảm nhận giá trị đang được lưu trong SRAM.
We want to sense the value without destroying the value, The value should still stay there. We want to read it but not destroy it, that's very important. That's what read stability actually means, right?
Chúng ta muốn cảm nhận giá trị mà không phá hủy nó, Giá trị vẫn phải còn nguyên ở đó. Chúng ta muốn đọc nó nhưng không phá hủy nó, điều này rất quan trọng. Đó chính là ý nghĩa của độ ổn định khi đọc (read stability), đúng không?
We want to read the value but not destroy the value, it should be non-destructive, right? So what we do when we actually do a read, right, we basically pre-charge.
Chúng ta muốn đọc giá trị nhưng không phá hủy giá trị, tức là phải không phá hủy (non-destructive), đúng không? Vậy khi thực hiện một thao tác đọc, về cơ bản chúng ta tiến hành nạp trước (pre-charge).
So this is the difference between read and write. So write, we basically, whatever the value we want to write, it's inverted, we control bit line and bit line bar.
Đây là điểm khác nhau giữa đọc và ghi. Với ghi, về cơ bản, giá trị nào chúng ta muốn ghi, thì giá trị đảo của nó, chúng ta điều khiển bit line và bit line bar.
We want to do a read, what we want to do is really want to sense, right, sense what's going on in this SRAM cell.
Khi muốn đọc, điều chúng ta thực sự muốn là cảm nhận, đúng không, cảm nhận điều đang diễn ra trong ô SRAM này.
We pre-charge our bit line, both pairs of bit lines, both bit line and bit line bar, we pre-charge them to VDD, so they are high, right, both are high.
Chúng ta nạp trước cho bit line, cả cặp bit line, cả bit line và bit line bar, nạp trước lên VDD, nên chúng đều ở mức cao, đúng không, cả hai đều cao.
What we want to do is to really sense what's going on inside. So now the access transistor is on, right, we have the access, we have the value.
Điều chúng ta muốn là thực sự cảm nhận điều đang diễn ra bên trong. Bây giờ transistor truy cập đã bật, đúng không, chúng ta có quyền truy cập, chúng ta có giá trị.
So that's why we mentioned briefly earlier, we can do actually differential read in the sense we have, we pull up our bit line, both are high, depends on the value stored on those two ends, right?
Đó là lý do trước đó chúng ta đã nhắc sơ qua, chúng ta thực sự có thể đọc vi sai theo nghĩa là, chúng ta kéo bit line lên, cả hai đều cao, tùy thuộc vào giá trị lưu ở hai đầu đó, đúng không?
So if the value is one here, if my bit line is high, I don't do anything, right? Both are one, stays one, no difference in my bit line.
Nếu giá trị ở đây là một, nếu bit line của tôi đang cao, tôi không làm gì cả, đúng không? Cả hai đều là một, vẫn là một, bit line không có sự khác biệt.
But if the value that is actually stored on the other hand is zero, right, that will lead to a discharging.
Nhưng nếu giá trị thực sự được lưu ở phía bên kia là không, đúng không, thì sẽ dẫn đến sự phóng điện.
So we'll talk about more likely next lecture how we actually make sure it's not significantly destroying the value, so non-destructive is very important.
Bài giảng sau chúng ta sẽ nói kỹ hơn về cách đảm bảo không làm hỏng đáng kể giá trị, nên tính không phá hủy là rất quan trọng.
But if it is zero, my voltage on my bit line will actually decrease, right? Because the other side is zero, I'm pre-charged to one, I will actually decrease.
Nhưng nếu là không, điện áp trên bit line của tôi sẽ giảm xuống, đúng không? Vì phía bên kia là không, tôi được nạp trước lên một, nên nó sẽ giảm xuống.
So by read, we're actually doing this differential read, we pull up our values, both bit line and bit line bar to be high, and then we read differentially to see which side is actually zero.
Như vậy với thao tác đọc, chúng ta thực sự đang đọc vi sai, chúng ta kéo các giá trị lên, cả bit line và bit line bar đều ở mức cao, rồi đọc vi sai để xem phía nào thực sự bằng không.
By doing that, we can actually basically sense what the value is in our SRAM, right?
Làm như vậy, về cơ bản chúng ta cảm nhận được giá trị trong SRAM là gì, đúng không?
So the key part is we want to read the cell, but we don't want to destroy the stored elements.
Vậy điểm mấu chốt là chúng ta muốn đọc ô nhớ, nhưng không muốn phá hủy các phần tử đã lưu.
So that leads to basically the read stability and the write stability consideration for the SRAM cell, and that leads to how we actually want to size our SRAM cell to make sure it meets both read stability and write stability.
Điều đó dẫn đến các yếu tố cần cân nhắc về độ ổn định khi đọc và độ ổn định khi ghi của ô nhớ SRAM, và dẫn đến việc chúng ta muốn định cỡ ô SRAM như thế nào để đảm bảo đáp ứng cả độ ổn định khi đọc lẫn khi ghi.
Those two parts are pretty important and also a little bit tricky, so I don't want to rush it in the last five minutes.
Hai phần này khá quan trọng và cũng hơi phức tạp, nên tôi không muốn làm vội trong năm phút cuối.
So we're going to pick it up next Friday, next Tuesday, how we actually read and write the SRAM cell. But yeah, the key thing, this is a 6T cell, right?
Vậy nên chúng ta sẽ tiếp tục vào thứ Sáu tới, à nhầm, thứ Ba tới, về cách chúng ta thực sự đọc và ghi ô nhớ SRAM. Nhưng điều quan trọng ở đây, đây là ô nhớ 6T, đúng không?
Again, a cross-coupled inverter, two access transistors, that's how we do these things.
Một lần nữa, đó là hai bộ đảo mắc chéo nhau, cùng hai transistor truy cập, đó là cách chúng ta xây dựng những thứ này.
But we'll talk about how we actually need to size those transistors very carefully to make sure when we write, we are strong enough to override the value, but when we read, we're careful enough that we're not destroying the value.
Nhưng chúng ta sẽ nói về việc thực sự cần chọn kích thước các transistor đó hết sức cẩn thận để đảm bảo rằng khi ghi, chúng ta đủ mạnh để ghi đè giá trị cũ, nhưng khi đọc, chúng ta đủ cẩn thận để không làm hỏng giá trị đang lưu.
With that, I'm going to end the lecture now, and we'll pick up our discussion next Tuesday on how we can actually do SRAM read and write correctly.
Đến đây, tôi xin kết thúc bài giảng, và chúng ta sẽ tiếp tục thảo luận vào thứ Ba tới về việc làm sao để đọc và ghi SRAM một cách chính xác.
It's great to see you, and I'll see you next Tuesday.
Rất vui được gặp các bạn, hẹn gặp lại vào thứ Ba tới.
Đă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.