精华内容
下载资源
问答
  • 并行转串行 串行转并行输出模块

    千次阅读 2018-12-28 17:50:02
    并行转串行 串行转并行输出模块 夏宇闻Verilog 第15章学习笔记 通信协议:scl为高,sda由高跳变低,start;scl为高,sda由低跳变为高,stop;scl为低,sda数据位才能变化 两个模块ptosda和out16hi,将ptosda并转串...

    并行转串行 串行转并行输出模块

    夏宇闻Verilog 第15章学习笔记

    • 通信协议:scl为高,sda由高跳变低,start;scl为高,sda由低跳变为高,stop;scl为低,sda数据位才能变化
    • 两个模块ptosda和out16hi,将ptosda并转串模块的串行输出给out16hi串转并模块,输出对应的高位电平

    代码如下

    //************************并行数据转一种特殊串行数据流********************************
    //模块名称:M1 转换模块
    //说明:data用scl和sda传输,sclk为输入时钟,data[3:0]数据流,ack为请求发送数据
    //**********************************************************************************
    
    module ptosda(rst_n,sclk,ack,scl,sda,data);
    
    input rst_n,sclk;
    input[3:0] data;
    output scl,sda,ack;
    
    reg scl,link_sda,ack,sda_buf;              //ack ask for new data
    reg[3:0] data_buf;
    reg[7:0] state;
    
    assign sda=link_sda?sda_buf:1'b0;             //link_sda控制sda_buf输出到串行总线上
    
    parameter Ready=8'b00000000,
              Start=8'b00000001,
    		   bit1=8'b00000010,
    		   bit2=8'b00000100,
               bit3=8'b00001000,
               bit4=8'b00010000,
               bit5=8'b00100000,
               Stop=8'b01000000,
               Idle=8'b10000000;
    
    always@(posedge sclk or negedge rst_n)begin      //sclk产生scl为sclk的2T
     if(!rst_n)begin
      scl<=1;
     end
     else begin
      scl<=~scl;
     end
    end
    
    always@(posedge ack)begin	   //请求新数据时存入并行主线的数据	   
     data_buf<=data;
    end
    //******************主状态机:产生控制信号,根据data_buf中的数据,按照协议产生串行信号
    always@(negedge sclk or negedge rst_n)begin
     if(!rst_n)begin
      link_sda<=0;          //sda_buf与sda串行总线断开 
      state<=Ready;
      sda_buf<=1;
      ack<=0;
     end
     else begin
      case(state)
       Ready:begin
              if(ack)begin            //并行数据已经到达
      		   link_sda<=1;
               state<=Start;		  
    		  end
    		  else begin
    		   link_sda<=0;
    		   state<=Ready;
    		   ack<=1;
    		   //sda_buf<=1;
    		  end
    		 end
       Start:begin
              if(scl && ack)begin       //产生sda开始的信号  (开始是scl为高,sda由高变低)
               sda_buf<=0;
    		   state<=bit1;
    		  end
    		  else state<=Start;
             end
    	bit1:begin
    	      if(!scl)begin
    		   sda_buf<=data_buf[3];
    		   state<=bit2;
    		  end
    		  else state<=bit1;
    		 end
        bit2:begin
    	      if(!scl)begin
    		   sda_buf<=data_buf[2];
    		   state<=bit3;
    		  end
    		  else state<=bit2;
    		 end
    	bit3:begin
    	      if(!scl)begin
    		   sda_buf<=data_buf[1];
    		   state<=bit4;
    		  end
    		  else state<=bit3;
    		 end
    	bit4:begin
    	      if(!scl)begin
    		   sda_buf<=data_buf[0];
    		   state<=bit5;
    		  end
    		  else state<=bit4;
    		 end
    	bit5:begin
    	      if(!scl)begin
    		   sda_buf<=0;             //为产生结束信号做准备,先把sda变低
    		   state<=Stop;
    		  end
    		  else state<=bit5;
    		 end
    	Stop:begin
    	      if(scl)begin
    		   sda_buf<=1;
    		   state<=Idle;
    		  end
    		  else state<=Stop;
    		 end
    	Idle:begin
    	      link_sda<=0;
    		  state<=Ready;
    		 end
    	default:begin
    	         link_sda<=0;
    			 sda_buf<=1;
    			 state<=Ready;
    			end
      endcase	
     end
    end
    
    endmodule
    
    //*******************************************//
    //模块功能:接收串行数据,按照数据值在相应位输出高电平
    //可综合
    //***************************************************
    
    module out16hi(scl,sda,outhigh);
    
    input scl,sda;           //串行数据输入
    output reg[3:0] outhigh;
    reg[5:0] mstate /*synthesis preserve*/;
    
    reg[3:0] pdata,pdatabuf;  //记录串行数据位时候,用寄存器和最终数据寄存器;
    reg Startflag,Endflag;
    
    always@(negedge sda)begin
     if(scl)begin
      Startflag<=1;
     end
     else if(Endflag)begin
      Startflag<=0; 
     end
    end
    
    always@(posedge sda)begin
     if(scl)begin
      Endflag<=1;
      pdatabuf<=pdata;          //把收到的四位数据存入寄存器
     end
     else Endflag<=0;
    end
    
    parameter Ready=6'b000000,
              sbit0=6'b000001,
    		  sbit1=6'b000010,
    		  sbit2=6'b000100,
    		  sbit3=6'b001000,
    		  sbit4=6'b010000;
    
    always@(pdatabuf)begin         //把收到的数据变为相应高电平
     case(pdatabuf)
      4'b0001: outhigh=16'b0000_0000_0000_0001;
      4'b0010: outhigh=16'b0000_0000_0000_0010;
      4'b0011: outhigh=16'b0000_0000_0000_0100;
      4'b0100: outhigh=16'b0000_0000_0000_1000;
      4'b0101: outhigh=16'b0000_0000_0001_0000;
      4'b0110: outhigh=16'b0000_0000_0010_0000;
      4'b0111: outhigh=16'b0000_0000_0100_0000;
      4'b1000: outhigh=16'b0000_0000_1000_0000;
      4'b1001: outhigh=16'b0000_0001_0000_0000;
      4'b1010: outhigh=16'b0000_0010_0000_0000;
      4'b1011: outhigh=16'b0000_0100_0000_0000;
      4'b1100: outhigh=16'b0000_1000_0000_0000;
      4'b1101: outhigh=16'b0001_0000_0000_0000;
      4'b1110: outhigh=16'b0010_0000_0000_0000;
      4'b1111: outhigh=16'b0100_0000_0000_0000;
      4'b0000: outhigh=16'b1000_0000_0000_0000;
     endcase
    end
    
    always@(posedge scl)begin            //检测到开始 之后每次scl正跳变接收数据
     if(Startflag)begin
        case(mstate)
    	  sbit0:begin
    	         mstate<=sbit1;
    			 pdata[3]<=sda;
    			 $display("i am in sdabit0");
    			end
    	  sbit1:begin
    	         mstate<=sbit2;
    			 pdata[2]<=sda;
    			 $display("i am in sdabit1");
    			end
    	  sbit2:begin
    	         mstate<=sbit3;
    			 pdata[1]<=sda;
    			 $display("i am in sdabit2");
    			end
    	  sbit3:begin
    	         mstate<=sbit4;
    			 pdata[0]<=sda;
    			 $display("i am in sdabit3");
    			end
    	  sbit4:begin
    	         mstate<=sbit0;
    			 $display("i am in sdastop");
    			end
          default: mstate<=sbit0; //6'bxx_xxxx;			
        endcase
     end
     else mstate<=sbit0;   
    end		
    
    endmodule  
    
    

    这里的状态机的Ready其实没有用到,不需要这个状态

    //**********************顶层************************
    //模块名称:顶层   文件名:top_bingxingzhuanchuanxing.v
    //对ptosda和out16hi联合测试,ptosda能否并转串,out16hi能否把串对应输出高
    
    `timescale 1ns/1ns
    
    
    module top_bingxingzhuanchuanxing(sclk,outhigh,rst_n,data,ack);
    
    input rst_n,sclk;
    input[3:0] data;
    output outhigh,ack;
    
    wire scl,sda;
    
    out16hi m1(.scl(scl),.sda(sda),.outhigh(outhigh));
    ptosda m2(.rst_n(rst_n),.sclk(sclk),.ack(ack),.scl(scl),.sda(sda),.data(data));
    
    endmodule
    
    

    通过quartus综合的RTL图

    测试信号,data输入2’b0000,每收到一个ack,data+1

    `timescale 1 ns/ 1 ns
    `define halfperiod 50
    module top_bingxingzhuanchuanxing_vlg_tst();
    
    reg [3:0] data;
    reg rst_n;
    reg sclk;
    // wires                                               
    wire ack;
    wire outhigh;
    
    // assign statements (if any)                          
    top_bingxingzhuanchuanxing i1 (
    // port map - connection between master ports and signals/registers   
    	.ack(ack),
    	.data(data),
    	.outhigh(outhigh),
    	.rst_n(rst_n),
    	.sclk(sclk)
    );
    initial                                                
    begin                                                  
    rst_n=0;
    #(`halfperiod*2) rst_n=1;                      
    end
    
    initial
    begin
    sclk=0;
    data=0;
    #(`halfperiod*1000) 
    $stop; 
    end                                                    
    
    always #(`halfperiod) sclk=~sclk;
    
    always@(posedge ack)                                                              
    begin                                                  
    #(`halfperiod/2) data=data+1;                                                                   
    end  
                                                      
    endmodule
    
    • 利用sclk产生scl,scl的周期为sclk的2倍
    • 利用link_sda控制串行总线的开关
    • 利用ack信号要求新的4位数据输入

    在这里插入图片描述

    • sclk下降沿控制主状态机state;
    • scl上升沿在start_flag为1控制mstate
    流程:当有ACK信号来临,data[3:0]存入data_buf,data_buf通过state由高位到低位写入sda_buf;sda_buf 在200ns开始 1600ns结束,以1400ns为一个周期传输的数据流:10_ _ _ _ 0111/10_ _ _ _ 第一个10产生start,第二个01产生stop;通过link_sda将sda_buf写入sda变为10_ _ _ _ 01;10产生startflag,01产生endflag,通过mstate将sda上_ _ _ _ 由高到低写入pdata[3:0],z在每个endflag出现将pdata[3:0]写入pdatabuf转为并行输出outhigh

    在这里插入图片描述

    现在只有一个问题,为什么我的outhigh[15:0]不能输出相应的16位?

    在这里插入图片描述

    !2019.1.1 解决了,top模块里没有准确定义端口 应该是output [15:0] outhigh

    在这里插入图片描述

    展开全文
  • 51实现74HC165并行转串行输出
  • vhdl并行转串行输出

    2009-06-18 18:13:16
    这是一个8位并行转串行,加奇偶校验位.最高平率没有测过
  • lcd1602液晶屏并行IO口转串行,结合74hc595实现三线控制液晶屏的目的,节省IO资源
  • 在我的机器上,以下程序打印:OptionalLong[134043]PARALLEL took 127869 msOptionalLong[134043]SERIAL took 60594 ms我不清楚为什么串行执行程序要比并行执行程序快。我把这两个程序-Xms2g -Xmx2g放在8gb相对安静...

    在我的机器上,以下程序打印:

    OptionalLong[134043]

    PARALLEL took 127869 ms

    OptionalLong[134043]

    SERIAL took 60594 ms

    我不清楚为什么串行执行程序要比并行执行程序快。我把这两个程序-Xms2g -Xmx2g放在8gb相对安静的盒子上。有人可以澄清发生了什么吗?

    import java.util.stream.LongStream;

    import java.util.stream.LongStream.Builder;

    public class Problem47 {

    public static void main(String[] args) {

    final long startTime = System.currentTimeMillis();

    System.out.println(LongStream.iterate(1, n -> n + 1).parallel().limit(1000000).filter(n -> fourConsecutives(n)).findFirst());

    final long endTime = System.currentTimeMillis();

    System.out.println(" PARALLEL took " +(endTime - startTime) + " ms");

    final long startTime2 = System.currentTimeMillis();

    System.out.println(LongStream.iterate(1, n -> n + 1).limit(1000000).filter(n -> fourConsecutives(n)).findFirst());

    final long endTime2 = System.currentTimeMillis();

    System.out.println(" SERIAL took " +(endTime2 - startTime2) + " ms");

    }

    static boolean fourConsecutives(final long n) {

    return distinctPrimeFactors(n).count() == 4 &&

    distinctPrimeFactors(n + 1).count() == 4 &&

    distinctPrimeFactors(n + 2).count() == 4 &&

    distinctPrimeFactors(n + 3).count() == 4;

    }

    static LongStream distinctPrimeFactors(long number) {

    final Builder builder = LongStream.builder();

    final long limit = number / 2;

    long n = number;

    for (long i = 2; i <= limit; i++) {

    while (n % i == 0) {

    builder.accept(i);

    n /= i;

    }

    }

    return builder.build().distinct();

    }

    }

    展开全文
  • //在这里,仅仅计算是并行任务,他自己的递归还是串行任务 } }); parallelRecursive(exec, n.getChildren(), results); } } public Collection getParallelResults(List> nodes) throws InterruptedException { ...

    package net.jcip.examples;

    import java.util.Collection;

    import java.util.List;

    import java.util.Queue;

    import java.util.concurrent.ConcurrentLinkedQueue;

    import java.util.concurrent.Executor;

    import java.util.concurrent.ExecutorService;

    import java.util.concurrent.Executors;

    import java.util.concurrent.TimeUnit;

    /**

    * TransformingSequential

    *

    * Transforming sequential execution into parallel execution

    *

    * @author Brian Goetz and Tim Peierls

    */

    public abstract class TransformingSequential {

    void processSequentially(List elements) {

    for (Element e : elements)

    process(e);

    }

    void processInParallel(Executor exec, List elements) {

    for (final Element e : elements)

    exec.execute(new Runnable() {

    public void run() {

    process(e);

    }

    });

    }

    public abstract void process(Element e);

    public void sequentialRecursive(List> nodes,

    Collection results) {

    for (Node n : nodes) {

    results.add(n.compute());

    sequentialRecursive(n.getChildren(), results);

    }

    }

    public void parallelRecursive(final Executor exec,

    List> nodes,

    final Collection results) {

    for (final Node n : nodes) {

    exec.execute(new Runnable() {

    public void run() {

    results.add(n.compute()); //在这里,仅仅计算是并行任务,他自己的递归还是串行任务

    }

    });

    parallelRecursive(exec, n.getChildren(), results);

    }

    }

    public Collection getParallelResults(List> nodes)

    throws InterruptedException {

    ExecutorService exec = Executors.newCachedThreadPool();

    Queue resultQueue = new ConcurrentLinkedQueue();

    parallelRecursive(exec, nodes, resultQueue);

    exec.shutdown();

    exec.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);

    return resultQueue;

    }

    interface Element {

    }

    interface Node {

    T compute();

    List> getChildren();

    }

    }

    展开全文
  • 我们都知道通信从大的方面有两种:串行并行串行的最大优点是占用总线少,但是传输速率低;并行恰恰相反,占用总线多,传输速率高。市面上有很多这样的芯片,有串入并出的(通俗讲就是 一个一个进,最后一块出来...

     我们都知道通信从大的方面有两种:串行和并行。串行的最大优点是占用总线少,但是传输速率低;并行恰恰相反,占用总线多,传输速率高。市面上有很多这样的芯片,有串入并出的(通俗讲就是 一个一个进,最后一块出来),有并入串出的(相对前者而言)。具体用哪种类型要根据我们得实际情况。比如利用单片机显示数码管单纯的显示一个数码管如果仅仅是为了显示 那么动用单片机一个端口(如P0或P1/P2/P3)那没有什么,当然这里我说的数码管是8段的(如果利用BCD类型 16进制数码管那么只需四个即可)就拿51类型的单片机来说,总共32个I/O口,一般如果不是做太大的工程是完全够用的,但有些时候你会恨单片机怎么不多长几条“腿”,怎么省还是不够用。这个时候就需要用到并转串或者串转并芯片来进行IO口的扩展,74HC165就是一种并行转串行的芯片。

    74HC165是一款高速CMOS器件,74HC165遵循JEDEC标准no.7A。74HC165引脚兼容低功耗肖特基TTL(LSTTL)系列。        74HC165芯片有8位移位寄存器(并行输入,互补串行输出)   

     74hc165特性

      8位同步并行输入

      异步串行输出

      兼容JEDEC标准no.7A

      ESD保护

          简要说明
          54/74165为8位移位寄存器,其主要电特性的典型值如下:

    74hc165基本参数

      电压:2.0~6.0V

      驱动电流:+/-5.2mA

      传输延迟:16ns@5V

      最高频率:56MHz@5V

      逻辑电平:CMOS

      工作温度:-40~+85℃

      封装:SO16,SSOP16,DIP16,TSSOP16

     

    逻辑电路图:

    真值表:

    时序图:

     

     

       74HC165芯片的芯片引脚图:


         引脚功能介绍
    1、CLK,CLK INH : 时钟输入端(上升沿有效)
    2、A-H :并行数据输入端
    3、SER :串行数据输入端,为串行输入端 、 将数据串行进入到寄存器中、在每一个时钟的上升沿向右移动一位,利用这种特性,只要把 QH输出连接到下一级的SER输入 既可实现并转串扩展
    4、QH : 输出端
    5、!QH :互补输出端
    6、SH/!LD:移位控制/置入控制(低电平有效), 为低电平时 并行数据进入移位寄存器中,为高电平时并行数据不能传进移位寄存器

    ①当输入端(SH/LD)为低:

      从D0到D7口输入的并行数据将被异步地读取进寄存器内,然后通过DS输出。

    ②当输入端(SH/LD)为高:

      数据将从DS(10引脚)输入端串行进入寄存器,在每个时钟脉冲的上升沿向右移动一位。利用这种特性,只要把Q7输出绑定到下一级的DS输入,即可实现并转串扩展。(在我们的开发板,DS端是悬空的),通过时钟管脚,上升沿有效,在每个时钟脉冲的上升沿向右移动一位(D0→D1→D2→D3→…→D7)一位一位将数据往外读出和移出。

       芯片工作方法:  

        其实看一个芯片是如何使用的,不只是看引脚功能,更重要的是要看时序图和真值表,从其中我们可以详细的了解到它是如何使用的,然后转化成程序代码即可。

            从上面我们的真值表和时序图中我们要特别注意几个端口的变化,真值表中SH/LD只有在高电平的时候方才有效;CLK,CLK INH只有当其中一个为低电平的时候,另一个时钟才能正确的输入,这是非常重要的(一般的我们在使用时,可以将其中的一个直接接地,另一个做时钟输入端口使用)。但是我们做事要细心,要一丝不苟,从时序图中我们看到SH/LD有一个负脉冲这是什么缘故呢?在程序设计中如果忽略了此处,那么注定结果是悲剧的。从SH/LD的全称是: SHIFT/LOAD 这说明它有两种功能( SHIFT英文意思是移位,LOAD是装载)  ,故美其名曰: 移位控制(高电平有效)/置入控制端口(低电平有效)。在单片机接收数据前,必须将该引脚拉低,目的是为了将并行数据A--H上得数据装载到内部寄存器中,这里体现的时LOAD功能;接下来在接收数据的过程中必须将该引脚拉高,目的是为了使寄存器中的数据可以移动,从而从QH或QN'中移入单片机。这里体现的是SHIFT功能。74hc165中最重要的一个引脚就是该引脚 至于说时钟电路就显得逊色多了。我们只需将单品机的某一个端口拉低或抬高即可,这样数据就一步一步的被接收了。请务必记得上升沿有效。

    接下来看下使用到的开发板相关模块的电路原理图:

     

         开发板上的165并行输入端口 连接的IO口是与8个独立键盘相互共用,可以做独立键盘的输入扩展、QH串行输出端口是连接了P17引脚 加了个短路冒不用的时候可以断开避免影响P17的电平。 每次按键按下时,相应的发光二极管就会被点亮。

      硬件连线图:

     

    示例程序如下:

       #include "reg52.h"
       #include "intrins.h"
     
    
       typedef unsigned char u8;
       typedef unsigned int u16;
    
       #define GPIO_LED P0
       
       sbit IN_PL = P1^6;  //SHIFT/!LOA引脚
       sbit IN_Data = P1^7; // QH数据输出引脚
       sbit SCK = P3^6;  //CLOCK引脚
    
       u8 Read74HC165()
       {
       u8 indata;
       u8 i;
    
       IN_PL = 0;//装载8位并行数据
       _nop_();
       IN_PL = 1;//转换8位并行数据为串行数据
       _nop_();
    
       indata = 0;
       for(i = 0; i < 8; i ++) //将8个串行数据存入数组indata中
       {
        indata = indata << 1;//开始时,indata数组先左移一位,以后每个循环左移一次
    	SCK = 0;//时钟低电平到来后,并行数据开始转换串行数据
    	_nop_();
        
    	indata |= IN_Data; //将转换完成的串行数据一位位存入数组
    	SCK = 1;  //时钟变为高电平,再次变为低电平时,开始传出下一位串行数据
       }
       return indata;
       }
    
    
      
    
    
       void main()
       {
       u8 h165Value;
       while(1)
       {
       h165Value = 	Read74HC165();
       if(h165Value != 0xff)
       {
        GPIO_LED = ~h165Value; //根据传出的串行数据来点亮相应的发光二极管
       }
       }
       }

     

    展开全文
  • //在这里,仅仅计算是并行任务,他自己的递归还是串行任务 } }); parallelRecursive(exec, n.getChildren(), results); } } public Collection getParallelResults(List> nodes) throws InterruptedException { ...
  • golang 并行转串行透明代理

    千次阅读 2013-01-25 10:39:08
    放在这里做个备份 package main import ( "fmt" "log" "net" ) const ( realServer = "127.0.0.1:9002" selfPort = 9010 ) type gameConn struct { ClientConn net.Conn PkgBuf [maxPkgSize]... Pk
  • 拿这样缓存就起不到作用了,大哥指导了一波,可以通过队列来把并发的请求串行的请求,虽然串行请求比并发的慢,但针对这个问题,牺牲并发来读取缓存,这样性能会更好。但这是一个未知长度的队列。思考良久终于...
  • MIPI(移动产业处理器接口): ...串行接口、并行接口、低压差分信号、差分布线: Altium差分布线和等长方法 差分信号走线原则 USB2.0接口差分信号线设计 ---------------------------------------------------...
  • 引: 设备之间的通信方式可以分成并行通信和串行通信两种。并行通信在老刘看来就是拉横排的走,串行通信就是规定路线排队走。一、并行通信接口 并行通讯和中央处理器的关系图,如下图所示: 我对图标解释一下: 1. ...
  • 串行/并行转换的具体过程如下:转换前,RC端加低电平,使1、2两片寄存器的内容清0,此时S1S0=11,寄存器执行并行输入工作方式。当第一个CP脉冲到来后,寄存器的输出状态Q0~Q7为01111111,与此同时S1S0变为01,转换...
  • 74LS194是一个4位双向移位寄存器,最高时钟脉冲为36MHZ74LS194引脚功能图1 74 LS194逻辑符号及引脚排列其中:D0~D1为并行输入端;Q0~Q3为并行输出端;SR--右移串引输入端;SL--左移串引输入端;S1、S0-操作模式控制端;...
  • (5) 保持:寄存器予置任意4位二进制数码abcd,令=1,S1=S0=0,加CP脉冲,...1.实现数据的串、并行转换(1)串行输入、并行输出按图8-3-3-3接线,进行右移串入、并出实验,串入数码自定;改接线路用左移方式实现并...
  • 方式0是外接串行移位寄存器方式。工作时,数据从RXD串行地输入/输出,TXD输出移位脉冲,使外部的移位寄存器移位。...实际应用在串行I/O口与并行I/O口之间的转换。2)方式1方式1是点对点的通信方式。8位异步串行通信口...
  • 点击蓝字关注我们一、串行通信基础知识1、异步通信和同步通信计算机的数据传输共有两种方式:并行数据传输和串行数据传输。并行数据传输的特点:是各数据位同时传输,传输速度快,效率高。但并行数据传输时有多少...
  • A Two-Speed, Radix-4, Serial–Parallel Multiplier摘要本文提出了一种用于加速数字滤波、CNN等应用的双速、基4、串行-并行乘法器,它是 Booth4乘法器的一种变体,加入了串行-并行修改。通过只加非零Booth编码来跳...
  • 并行数据转串行数据模块的设计

    千次阅读 2017-11-14 19:08:59
    通信协议 scl为不断输出的时钟信号,如果scl为高电平时...如果scl为高电平,sda由低变高,串行数据结束。sda信号的数据值必须在scl高电平之间稳定,在scl低电平时才可以改变,否则的话,立即就结束了串行数据的转换。
  • (B)2个 (C)3个 (D)4个 9、用MCS-51串行口扩展并行I/O口时,串行口工作方式应选择(A) (A)方式0 (B)方式1 (C)方式2 (D)方式3 10、某种存储器芯片是8KB*4/片,那么它的地址线根数是( C ) (A) 11根 (B)12根 (C)13根 (D)...
  • 串行通信方式是数据传输的一种方式。这种方式操作简单,连接少,传输距离远,因而在信息传送,尤其是在远距离的传送中得到了广泛的应用。目前常用的串行通信方式有RS -232 C,RS - 422 A,RS - 423 A及RS - 485 A等...
  • SPI(Serial Peripheral Bus)总线是Motorola公司提出的一个同步串行外设接口,容许CPU 与各种外围接口器件以串行方式进行通信、交换信息。本文简述了SPI总线的特点,介绍了其4条信号线,SPI串行总线接口的典型应用。重点...
  • 74HC165并行数据转串行数据

    千次阅读 2012-11-21 00:53:44
    74HC165 概述 (NXP founded by Philips) ...74HC165是8位并行读取或串行输入移位寄存器,可在末级得到互斥的串行输出(Q7和Q7),当并行读取(PL)输入为低时,从D0到D7口输入的并行数据将被异步地读取进寄存器内。
  • 串行转并行

    2014-04-01 11:48:00
    并行是指有几条命令,不管有没有收到应答,一律下去,处理器把所有的命令存储起来,然后一条条处理。 串行的缺点是用户等待时间长, 并行则可能导致某些命令会被丢掉,但用户的命令很快就发送到处理器了。 ...
  • 前言芯片间通信的时序模型系统同步源同步自同步参考文章前言高速信号设计涉及到方方面面的知识积累,也许你认为即使...本系列文章通过联系高速串行的相关知识,从基础到进阶,可以助你很好地理解高速串行设计中的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,314
精华内容 525
关键字:

并行转串行