精华内容
下载资源
问答
  • 计算机网络 同步传输和异步传输

    千次阅读 2017-09-25 22:10:53
    在网络通信过程中,通信双方要交换数据,需要高度的协同工作。为了正确的解释信号,接收方必须确切地知道信号应当何时接收处理,因此定时是至关重要的。...异步传输(Asynchronous Transmission):异步传输模式(A

    在网络通信过程中,通信双方要交换数据,需要高度的协同工作。为了正确的解释信号,接收方必须确切地知道信号应当何时接收和处理,因此定时是至关重要的。
    在计算机网络中,定时的因素称为位同步。同步是要接收方按照发送方发送的每个位的起止时刻和速率来接收数据,否则会产生误差。
    通常可以采用同步或异步的传输方式对位进行同步处理。

    1. 异步传输(Asynchronous Transmission):异步传输模式(Asynchronous Transfer Mode,缩略语为ATM)
      异步传输一般以字符为单位,
      起始位:先发出一个逻辑”0”信号,表示传输字符的开始。
      空闲位:处于逻辑“1”状态,表示当前线路上没有资料传送。

      异步传输将比特分成小组进行传送,小组可以是8位的1个字符或更长。发送方可以在任何时刻发送这些比特组,
      而接收方从不知道它们会在什么时候到达。一个常见的例子是计算机键盘与主机的通信。按下一个字母键、数字键或特殊字符键,就发送一个8比特位的ASCII代码。
      键盘可以在任何时刻发送代码,这取决于用户的输入速度,内部的硬件必须能够在任何时刻接收一个键入的字符。

    异步传输存在一个潜在的问题,即接收方并不知道数据会在什么时候到达。在它检测到数据并做出响应之前,第一个比特已经过去了。
    这就像有人出乎意料地从后面走上来跟你说话,而你没来得及反应过来,漏掉了最前面的几个词。因此,每次异步传输的信息都以一个起始位开头,
    它通知接收方数据已经到达了,这就给了接收方响应、接收和缓存数据比特的时间;在传输结束时,一个停止位表示该次传输信息的终止。
    按照惯例,空闲(没有传送数据)的线路实际携带着一个代表二进制1的信号,异步传输的开始位使信号变成0,其他的比特位使信号随传输的数据信息而变化。
    最后,停止位使信号重新变回1,该信号一直保持到下一个开始位到达。例如在键盘上数字“1”,按照8比特位的扩展ASCII编码,将发送“00110001”,
    同时需要在8比特位的前面加一个起始位,后面一个停止位。

    异步传输的实现比较容易,由于每个信息都加上了“同步”信息,因此计时的漂移不会产生大的积累,但却产生了较多的开销。
    在上面的例子,每8个比特要多传送两个比特,总的传输负载就增加25%。对于数据传输量很小的低速设备来说问题不大,
    但对于那些数据传输量很大的高速设备来说,25%的负载增值就相当严重了。因此,异步传输常用于低速设备。

    1. 同步传输(Synchronous Transmission):同步传输的比特分组要大得多。它不是独立地发送每个字符,每个字符都有自己的开始位和停止位,
      而是把它们组合起来一起发送。我们将这些组合称为数据帧,或简称为帧。

    数据帧的第一部分包含一组同步字符,它是一个独特的比特组合,类似于前面提到的起始位,用于通知接收方一个帧已经到达,
    但它同时还能确保接收方的采样速度和比特的到达速度保持一致,使收发双方进入同步。

    帧的最后一部分是一个帧结束标记。与同步字符一样,它也是一个独特的比特串,类似于前面提到的停止位,用于表示在下一帧开始之前没有别的即将到达的数据了。

    同步传输通常要比异步传输快速得多。接收方不必对每个字符进行开始和停止的操作。一旦检测到帧同步字符,它就在接下来的数据到达时接收它们。
    另外,同步传输的开销也比较少。例如,一个典型的帧可能有500字节(即4000比特)的数据,其中可能只包含100比特的开销。
    这时,增加的比特位使传输的比特总数增加2.5%,这与异步传输中25 %的增值要小得多。
    随着数据帧中实际数据比特位的增加,开销比特所占的百分比将相应地减少。但是,数据比特位越长,缓存数据所需要的缓冲区也越大,这就限制了一个帧的大小。
    另外,帧越大,它占据传输媒体的连续时间也越长。在极端的情况下,这将导致其他用户等得太久。

    同步传输方式中发送方和接收方的时钟是统一的、字符与字符间的传输是同步无间隔的。

    异步传输方式并不要求发送方和接收方的时钟完全一样,字符与字符间的传输是异步的。

    同步与异步传输的区别

    1,异步传输是面向字符的传输,而同步传输是面向比特的传输。

    2,异步传输的单位是字符而同步传输的单位是桢。

    3,异步传输通过字符起止的开始和停止码抓住再同步的机会,而同步传输则是以数据中抽取同步信息。

    4,异步传输对时序的要求较低,同步传输往往通过特定的时钟线路协调时序。

    5,异步传输相对于同步传输效率较低。

    简单说
      同步传输就是,数据没有被对方确认收到则调用传输的函数就不返回。  
    接收时,如果对方没有发送数据,则你的线程就一直等待,直到有数据了才返回,可以继续执行其他指令  
    异步传输就是,你调用一个函数发送数据,马上返回,你可以继续处理其他事,  接收时,对方的有数据来,你会接收到一个消息,或者你的相关接收函数会被调用。
    形象点说
      异步传输: 你传输吧,我去做我的事了,传输完了告诉我一声  同步传输: 你现在传输,我要亲眼看你传输完成,才去做别的事

    用于异步通信的连接在OSI(开放系统互连)参考模型的物理层中被定义。

    “异步通信”是一种很常用的通信方式。

    异步通信在发送字符时,所发送的字符之间的时间间隔可以是任意的。当然,接收端必须时刻做好接收的准备(如果接收端主机的电源都没有加上,那么发送端发送字符就没有意义,因为接收端根本无法接收)

    。发送端可以在任意时刻开始发送字符,因此必须在每一个字符的开始和结束的地方加上标志,即加上开始位和停止位,以便使接收端能够正确地将每一个字符接收下来。

    异步通信的好处是通信设备简单、便宜,但传输效率较低(因为开始位和停止位的开销所占比例较大)。

    异步通信也可以是以帧作为发送的单位。接收端必须随时做好接收帧的准备。这时,帧的首部必须设有一些特殊的比特组合,使得接收端能够找出一帧的开始。这也称为帧定界。帧定界还包含确定帧的结束位置。这有两种方法。一种是在帧的尾部设有某种特殊的比特组合来标志帧的结束。或者在帧首部中设有帧长度的字段。需要注意的是,在异步发送帧时,并不是说发送端对帧中的每一个字符都必须加上开始位和停止位后再发送出去,而是说,发送端可以在任意时间发送一个帧,而帧与帧之间的时间间隔也可以是任意的。在一帧中的所有比特是连续发送的。发送端不需要在发送一帧之前和接收端进行协调(不需要先进行比特同步)。

    位同步:
    要求接收端根据发送端发送数据的起止时间和时钟频率,来校正自己的时间基准和时钟频率,这个过程叫位同步。可见,位同步的目的是使接收端接收的每一位信息都与发送端保持同步。

    展开全文
  • 同步FIFO和异步FIFO

    万次阅读 多人点赞 2017-09-19 09:30:03
    1.定义 FIFO是英文First In First Out 的缩写,是一种先进先出的数据缓存器,他与普通存储器的区别是没有外部读写地址线,这样使用起来非常简单,但缺点就是只能顺序写入数据,顺序的读出数据, 其数据地址由内部...

    1.定义

      FIFO是英文First In First Out 的缩写,是一种先进先出的数据缓存器,他与普通存储器的区别是没有外部读写地址线,这样使用起来非常简单,但缺点就是只能顺序写入数据,顺序的读出数据, 其数据地址由内部读写指针自动加1完成,不能像普通存储器那样可以由地址线决定读取或写入某个指定的地址。

      FIFO一般用于不同时钟域之间的数据传输,比如FIFO的一端是AD数据采集, 另一端是计算机的PCI总线,假设其AD采集的速率为16位 100K SPS,那么每秒的数据量为100K×16bit=1.6Mbps,而PCI总线的速度为33MHz,总线宽度32bit,其最大传输速率为 1056Mbps,在两个不同的时钟域间就可以采用FIFO来作为数据缓冲。另外对于不同宽度的数据接口也可以用FIFO,例如单片机位8位数据输出,而 DSP可能是16位数据输入,在单片机与DSP连接时就可以使用FIFO来达到数据匹配的目的。

      FIFO的分类根均FIFO工作的时钟域,可以将FIFO分为同步FIFO和异步FIFO。同步FIFO是指读时钟和写时钟为同一个时钟。在时钟沿来临时同时发生读写操作。异步FIFO是指读写时钟不一致,读写时钟是互相独立的。

      FIFO设计的难点 FIFO设计的难点在于怎样判断FIFO的空/满状态。为了保证数据正确的写入或读出,而不发生益处或读空的状态出现,必须保证FIFO在满的情况下,不 能进行写操作。在空的状态下不能进行读操作。怎样判断FIFO的满/空就成了FIFO设计的核心问题。

    1.同步FIFO之Verilog实现

      同步FIFO的意思是说FIFO的读写时钟是同一个时钟,不同于异步FIFO,异步FIFO的读写时钟是完全异步的。同步FIFO的对外接口包括时钟,清零,读请求,写请求,数据输入总线,数据输出总线,空以及满信号。下面分别对同步FIFO的对外接口信号作一描述:

    1. 时钟,输入,用于同步FIFO的读和写,上升沿有效;

    2. 清零,输入,异步清零信号,低电平有效,该信号有效时,FIFO被清空;

    3. 写请求,输入,低电平有效,该信号有效时,表明外部电路请求向FIFO写入数据;

    4. 读请求,输入,低电平有效,该信号有效时,表明外部电路请求从FIFO中读取数据;

    5. 数据输入总线,输入,当写信号有效时,数据输入总线上的数据被写入到FIFO中;

    6. 数据输出总线,输出,当读信号有效时,数据从FIFO中被读出并放到数据输出总线上;

    7. 空,输出,高电平有效,当该信号有效时,表明FIFO中没有任何数据,全部为空;

    8. 满,输出,高电平有效,当该信号有效时,表明FIFO已经满了,没有空间可用来存贮数据。

      下面的框图主要描述同步FIFO的内部结构,画出框图有助于对电路结构的理解,同样也有助于RTL代码的编写 :

    这里写图片描述

    …………………………………………………………………………………………………………………………………………………………………………………………..

    同步FIFO的Verilog代码 之一
    在modlesim中验证过。

    /******************************************************
    A fifo controller verilog description.
    ******************************************************/
    module fifo(datain, rd, wr, rst, clk, dataout, full, empty);
    input [7:0] datain;
    input rd, wr, rst, clk;
    output [7:0] dataout;
    output full, empty;
    wire [7:0] dataout;
    reg full_in, empty_in;
    reg [7:0] mem [15:0];
    reg [3:0] rp, wp;
    assign full = full_in;
    assign empty = empty_in;
    // memory read out
    assign dataout = mem[rp];
    // memory write in
    always@(posedge clk) begin
        if(wr && ~full_in) mem[wp]<=datain;
    end
    // memory write pointer increment
    always@(posedge clk or negedge rst) begin
        if(!rst) wp<=0;
        else begin
          if(wr && ~full_in) wp<= wp+1'b1;
        end
    end
    // memory read pointer increment
    always@(posedge clk or negedge rst)begin
        if(!rst) rp <= 0;
        else begin
          if(rd && ~empty_in) rp <= rp + 1'b1;
        end
    end
    // Full signal generate
    always@(posedge clk or negedge rst) begin
        if(!rst) full_in <= 1'b0;
        else begin
          if( (~rd && wr)&&((wp==rp-1)||(rp==4'h0&&wp==4'hf)))
              full_in <= 1'b1;
          else if(full_in && rd) full_in <= 1'b0;
        end
    end
    // Empty signal generate
    always@(posedge clk or negedge rst) begin
        if(!rst) empty_in <= 1'b1;
        else begin
          if((rd&&~wr)&&(rp==wp-1 || (rp==4'hf&&wp==4'h0)))
            empty_in<=1'b1;
          else if(empty_in && wr) empty_in<=1'b0;
        end
    end
    endmodule

    …………………………………………………………………………………………………………………………………………………………………………………………..

    同步FIFO的Verilog代码 之二
    这一种设计的FIFO,是基于触发器的。宽度,深度的扩展更加方便,结构化跟强。以下代码在modelsim中验证过。

    module fifo_cell (sys_clk, sys_rst_n, read_fifo, write_fifo, fifo_input_data,
                            next_cell_data, next_cell_full, last_cell_full, cell_data_out, cell_full);
                            parameter WIDTH =8;
                            parameter D = 2;
                            input sys_clk;
                            input sys_rst_n;
                            input read_fifo, write_fifo;
                            input [WIDTH-1:0] fifo_input_data;
                            input [WIDTH-1:0] next_cell_data;
                            input next_cell_full, last_cell_full;
                            output [WIDTH-1:0] cell_data_out;
                            output cell_full;
                            reg [WIDTH-1:0] cell_data_reg_array;
                            reg [WIDTH-1:0] cell_data_ld;
                            reg cell_data_ld_en;
                            reg cell_full;
                            reg cell_full_next;
                            assign cell_data_out=cell_data_reg_array;
                            always @(posedge sys_clk or negedge sys_rst_n)
                               if (!sys_rst_n)
                                  cell_full <= #D 0;
                               else if (read_fifo || write_fifo)
                                  cell_full <= #D cell_full_next;
                            always @(write_fifo or read_fifo or next_cell_full or last_cell_full or cell_full)
                               casex ({read_fifo, write_fifo})
                                   2'b00: cell_full_next = cell_full;
                                   2'b01: cell_full_next = next_cell_full;
                                   2'b10: cell_full_next = last_cell_full;
                                   2'b11: cell_full_next = cell_full;
                               endcase
                             always @(posedge sys_clk or negedge sys_rst_n)
                                  if (!sys_rst_n)
                                     cell_data_reg_array [WIDTH-1:0] <= #D 0;
                                  else if (cell_data_ld_en)
                                     cell_data_reg_array [WIDTH-1:0] <= #D cell_data_ld [WIDTH-1:0];
                             always @(write_fifo or read_fifo or cell_full or last_cell_full)   
                                  casex ({write_fifo,read_fifo,cell_full,last_cell_full})
                                      4'bx1_xx: cell_data_ld_en = 1'b1;
                                      4'b10_01: cell_data_ld_en = 1'b1;
                                      default: cell_data_ld_en =1'b0;
                                  endcase
                             always @(write_fifo or read_fifo or next_cell_full or cell_full or last_cell_full or fifo_input_data or next_cell_data)
                                  casex ({write_fifo, read_fifo, next_cell_full, cell_full, last_cell_full})
                                     5'b10_x01: cell_data_ld[WIDTH-1:0] = fifo_input_data[WIDTH-1:0];
                                     5'b11_01x: cell_data_ld[WIDTH-1:0] = fifo_input_data[WIDTH-1:0];
                                     default: cell_data_ld[WIDTH-1:0] = next_cell_data[WIDTH-1:0];
                                  endcase
    endmodule
    
    
    
    module fifo_4cell(sys_clk, sys_rst_n, fifo_input_data, write_fifo, fifo_out_data,
                      read_fifo, full_cell0, full_cell1, full_cell2, full_cell3);
                      parameter WIDTH = 8;
                      parameter D = 2;
                      input sys_clk;
                      input sys_rst_n;
                      input [WIDTH-1:0] fifo_input_data;
                      output [WIDTH-1:0] fifo_out_data;
                      input read_fifo, write_fifo;
                      output full_cell0, full_cell1, full_cell2, full_cell3;
                      wire [WIDTH-1:0] dara_out_cell0, data_out_cell1, data_out_cell2,
                                       data_out_cell3, data_out_cell4;
                      wire full_cell4;
                      fifo_cell #(WIDTH,D) cell0
                      ( .sys_clk (sys_clk),
                        .sys_rst_n (sys_rst_n),
                        .fifo_input_data (fifo_input_data[WIDTH-1:0]),
                        .write_fifo (write_fifo),
                        .next_cell_data (data_out_cell1[WIDTH-1:0]),
                        .next_cell_full (full_cell1),
                        .last_cell_full (1'b1),
                        .cell_data_out (fifo_out_data [WIDTH-1:0]),
                        .read_fifo (read_fifo),
                        .cell_full (full_cell0)
                       );
    
                      fifo_cell #(WIDTH,D) cell1
                      ( .sys_clk (sys_clk),
                        .sys_rst_n (sys_rst_n),
                        .fifo_input_data (fifo_input_data[WIDTH-1:0]),
                        .write_fifo (write_fifo),
                        .next_cell_data (data_out_cell2[WIDTH-1:0]),
                        .next_cell_full (full_cell2),
                        .last_cell_full (full_cell0),
                        .cell_data_out (data_out_cell1[WIDTH-1:0]),
                        .read_fifo (read_fifo),
                        .cell_full (full_cell1)
                       );                  
                      fifo_cell #(WIDTH,D) cell2
                      ( .sys_clk (sys_clk),
                        .sys_rst_n (sys_rst_n),
                        .fifo_input_data (fifo_input_data[WIDTH-1:0]),
                        .write_fifo (write_fifo),
                        .next_cell_data (data_out_cell3[WIDTH-1:0]),
                        .next_cell_full (full_cell3),
                        .last_cell_full (full_cell1),
                        .cell_data_out (data_out_cell2[WIDTH-1:0]),
                        .read_fifo (read_fifo),
                        .cell_full (full_cell2)
                       );                  
    
                      fifo_cell #(WIDTH,D) cell3
                      ( .sys_clk (sys_clk),
                        .sys_rst_n (sys_rst_n),
                        .fifo_input_data (fifo_input_data[WIDTH-1:0]),
                        .write_fifo (write_fifo),
                        .next_cell_data (data_out_cell4[WIDTH-1:0]),
                        .next_cell_full (full_cell4),
                        .last_cell_full (full_cell2),
                        .cell_data_out (data_out_cell3[WIDTH-1:0]),
                        .read_fifo (read_fifo),
                        .cell_full (full_cell3)
                       );     
                       assign data_out_cell4[WIDTH-1:0] = {WIDTH{1'B0}};
                       assign full_cell4 = 1'b0;
    endmodule                              

    2.异步FIFO之Verilog实现

      FIFO (先进先出队列)是一种在电子系统得到广泛应用的器件,通常用于数据的缓存和用于容纳异步信号的频率或相位的差异。FIFO的实现通常是利用双口RAM和读写地址产生模块来实现的。FIFO的接口信号包括异步的写时钟(wr_clk)和读时钟(rd_clk)、与写时钟同步的写有效(wren)和写数据(wr_data)、与读时钟同步的读有效(rden)和读数据(rd_data)。为了实现正确的读写和避免FIFO的上溢或下溢,通常还应该给出与读时钟和写时钟同步的FIFO的空标志(empty)和满标志(full)以禁止读写操作。

    1 异步FIFO功能描述

      图1给出了FIFO的接口信号和内部模块图。
      由图1可以看出,写地址产生模块根据写时钟和写有效信号产生递增的写地睛,读地址产生模块根据读时钟和读有效信号产生递增的读地址。FIFO的操作如下:在写时钟wr_clk的升沿,当wren有效时,将wr_data写入双口RAM中写地址对应的位置中;始终将读地址对应的双口RAM中的数据输出到读数据总线上。这样就实现了先进先出的功能。
    这里写图片描述

      写地址产生模块还根据读地址和写地址关系产生FIFO的满标志。当wren有效时,若写地址+2=读地址时,full为1;当wren无效时,若写地址+ 1=读地址时,full为1。读地址产生模块还根据读地址和写地址的差产生FIFO的空标志。当rden有效时,若写地址-1=读地址时,empty为 1;当rden无效时,若写地址=读地址时,empty为1。按照以上方式产生标志信号是为了提前一个时钟周期产生对应的标志信号。
      由于空标志和满标志控制了FIFO的操作,因此标志错误会引起操作的错误。如上所述,标志的产生是通过对读写地址的比较产生的,当读写时钟完全异步时,对读写地址进行比较时,可能得出错误的结果。例如,在读地址变化过程中,由于读地址的各位变化并不同步,计算读写地址的差值,可能产生错误的差值,导致产生错误的满标志信号。若将未满标志置为满标志时,可能降低了应用的性能,降低写数据速率;而将满置标志置为未满时,执行一次写操作,则可能产生溢出错误,这对于实际应用来说是绝对应该避免的。空标志信号的产生也可能产生类似的错误。

    2 异步FIFO的改进设计

      从以上分析中可以看出,异步FIFO之所以会发生错误是国为在地址变化时,由于多位地址各位变化时间不同,异步时钟对其进行采样时数值可能为不同于地址变化丧后数值的其他值,异步产生错误的空标志和满标志,以致于产生FIFO的操作错误。
      格雷码是一种在相邻计数值之间只有一位发生变化的编码方式。可以看出,若读写地址采用格雷码编码方式,就可以解决上面的问题。
      为了应用的灵活,还增加了两个标志信号,将满(almosf_full)标志和空(almost_empty)标志分别定义如下:当写地址与读地址的距离小于某个预先定义数值时,almost_full为1;当读地址与写地址的距离小于这个预先定义的数值时,almost_empty为1。

    3 异步FIFO的Verilog

    …………………………………………………………………………………………………………………………………………………………………………………………………………………………….
    异步FIFO的Verilog代码 之一
    这个是基于RAM的异步FIFO代码,个人认为代码结构简单易懂,非常适合于考试中填写。记得10月份参加威盛的笔试的时候,就考过异步FIFO的实现。想当初要是早点复习,可能就可以通过威盛的笔试了。

    与之前的用RAM实现的同步FIFO的程序相比,异步更为复杂。增加了读写控制信号的跨时钟域的同步。此外,判空与判满的也稍有不同。

    module fifo1(rdata, wfull, rempty, wdata, winc, wclk, wrst_n,rinc, rclk, rrst_n);
    parameter DSIZE = 8; parameter ASIZE = 4;
    output [DSIZE-1:0] rdata;
    output wfull;
    output rempty;
    input [DSIZE-1:0] wdata;
    input winc, wclk, wrst_n;
    input rinc, rclk, rrst_n;
    reg wfull,rempty;
    reg [ASIZE:0] wptr, rptr, wq2_rptr, rq2_wptr, wq1_rptr,rq1_wptr;
    reg [ASIZE:0] rbin, wbin;
    reg [DSIZE-1:0] mem[0:(1<<ASIZE)-1];
    wire [ASIZE-1:0] waddr, raddr;
    wire [ASIZE:0] rgraynext, rbinnext,wgraynext,wbinnext;
    wire rempty_val,wfull_val;
    //-----------------双口RAM存储器--------------------
    assign rdata=mem[raddr];
    always@(posedge wclk)
    if (winc && !wfull) mem[waddr] <= wdata;
    //-------------同步rptr 指针-------------------------
    always @(posedge wclk or negedge wrst_n)
    if (!wrst_n) {wq2_rptr,wq1_rptr} <= 0;
    else {wq2_rptr,wq1_rptr} <= {wq1_rptr,rptr};
    //-------------同步wptr指针---------------------------
    always @(posedge rclk or negedge rrst_n)
    if (!rrst_n) {rq2_wptr,rq1_wptr} <= 0;
    else {rq2_wptr,rq1_wptr} <= {rq1_wptr,wptr};
    //-------------rempty产生与raddr产生-------------------
    always @(posedge rclk or negedge rrst_n) // GRAYSTYLE2 pointer
    begin
    if (!rrst_n) {rbin, rptr} <= 0;
    else {rbin, rptr} <= {rbinnext, rgraynext};
    end
    // Memory read-address pointer (okay to use binary to address memory)
    assign raddr = rbin[ASIZE-1:0];
    assign rbinnext = rbin + (rinc & ~rempty);
    assign rgraynext = (rbinnext>>1) ^ rbinnext;
    // FIFO empty when the next rptr == synchronized wptr or on reset
    assign rempty_val = (rgraynext == rq2_wptr);
    always @(posedge rclk or negedge rrst_n)
    begin
    if (!rrst_n) rempty <= 1'b1;
    else rempty <= rempty_val;
    end
    //---------------wfull产生与waddr产生------------------------------
    always @(posedge wclk or negedge wrst_n) // GRAYSTYLE2 pointer
    if (!wrst_n) {wbin, wptr} <= 0;
    else {wbin, wptr} <= {wbinnext, wgraynext};
    // Memory write-address pointer (okay to use binary to address memory)
    assign waddr = wbin[ASIZE-1:0];
    assign wbinnext = wbin + (winc & ~wfull);
    assign wgraynext = (wbinnext>>1) ^ wbinnext;
    assign wfull_val = (wgraynext=={~wq2_rptr[ASIZE:ASIZE-1], wq2_rptr[ASIZE-2:0]}); //:ASIZE-1]
    always @(posedge wclk or negedge wrst_n)
    if (!wrst_n) wfull <= 1'b0;
    else wfull <= wfull_val;
    endmodule

    ………………………………………………………………………………………………………………………………………………………………

      异步FIFO的Verilog代码 之二
      与前一段异步FIFO代码的主要区别在于,空/满状态标志的不同算法。

      第一个算法:Clifford E. Cummings的文章中提到的STYLE #1,构造一个指针宽度为N+1,深度为2^N字节的FIFO(为便方比较将格雷码指针转换为二进制指针)。当指针的二进制码中最高位不一致而其它N位都 相等时,FIFO为满(在Clifford E. Cummings的文章中以格雷码表示是前两位均不相同,而后两位LSB相同为满,这与换成二进制表示的MSB不同其他相同为满是一样的)。当指针完全相 等时,FIFO为空。

      这种方法思路非常明了,为了比较不同时钟产生的指针,需要把不同时钟域的信号同步到本时钟域中来,而使用Gray码的目的就是使这个异步同步化的过 程发生亚稳态的机率最小,而为什么要构造一个N+1的指针,Clifford E. Cummings也阐述的很明白,有兴趣的读者可以看下作者原文是怎么论述的,Clifford E. Cummings的这篇文章有Rev1.1 \ Rev1.2两个版本,两者在比较Gray码指针时的方法略有不同,个Rev1.2版更为精简。

      第二种算法:Clifford E. Cummings的文章中提到的STYLE #2。它将FIFO地址分成了4部分,每部分分别用高两位的MSB 00 、01、 11、 10决定FIFO是否为going full 或going empty (即将满或空)。如果写指针的高两位MSB小于读指针的高两位MSB则FIFO为“几乎满”,若写指针的高两位MSB大于读指针的高两位MSB则FIFO 为“几乎空”。

      它是利用将地址空间分成4个象限(也就是四个等大小的区域),然后观察两个指针的相对位置,如果写指针落后读指针一个象限(25%的距离,呵呵), 则证明很可能要写满,反之则很可能要读空,这个时候分别设置两个标志位dirset和dirrst,然后在地址完全相等的情况下,如果dirset有效就 是写满,如果dirrst有效就是读空。
      
      这种方法对深度为2^N字节的FIFO只需N位的指针即可,处理的速度也较第一种方法快。

      这段是说明的原话,算法一,还好理解。算法二,似乎没有说清楚,不太明白。有兴趣的可以查查论文,详细研究下。

      总之,第二种写法是推荐的写法。因为异步的多时钟设计应按以下几个原则进行设计:
      1,尽可能的将多时钟的逻辑电路(非同步器)分割为多个单时钟的模块,这样有利于静态时序分析工具来进行时序验证。
      2,同步器的实现应使得所有输入来自同一个时钟域,而使用另一个时钟域的异步时钟信号采样数据。
      3,面向时钟信号的命名方式可以帮助我们确定那些在不同异步时钟域间需要处理的信号。
      4,当存在多个跨时钟域的控制信号时,我们必须特别注意这些信号,保证这些控制信号到达新的时钟域仍然能够保持正确的顺序。

    module fifo2 (rdata, wfull, rempty, wdata,
    winc, wclk, wrst_n, rinc, rclk, rrst_n);
    parameter DSIZE = 8;
    parameter ASIZE = 4;
    output [DSIZE-1:0] rdata;
    output wfull;
    output rempty;
    input [DSIZE-1:0] wdata;
    input winc, wclk, wrst_n;
    input rinc, rclk, rrst_n;
    wire [ASIZE-1:0] wptr, rptr;
    wire [ASIZE-1:0] waddr, raddr;
    async_cmp #(ASIZE) async_cmp(.aempty_n(aempty_n),
    .afull_n(afull_n),
    .wptr(wptr), .rptr(rptr),
    .wrst_n(wrst_n));
    fifomem2 #(DSIZE, ASIZE) fifomem2(.rdata(rdata),
    .wdata(wdata),
    .waddr(wptr),
    .raddr(rptr),
    .wclken(winc),
    .wclk(wclk));
    rptr_empty2 #(ASIZE) rptr_empty2(.rempty(rempty),
    .rptr(rptr),
    .aempty_n(aempty_n),
    .rinc(rinc),
    .rclk(rclk),
    .rrst_n(rrst_n));
    wptr_full2 #(ASIZE) wptr_full2(.wfull(wfull),
    .wptr(wptr),
    .afull_n(afull_n),
    .winc(winc),
    .wclk(wclk),
    .wrst_n(wrst_n));
    endmodule
    module fifomem2 (rdata, wdata, waddr, raddr, wclken, wclk);
    parameter DATASIZE = 8; // Memory data word width
    parameter ADDRSIZE = 4; // Number of memory address bits
    parameter DEPTH = 1<<ADDRSIZE; // DEPTH = 2**ADDRSIZE
    output [DATASIZE-1:0] rdata;
    input [DATASIZE-1:0] wdata;
    input [ADDRSIZE-1:0] waddr, raddr;
    input wclken, wclk;
    `ifdef VENDORRAM
    // instantiation of a vendor's dual-port RAM
    VENDOR_RAM MEM (.dout(rdata), .din(wdata),
    .waddr(waddr), .raddr(raddr),
    .wclken(wclken), .clk(wclk));
    `else
    reg [DATASIZE-1:0] MEM [0:DEPTH-1];
    assign rdata = MEM[raddr];
    always @(posedge wclk)
    if (wclken) MEM[waddr] <= wdata;
    `endif
    endmodule
    module async_cmp (aempty_n, afull_n, wptr, rptr, wrst_n);
    parameter ADDRSIZE = 4;
    parameter N = ADDRSIZE-1;
    output aempty_n, afull_n;
    input [N:0] wptr, rptr;
    input wrst_n;
    reg direction;
    wire high = 1'b1;
    wire dirset_n = ~( (wptr[N]^rptr[N-1]) & ~(wptr[N-1]^rptr[N]));
    wire dirclr_n = ~((~(wptr[N]^rptr[N-1]) & (wptr[N-1]^rptr[N])) |
    ~wrst_n);
    always @(posedge high or negedge dirset_n or negedge dirclr_n)
    if (!dirclr_n) direction <= 1'b0;
    else if (!dirset_n) direction <= 1'b1;
    else direction <= high;
    //always @(negedge dirset_n or negedge dirclr_n)
    //if (!dirclr_n) direction <= 1'b0;
    //else direction <= 1'b1;
    assign aempty_n = ~((wptr == rptr) && !direction);
    assign afull_n = ~((wptr == rptr) && direction);
    endmodule
    module rptr_empty2 (rempty, rptr, aempty_n, rinc, rclk, rrst_n);
    parameter ADDRSIZE = 4;
    output rempty;
    output [ADDRSIZE-1:0] rptr;
    input aempty_n;
    input rinc, rclk, rrst_n;
    reg [ADDRSIZE-1:0] rptr, rbin;
    reg rempty, rempty2;
    wire [ADDRSIZE-1:0] rgnext, rbnext;
    //---------------------------------------------------------------
    // GRAYSTYLE2 pointer
    //---------------------------------------------------------------
    always @(posedge rclk or negedge rrst_n)
    if (!rrst_n) begin
    rbin <= 0;
    rptr <= 0;
    end
    else begin
    rbin <= rbnext;
    rptr <= rgnext;
    end
    //---------------------------------------------------------------
    // increment the binary count if not empty
    //---------------------------------------------------------------
    assign rbnext = !rempty ? rbin + rinc : rbin;
    assign rgnext = (rbnext>>1) ^ rbnext; // binary-to-gray conversion
    always @(posedge rclk or negedge aempty_n)
    if (!aempty_n) {rempty,rempty2} <= 2'b11;
    else {rempty,rempty2} <= {rempty2,~aempty_n};
    endmodule
    module wptr_full2 (wfull, wptr, afull_n, winc, wclk, wrst_n);
    parameter ADDRSIZE = 4;
    output wfull;
    output [ADDRSIZE-1:0] wptr;
    input afull_n;
    input winc, wclk, wrst_n;
    reg [ADDRSIZE-1:0] wptr, wbin;
    reg wfull, wfull2;
    wire [ADDRSIZE-1:0] wgnext, wbnext;
    //---------------------------------------------------------------
    // GRAYSTYLE2 pointer
    //---------------------------------------------------------------
    always @(posedge wclk or negedge wrst_n)
    if (!wrst_n) begin
    wbin <= 0;
    wptr <= 0;
    end
    else begin
    wbin <= wbnext;
    wptr <= wgnext;
    end
    //---------------------------------------------------------------
    // increment the binary count if not full
    //---------------------------------------------------------------
    assign wbnext = !wfull ? wbin + winc : wbin;
    assign wgnext = (wbnext>>1) ^ wbnext; // binary-to-gray conversion
    always @(posedge wclk or negedge wrst_n or negedge afull_n)
    if (!wrst_n ) {wfull,wfull2} <= 2'b00;
    else if (!afull_n) {wfull,wfull2} <= 2'b11;
    else {wfull,wfull2} <= {wfull2,~afull_n};
    endmodule
    展开全文
  • 同步通信和异步通信

    2016-05-04 10:20:08
    同步通信方式,是把许多字符组成一个信息组,这样,字符可以一个接一个地传输,但是,在每组信息(通常称为信息帧)的开始要加上同步字符,在没有信息要传输时,要填上空字符,因为同步传输不允许有间隙。同步方式下,...

    一、同步通信和异步通信
    串行通信可以分为两种类型,一种叫同步通信,另一种叫异步通信。
    同步通信方式,是把许多字符组成一个信息组,这样,字符可以一个接一个地传输,但是,在每组信息(通常称为信息帧)的开始要加上同步字符,在没有信息要传输时,要填上空字符,因为同步传输不允许有间隙。同步方式下,发送方除了发送数据,还要传输同步时钟信号,信息传输的双方用同一个时钟信号确定传输过程中每1位的位置。见右图5.2所示。



    图5.2 同步通信示意图
    在异步通信方式中,两个数据字符之间的传输间隔是任意的,所以,每个数据字符的前后都要用一些数位来作为分隔位。
    从图5.2中可以看到,按标准的异步通信数据格式(叫做异步通信帧格式),1个字符在传输时,除了传输实际数据字符信息外,还要传输几个外加数位。具体说,在1个字符开始传输前,输出线必须在逻辑上处于“1”状态,这称为标识态。传输一开始,输出线由标识态变为“0”状态,从而作为起始位。起始位后面为5~8个信息位,信息位由低往高排列,即先传字符的低位,后传字符的高位。信息位后面为校验位,校验位可以按奇校验设置,也可以按偶校验设置,或不设校验位。最后是逻辑的“1”作为停止位,停止位可为1位、1.5位或者2位。如果传输完1个字符以后,立即传输下一个字符,那么,后一个字符的起始位便紧挨着前一个字符的停止位了,否则,输出线又会进入标识态。在异步通信方式中,发送和接收的双方必须约定相同的帧格式,否则会造成传输错误。在异步通信方式中,发送方只发送数据帧,不传输时钟,发送和接收双方必须约定相同的传输率。当然双方实际工作速率不可能绝对相等,但是只要误差不超过一定的限度,就不会造成传输出错。图5.3是异步通信时的标准数据格式。

    图5.3 异步通信示意图
    比较起来,在传输率相同时,同步通信方式下的信息有效率要比异步方式下的高,因为同步方式下的非数据信息比例比较小。
    二、传输率
    所谓传输率就是指每秒传输多少位,传输率也常叫波特率。在计算机中,每秒传输多少位和波特率的含义是完全一致的,但是,在最初的定义上,每秒传输多少位和波特率是不同的,前者是指每秒钟传输的数位是多少,而波特率是指每秒钟传输的离散信号的数目。所谓离散信号,就是指不均匀的、不连续的也不相关的信号。在计算机里,只允许高电平和低电平两种离散信号,它们分别表示l和0,于是,造成了波特率与每秒传输数位这两者的吻合。但在其他一些场合,就未必如此。比如,采用脉冲调制时,可以允许取4种相位,而每种相位代表2个数位,这种情况下,按每秒传输多少位(bps)计算的传输率便是波特率的两倍。
    国际上规定了一个标准波特率系列,标准波特率也是最常用的波特率,标准波特率系列为110、300、600、1200、1800、2400、4800、9600、19200......。
    大多数接口的波特率可以通过编程来指定。
    作为例子,我们可以考虑这样一个异步传输过程:设每个字符对应1个起始位、7个数据位、1个奇/偶校验位和1个停止位,如果波特率为1200,那么,每秒钟能传输的最大字符数为1200/10=120个。 
    作为比较,我们再来看一个同步传输的例子。假如也用1200的波特率工作,每个字符为7位,用4个同步字符作为信息帧头部,但不用奇/偶校验,那么,传输100个字符所用的时间为7×(100+4)/1200=0.6067,这就是说,每秒钟能传输的字符数可达到100/0.6067=165个。
    三、异步通信的差错类型
    异步通信过程中,可能发生通信错,一般有3种错误:
    1、帧格式错:在应该接收到停止位的时候,接收到逻辑的“0”,便产生帧格式错误。
    2、奇偶错:接收到的奇偶校验位错。
    3、覆盖错:通信接口接收到数据并存放到数据输入寄存器中,但是CPU没有及时来取,后面新接收的数据覆盖了前面收到的数据,叫做覆盖错。
    发生帧格式错和奇偶错的原因可能为下面几种:
    ◆ 发送和接收双方采用了不同的传输率,或虽然双方约定了相同的传输率,但传输率不可能绝对相等。在通信的速率比较高的情况下,如果双方的传输率误差达到一定的程度,也会造成通信出错;
    ◆ 通信双方采用了不相同的帧格式;
    ◆ 干扰。
    展开全文
  • 同步系统和异步系统容错率的思考

    千次阅读 2018-08-17 17:33:14
    经常听到有文章引用下面这句话:在同步系统中容错率可以达到50%,而在异步系统中容错率下降到33%。 那么问题来了,到底什么是同步系统,什么是异步系统? 同步系统(Synchronous System) 援引...

    经常听到有文章引用下面这句话:在同步系统中容错率可以达到50%,而在异步系统中容错率下降到33%。
    实际上这句话是有问题的,早在1985年Michael J. Fischer, Nancy Lynch, 和Mike Paterson已经证明,在一个完全异步的系统中,没有任何一种共识算法可以容忍哪怕一个错误节点,史称FLP不可能性证明(FLP是他们三个人名字的缩写)。所以,上面那句话应该把“异步系统”修正为“部分同步系统”。
    那么问题来了,到底什么是同步系统,异步系统,和部分同步系统呢?

    同步系统(Synchronous System)

    援引《Introduction to Reliable and Secure Distributed Programming》第46页中的权威定义:

    1. Synchronous computation. There is a known upper bound on processing delays. That is, the time taken by any process to execute a step is always less than this bound. Remember that a step gathers the delivery of a message (possibly nil) sent by some other process, a local computation (possibly involving interaction among several layers of same process), and the sending of a message of some other process (possibly omitted).
    2. Synchronous communication. There is known uppder bound on message transmission delays. That is, the time period between the instant at which a message is sent and the instant at which the message is delivered by the destination process is smaller than this bound.

    也就是说,同步系统可以保证在有限时间内完成计算,在有限时间内完成网络传输。

    异步系统(Asynchronous System)

    显然,异步系统就是不符合上面两个条件的系统了。

    部分同步系统(Partial Synchronous System)

    事实上,在实际系统中,大多数情况下都属于同步系统,只有在某些极端情况下(如网络丢包、缓存被塞满等),系统会转变为异步系统。这种系统被称为部分同步系统。
    部分同步系统有两种形式的定义:

    1. 系统可以保证在有限时间内完成计算和网络传输,但是这个时间无法被预先知道
    2. 系统只能在一段无法预知的时间内,保证计算和网络传输有一个时间上限

    同步系统的容错率

    这里只讨论签名消息,直观来说,需要通过少数服从多数来达成共识,那么显然容错率是50%。
    当然,Andrew Miller在他的论文给出了证明过程:

    1. 假设集合P中都是诚实节点,Q中都是恶意节点,输入为0,结果如左图所示
    2. 假设集合P中都是恶意节点,Q中都是诚实节点,输入为1,结果如右图所示
      通过一个"passive client"去观察(这个passive client只能接收消息,不能发送消息),无法区分这两种情况。因此,同步系统的容错率为50%。

    这里写图片描述

    如果要求所有节点转发消息时都带上自己的签名,将可以获得更强的容错性。例如Lamport设计了一种算法,理论上可以达到99%的容错率:

    这里写图片描述

    假设有m个恶意节点,诚实节点只需要确保收到m+1个不同节点签名,就可以保证所有诚实节点达成一致。
    以图中情况为例:图中有4个恶意节点,2个诚实节点。当节点6收到4个签名的时候(实线部分),还无法确认该消息是否有效,因为有可能都是恶意节点的签名。但是,当它收到5个签名时(虚线部分),就可以确认节点2一定也已经收到过该信息,这样所有诚实节点就可以达成一致了。

    部分同步系统的容错率

    在部分同步系统中,网络传输可能出现长时间的延迟,因此节点可能无法收全所有信息。在这种情况下,节点会进入等待,需要在收到有限条消息的时候做出决策。PBFT就是一种异步系统中的拜占庭容错算法,最大容错率为33%,推导如下:

    • 假设系统中有m个恶意节点
    • 这些恶意节点可能选择不发送消息,这样诚实节点最多只能收到n-m条消息,并在此时做出决策
    • 但是,由于网络延迟,诚实节点发送的消息有可能没收到,也就是说,这n-m条消息中有可能包含了m个恶意节点的消息
    • 为了作出正确的决策,至少需要m+1个诚实节点的消息,才能推翻这m个恶意节点的消息
    • 也就是说,需要n-m >= 2m+1,即n >= 3m+1,证毕

    这里写图片描述

    关于POW

    POW是一种比较特殊的算法,它依靠算力竞赛而非网络交互完成共识。参见以太坊wiki上的描述:
    Proof of work has been rigorously analyzed by Andrew Miller and others and fits into the picture as an algorithm reliant on a synchronous network model. We can model the network as being made up of a near-infinite number of nodes, with each node representing a very small unit of computing power and having a very small probability of being able to create a block in a given period. In this model, the protocol has 50% fault tolerance assuming zero network latency, ~46% (Ethereum) and ~49.5% (Bitcoin) fault tolerance under actually observed conditions, but goes down to 33% if network latency is equal to the block time, and reduces to zero as network latency approaches infinity.

    也就是说,POW在网络无延时的情况下可以达到50%的容错率,当网络延时和出块时间相当时容错率下降到33%,而当网络延时趋于无穷大时容错率趋于0(会出现大量分叉,导致网络不可用)。

    参考:
    https://books.google.com/books?id=Y8lHVFeJ6EQC&printsec=frontcover&source=gbs_ge_summary_r&cad=0#v=onepage&q&f=false
    https://groups.csail.mit.edu/tds/papers/Lynch/jacm88.pdf
    https://eprint.iacr.org/2016/454.pdf
    https://github.com/ethereum/wiki/wiki/Proof-of-Stake-FAQs
    https://groups.csail.mit.edu/tds/papers/Lynch/jacm88.pdf

    更多文章欢迎关注“鑫鑫点灯”专栏:https://blog.csdn.net/turkeycock
    或关注飞久微信公众号:
    在这里插入图片描述

    展开全文
  • 同步FIFO与异步FIFO的基本原理

    千次阅读 2020-11-18 10:49:22
    FIFO是英文First In First Out 的缩写,是一种先进先出的数据缓存器,他与普通存储器的区别是没有外部读写地址线,这样使用起来非常简单,但缺点就是只能顺序写入数据,顺序的读出数据, 其数据地址由内部读写指针...
  • NAND Flash的同步异步

    2021-06-11 09:02:58
    同步异步SDR与DDRSyncAsyncONFIToggle闪存的同步异步 SDR与DDR     SDR(single data rate),写数据使用上升沿或下降沿来触发。因为只用上升沿或下降沿,对信号的准确性要求较低。  ...
  • 异步传输同步传输

    千次阅读 2011-07-31 17:01:25
    异步传输(Asynchronous Transmission): 异步传输将比特分成小组进行传送,小组可以是8位的1个字符或更长。发送方可以在任何时刻发送这些比特组,而接收方从不知道它们会在什么时候到达。一个常见的例子是计算机...
  • 【FPGA——基础篇】同步FIFO与异步FIFO——Verilog实现

    万次阅读 多人点赞 2019-04-16 09:20:07
    FIFO是英文First In First Out 的缩写,是一种先进先出的数据缓存器,他与普通存储器的区别是没有外部读写地址线,这样使用起来非常简单,但缺点就是只能顺序写入数据,顺序的读出数据, 其数据地址由内部读写指针...
  • HTTP协议是Hyper Text Transfer Protocol(超文本传输协议)的缩写,是用于从万维网(WWW:World Wide Web )服务器传输超文本到本地浏览器的传送协议。 HTTP是一个基于TCP/IP通信协议来传递数据(HTML 文件, 图片文件...
  • Node.js 异步性能与同步性能对比

    千次阅读 2016-01-03 21:17:08
    上周做了个分享,基于node.js的ECMAScript 6...其中引用到了很多地方都在说的:node.js的异步非阻塞模型能扛高并发,是构建高性能网站的利器。但是没有示例,大家也提出了很多疑问。所以今天在此补上一个简单的示例。
  • 在高性能的I/O设计中,有两个著名的模型:Reactor模型Proactor模型,其中Reactor模型用于同步I/O,而Proactor模型运用于异步I/O操作。
  • 我们通常所说的 BIO 是相对于 NIO 来说的,BIO 也就是 Java 开始之初推出的 IO 操作模块,BIO 是 BlockingIO 的缩写,顾名思义就是阻塞 IO 的意思。 BIO、NIO、AIO的区别 BIO 就是传统的 java.io 包,它是基于流模型...
  • // // ViewController.m // UI-NO.18 // // Created by Bruce on 15/8/11. // Copyright (c) 2015年 Bruce. All rights reserved. ...超文本传输协议(HTTP,HyperText Transfer Protocol)是互联网上应...
  • 同步异步存储器

    2013-08-08 09:32:00
    1.SSRAM 是synchronous static random access memory 的缩写,即同步静态随机存取存储器。 ①同步是指Memory工作需要步时钟,内部的命令的发送与数据的传输都以它为基准;随机是指数据不是线性依次存储,而是由指定...
  • Nand Flash的同步异步、ONFI、Toggle

    万次阅读 多人点赞 2018-07-02 16:55:15
    DDR(Double Data Rate),写数据时通过MCU来控制DQS信号跳变沿来触发(即上升沿下降沿均触发),所以对信号的准确性要求较高,可以通过增加同步时钟信号来提高信号的准确性,如ONFI2.0时的DDR就是使用此方式。...
  • 什么是ftp异步模式 FTP:文件传输协议 (FTP: File Transfer Protocol) FTP is an abbreviation of the File Transfer Protocol. FTP is a standard network protocol used in transferring files between systems of...
  • 串口通信协议--同步异步,位传输

    千次阅读 2008-09-21 16:11:00
    具体如下: 串行通信协议分同步协议和异步协议。 (1)异步通信协议的实例——起止式异步协议 特点与格式: 起止式异步协议的特点是一个字符一个字符传输,并且传送一个字符总是以起始位开始,以停止位结束,字符...
  • 同步FIFO和异步FIFO的Verilog实现

    万次阅读 2014-05-14 20:29:26
    FIFO是英文First In First Out 的缩写,是一种先进先出的数据缓存器,他与普通存储器的区别是没有外部读写地址线,这样使用起来非常简单,但缺点就是只能顺序写入数据,顺序的读出数据, 其数据地址由内部读写指针...
  • and-wait protocol )1.1.2、后退N 步式1.1.3、选择重发式1.2、相关概念1.2.1、HARQ process number1.2.2、NDI1.2.3、RV1.2.4、MCS1.2.5、同步(synchronous)和异步(asynchronous)1.2.6、自适应(adaptive)非...
  • 比特率 波特率 数据传输速率区别

    千次阅读 2018-08-16 20:28:55
    其定义是:通信线路(或系统)单位时间(每秒)内传输的信息量,即每秒能传输的二进制位数,其单位是比特/秒(bit/s或b/s,英文缩略语为bps)。  在二进制系统中,信息速率(比特率)与信号速率(波特率)相等,例如,当系统...
  • 异步同步

    2017-10-10 11:50:05
    要说Ajax就不得不说,异步传输和同步传输了。 异步是值:发送方发出数据后,不等接收方发回响应,接着发送下一个数据包的通讯方式。同步是指:发送方发出数据后,等待接收方发回响应以后才发下一个数据包的通讯...
  • AJAX是异步JavaScriptXML的首字母缩写。 它是一组相互关联的技术,例如JavaScript,DOM,XML,HTML / XHTML,CSS,XMLHttpRequest等。 AJAX允许您异步发送接收数据,而无需重新加载网页。 所以它速度很快 AJAX...
  • 参考博文:https://www.cnblogs.com/ylsm-kb/p/9068449.html FIFO是英文First In First Out 的缩写,是一...
  • 该总线双向通信,可以实现全双工传输和接收。 SPI是串行外设接口(Serial Peripheral Interface)的缩写,是一种高速的,全双工,同步的通信总线。 IIC是飞利浦公司推出的总线协议,串行同步半双工。 RS485也是...
  • 同步异步

    2012-12-07 11:28:41
    同步 设备同步 当两个设备一起工作并对时间有精确要求的时候,就需要在它们之间进行同步同步是基于在两个设备之间规定一个共同的时间参考。例如,你想将32轨的音频信号录制在两台16轨磁带机上,则这两个磁带机的...
  • //默认用了两个中间件,日志恢复 engine.Use(Logger(), Recovery()) 中间件 基本路由 Gin框架中采用的路由库是基于 httprouter做的 Restful风格的API ​ Gin支持Restful风格的API ​ Representational ...
  • 异步传输模式(ATM)

    千次阅读 2008-09-09 13:08:00
    ATM是Asynchronous Transfer Mode(ATM)异步传输模式的缩写ATM是一项数据传输技术。ATM是以信元为基础的一种分组交换复用技术,它是一种为了多种业务设计的通用的面向连接的传输模式。它适用于局域网广域网,它...
  • 内容 :FIFO设计,同步FIFO,异步FIFO 来自 :时间的诗 原文:http://xilinx.eetrend.com/blog/2118 FIFO 很重要,之前参加的各类电子公司的逻辑设计的笔试几乎都会考到。 FIFO是英文First ...
  • 所用到的数据传输标准 合理的选择电动机是正确使用的先决条件。选择恰当,电动机就能安全、经济、可靠地运行;选择得不合适,轻者造成浪费,重者烧毁电动机。选择电动机的内容包括很多,例如电压、频率、功率、转速...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,781
精华内容 7,112
关键字:

同步传输和异步传输缩写