3.1 Sequential Logic（逻辑时序）

image-20250407103408721

The Clock

image-20250407103559711

image-20250407103651219

⭐

Combinatorial Logic vs. Sequential Logic

image-20250407104103457

image-20250407104118222

image-20250407104217914

image-20250407104323702

3.2 Flip Flops 触发器

制作：允许上一步操作的芯片

⭐

D 触发器

换句话说，DFF 简单地将前一个时间周期的输入值作为当前周期的输出。𝑜𝑢𝑡(𝑡)=𝑖𝑛(𝑡−1)

image-20250407131732664

image-20250407125650242

时序逻辑的原理

image-20250407130044516

寄存器 Bit

【寄存器（也）是一种常用的时序逻辑电路】

image-20250407130252903

image-20250407130512040

implement

image-20250407130642446

show

image-20250407131134475

image-20250407131141487

image-20250407131153974

image-20250407131219341

image-20250407131249812

image-20250407131306313

3.3 Memory Units

image-20250407162440343

Memory

image-20250407162636276

The most basic memory element: Register

image-20250407162706895

⭐ （并着排列的）

image-20250407162832550

image-20250407163056209

RAM unit

image-20250407163925696

image-20250407164114314

image-20250407164124566

image-20250407164321731

image-20250407164328029

image-20250407164336551

image-20250407164355607

（逻辑时序的芯片）

image-20250407164409494

image-20250407164444136

RAM / Read Logic

image-20250407164613906

image-20250407164723446

RAM / Write Logic

image-20250407164822467

A family of 16-bit RAM chips

image-20250407165748845

image-20250407165903504

3.4 Counters

image-20250407183128147

image-20250407183216165

(Inc 代表增量[+1])

image-20250407183416972

3.5 code

preview：DFF

image-20250415121843294

1-bit register 芯片

  • 输入一个1-bit的数。如果load=1，下一秒输入该数，如果load=0，下一秒保持原来的数值。
  • register 中文：寄存器
image-20250415122014364 
1
2
3
4
5
6
7
8
CHIP Bit {
    IN in, load;
    OUT out;

    PARTS:
    Mux(a=out2 , b=in , sel=load , out=w1 );
    DFF(in=w1 , out=out,out=out2 );
}

16-bit register 芯片

  • 输入一个16-bit的数。根据load，下一秒输出该数，或者下一秒保持上一秒的值。
  • 1个load决定16个输出。16个1-bit register芯片并排。
  • 对每一位进行load运算
  • 最终的输入/输出 都是 一个 16-bit的数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 16-bit 寄存器! 
CHIP Register {
    IN in[16], load;
    OUT out[16];

    PARTS:
    //对16bit的每一位进行load，当load为1的时候给 对应位 储存值
    Bit(in=in[15] , load=load , out=out[15] );
    Bit(in=in[14] , load=load , out=out[14] );
    Bit(in=in[13] , load=load , out=out[13] );
    Bit(in=in[12] , load=load , out=out[12] );
    Bit(in=in[11] , load=load , out=out[11] );
    Bit(in=in[10] , load=load , out=out[10] );
    Bit(in=in[9] , load=load , out=out[9] );
    Bit(in=in[8] , load=load , out=out[8] );
    Bit(in=in[7] , load=load , out=out[7] );
    Bit(in=in[6] , load=load , out=out[6] );
    Bit(in=in[5] , load=load , out=out[5] );
    Bit(in=in[4] , load=load , out=out[4] );
    Bit(in=in[3] , load=load , out=out[3] );
    Bit(in=in[2] , load=load , out=out[2] );
    Bit(in=in[1] , load=load , out=out[1] );
    Bit(in=in[0] , load=load , out=out[0] );
}

RAM8

  • 8个 16-bit寄存器，并排放在RAM8里。
  • 输入：一个16-bit 的数。输出为 一个 16-bit 的数 （数最大 16-bit，可小点）
  • ⭐根据三位数地址address决定给 哪一个 register储存值。
  • 对应的被调到的寄存器的load会被打开，load=1。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
CHIP RAM8 {
    IN in[16], load, address[3];  // address有3位，能解码成 2的三次方= 8个 不一样的 三位数
    OUT out[16];

    PARTS:
    //假设address为000，load为 1。DMux8Way会把load信号分配到输出端口a，
    //也就是第一个寄存器的load端口会接收到值为 1 的信号，而其余寄存器的load端口会接收到值为 0 的信号（即不改变自身的值）
    DMux8Way(in = load,sel = address,a = a,b = b,c = c,d = d,e = e,f = f,g = g,h = h);

    Register(in=in , load=a , out=outa );
    Register(in=in , load=b , out=outb );
    Register(in=in , load=c , out=outc );
    Register(in=in , load=d , out=outd );
    Register(in=in , load=e , out=oute );
    Register(in=in , load=f , out=outf );
    Register(in=in , load=g , out=outg );
    Register(in=in , load=h , out=outh );

    Mux8Way16(a=outa , b=outb , c=outc , d=outd , e=oute , f=outf , g=outg , h=outh , sel=address , out=out);
}

RAM64

  • 原理同RAM8：一个最大16-bit的输入，根据address（解码后）决定把改 一位数值 保存在哪个地方（该地方的load会打开）
  • （结构由 8个RAM8 并排拼一起，解码端口变多了点，当然了address也长了点）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 CHIP RAM64 {
    IN in[16], load, address[6];
    OUT out[16];

    PARTS:
    DMux8Way(in = load,sel = address[3..5],a = a,b = b,c = c,d = d,e = e,f = f,g = g,h = h);
    //两层解码：第一层，用前3位区分开8个不一样的RAM8

	// 第二层，用后三位，区分开来每个RAM8的8个不同的寄存器。（这样子就区分开来了8*8=64个寄存器）
    RAM8(in=in , load=a , address=address[0..2] , out=outa );
    RAM8(in=in , load=b , address=address[0..2] , out=outb );
    RAM8(in=in , load=c , address=address[0..2] , out=outc );
    RAM8(in=in , load=d , address=address[0..2] , out=outd );
    RAM8(in=in , load=e , address=address[0..2] , out=oute );
    RAM8(in=in , load=f , address=address[0..2] , out=outf );
    RAM8(in=in , load=g , address=address[0..2] , out=outg );
    RAM8(in=in , load=h , address=address[0..2] , out=outh );

    Mux8Way16(a=outa , b=outb , c=outc , d=outd , e=oute , f=outf , g=outg , h=outh , sel=address[3..5] , out=out);
}

RAM512

  • 原理同上，就是积木从小拼到大（8个RAM64）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
CHIP RAM512 {
    IN in[16], load, address[9];
    OUT out[16];

    PARTS:
    DMux8Way(in = load,sel = address[6..8],a = a,b = b,c = c,d = d,e = e,f = f,g = g,h = h);

    RAM64(in=in , load=a , address=address[0..5] , out=outa );
    RAM64(in=in , load=b , address=address[0..5] , out=outb );
    RAM64(in=in , load=c , address=address[0..5] , out=outc );
    RAM64(in=in , load=d , address=address[0..5] , out=outd );
    RAM64(in=in , load=e , address=address[0..5] , out=oute );
    RAM64(in=in , load=f , address=address[0..5] , out=outf );
    RAM64(in=in , load=g , address=address[0..5] , out=outg );
    RAM64(in=in , load=h , address=address[0..5] , out=outh );

    Mux8Way16(a=outa , b=outb , c=outc , d=outd , e=oute , f=outf , g=outg , h=outh , sel=address[6..8] , out=out);
}

RAM4K

  • 8个RAM512
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 CHIP RAM4K {
    IN in[16], load, address[12];
    OUT out[16];

    PARTS:
    DMux8Way(in = load,sel = address[9..11],a = a,b = b,c = c,d = d,e = e,f = f,g = g,h = h);
    //假设address为000，load为 1。DMux8Way会把load信号分配到输出端口a。

    RAM512(in=in , load=a , address=address[0..8] , out=outa );
    RAM512(in=in , load=b , address=address[0..8] , out=outb );
    RAM512(in=in , load=c , address=address[0..8] , out=outc );
    RAM512(in=in , load=d , address=address[0..8] , out=outd );
    RAM512(in=in , load=e , address=address[0..8] , out=oute );
    RAM512(in=in , load=f , address=address[0..8] , out=outf );
    RAM512(in=in , load=g , address=address[0..8] , out=outg );
    RAM512(in=in , load=h , address=address[0..8] , out=outh );

    Mux8Way16(a=outa , b=outb , c=outc , d=outd , e=oute , f=outf , g=outg , h=outh , sel=address[9..11] , out=out);
}

RAM16K

  • 4个RAM4K
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 CHIP RAM16K {
    IN in[16], load, address[14];
    OUT out[16];

    PARTS:
    DMux4Way(in = load,sel = address[12..13],a = a,b = b,c = c,d = d);
    // 前两位用来区分4个RAM4K，后面12位是RAM4K所需的address。 

    RAM4K(in=in , load=a , address=address[0..11] , out=outa );
    RAM4K(in=in , load=b , address=address[0..11] , out=outb );
    RAM4K(in=in , load=c , address=address[0..11] , out=outc );
    RAM4K(in=in , load=d , address=address[0..11] , out=outd );
    
    Mux4Way16(a=outa , b=outb , c=outc , d=outd , sel=address[12..13] , out=out);
}
image-20250415131408114

CHIP PC

747e5d538c8e16996b67320f42e7e77

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
 * A 16-bit counter. 计数器吧？？？
 * if      reset(t): out(t+1) = 0
 * else if load(t):  out(t+1) = in(t)
 * else if inc(t):   out(t+1) = out(t) + 1
 * else              out(t+1) = out(t)
 */
 
CHIP PC {
    IN in[16], reset, load, inc;
    OUT out[16];
    
    PARTS:

    Inc16(in = feedback,out = incout);
    Mux16(a = feedback,b = incout,sel = inc,out = out1);
    Mux16(a = out1,b = in,sel = load,out = out2);
    Mux16(a = out2,b = false,sel = reset,out = out3);

    Register(in = out3,load = true,out = out,out = feedback);
}