1 概念
 
移位寄存器内的数据可以在移位脉冲（时钟信号）的作用下依次左移或右移。移位寄存器不仅可以存储数据，还可以用来实现数据的串并转换、分频，构成序列码发生器、序列码检测器，进行数值运算以及数据处理等，它也是数字系统中应用非常广泛的时序逻辑部件之一。
 
有四种不同类型的移位寄存器可用数据输入和输出设备的方式不同：
 
串行输入，串行输出
 
串行输入，并行输出
 
并行输入，串行输出
 
并行输入，并行输出
 
 右移位寄存器的特点是右边寄存器的次态等于左边触发器的现态。串行输出数据从触发器FD的QD端输出，并行数据从个触发器的QA~QD端输出，两种输出方式都属于同向输出。各触发器都采用同一时钟信号，所以它们工作在同步状态。如果将FD的输出端QD接到FA的输入端DI，则可以构成循环移位的右移位寄存器。
 
右移寄存器
 
并行输入串行输出
 
module right_shift_pin_sout(
    clk    ,
    rst_n  ,
    //其他信号,举例dout
    sout,
    pin    
    );

    //参数定义
    parameter      DATA_W =         4;
    parameter    CNT_W=2;

    //输入信号定义
    input               clk    ;
    input               rst_n  ;
    input [DATA_W-1: 0] pin    ;

    //输出信号定义
    output  sout   ;



    //中间信号定义
    reg[CNT_W-1: 0]     cnt    ;
    wire [DATA_W-1: 0]   D    ;

    reg [DATA_W-1: 0]   Q    ;
    //计数
    always@(posedge clk or negedge rst_n)begin
        if(rst_n==1'b0)begin
            cnt<=0;
        end
        else begin
            if(cnt==DATA_W-1)begin
                cnt<=0;
            end
            else begin
                cnt<=cnt+1;
            end
         end
    end
    //D
    assign D=(cnt==0)?pin:4'b0;
    assign sout=Q[3];
    //sout
    always  @(posedge clk or negedge rst_n)begin
        if(rst_n==1'b0)begin
            sout<=0;
        end
        else begin
            sout<=Q[3];
        end
    end
//Q
    always  @(posedge clk or negedge rst_n)begin
        if(rst_n==1'b0)begin
            Q<=0;
        end
        else if(cnt==0)begin
            Q<=D;
        end
        else begin
            Q[3:1]<=Q[2:0]; 
        end
    end



    endmodule


 
tb
 
 `timescale 1 ns/1 ns

module testbench_name();
parameter      DATA_W =         4;
parameter    CNT_W=2;
//时钟和复位
reg clk  ;
reg rst_n;
 
wire sout;  
reg[DATA_W-1: 0]  pin ; 
        //时钟周期，单位为ns，可在此修改时钟周期。
        parameter CYCLE    = 20;

        //复位时间，此时表示复位3个时钟周期的时间。
        parameter RST_TIME = 3 ;

        //待测试的模块例化
        right_shift_pin_sout 
        #(.DATA_W(DATA_W),.CNT_W(CNT_W))  uut(
       .clk    (   clk    ), 
       .rst_n  (   rst_n  ), 
       .sout   (  sout   ),
       .pin    (   pin    ) 
            )  ;  
        

            //生成本地时钟50M
            initial begin
                clk = 0;
                forever
                #(CYCLE/2)
                clk=~clk;
            end

            //产生复位信号
            initial begin
                rst_n = 1;
                #2;
                rst_n = 0;
                #(CYCLE*RST_TIME);
                rst_n = 1;
            end

            //输入信号pin赋值方式
            initial begin
                #1;
                //赋初值
                pin =4'b1111;
                #(9*CYCLE);
                pin=4'b1000;
                #(9*CYCLE);
                pin=4'b0010;
                #(9*CYCLE);
                pin=4'b0001;
                //开始赋值

            end

endmodule

 
 
利用状态机实现比较复杂的接口设计：
 
 
这是一个将并行数据转换为串行输出的变换器，利用双向总线输出。这是由EEPROM读写器的缩减得到的，首先对I2C总线特征介绍：
 
 
I2C总线（inter integrated circuit）双向二线制串行总线协议为：只有总线处于“非忙”状态时，数据传输才开始。在数据传输期间，只要时钟线为高电平，数据线都必须保持稳定，否则数据线上的任何变化都被当作“启动”或“停止”信号。
 
 
 
 
 
 
 
下面介绍A、B、C、D的工作状态：
 
 
（1）总线处于非忙状态（A段）：该段内的数据线（sda）和时钟线（scl）都保持高电平；
 
 
（2）启动数据传输（B段）：当时钟线（scl）为高电平时，数据线（sda）由高电平变为低电平的下降沿被认为是“启动”信号；
 
 
（3）停止数据传输（C段）：当时钟线（scl）为高电平时，数据线（sda）由低电平变为高电平的上升沿被认为是“停止”信号；
 
 
（4）数据有效（D段）：在出现“启动”信号之后，在时钟线（scl）为高电平时，数据线是稳定的，这是数据线上的数据就是要传送的数据，数据线上的数据改变必须在时钟线（scl）为低电平期间完成，每个数据占用一个时钟；
 
 
（5）应答信号：每个正在接受数据的EEPROM在接收到一个字节的数据后，通常需要发出一个应答信号；而每个正在发送数据的EEPROM在发出一个字节的数据后，通常需要接受一个应答信号；EEPROM读写控制器必须提供一个与这个应答信号相联系的二外的始终脉冲。
 
 
其控制字节一共有8位：1010xxxW/R 其中1010是I2C总线器件特征编码，xxx表示地址，W/R表示读写状态。
 
 
 
 
 
在实现并行输入串行输出时，需要两个状态机：
 
 
 
 
主状态机主要控制内部存储器和输入端的连接，以及给出应答信号；从状态机主要负责总线连接时，内部寄存器的最高位输出个移位；
 
 
 
 
 
 
 
状态机的源码如下：
 
 
 
  

   
  
 
  
  1 module parallel_to_serial(rst,clk,addr,data,sda,ack);
  2   input rst,clk;
  3   input [7:0]data,addr;
  4   
  5   inout sda;                     //data bus
  6   output ack;                    //ask for next address/data writting wo eeprm;
  7   reg link_write;                //whether connect to output
  8   reg [2:0]state;                //main status,
  9   reg [4:0]sh8out_state;         //serial output status
 10   reg [7:0]sh8out_buf;           //output data buffer
 11   reg finish_F;                  //whether finished an operation of main status
 12   reg ack;                       
 13   
 14   parameter  idle=0, addr_write=3'd1, data_write=3'd2, stop_ack=3'd4;          //main status code
 15   parameter  bit0=1, bit1=2, bit2=3, bit3=4, bit4=5, bit5=6, bit6=7, bit7=8;   //serial output status code
 16   
 17   assign sda=link_write?sh8out_buf[7]:1'bz;               //???????????
 18   
 19   always @(posedge clk)
 20   begin
 21   if(!rst)                       //reset
 22     begin
 23     ack<=0;
 24     link_write<=0;               //???????
 25     finish_F<=0;
 26     state<=idle;
 27     sh8out_state<=idle;
 28     sh8out_buf<=0;
 29     end
 30     else
 31       case(state)
 32         idle:begin
 33              link_write<=0;        //??????
 34              ack<=0;
 35              finish_F<=0;
 36              sh8out_buf<=addr;     //???????
 37              sh8out_state<=idle;
 38              state<=addr_write;    //???????
 39              end
 40         addr_write:begin
 41              if (finish_F==0) begin shift8_out;end    //???????
 42              else
 43                begin
 44                link_write<=0;
 45                ack<=0;
 46                finish_F<=0;
 47                sh8out_buf<=data;  //???????
 48                state<=data_write;
 49                sh8out_state<=idle;     
 50                end          
 51              end
 52         data_write:begin
 53              if (finish_F==0) begin shift8_out;end    //???????
 54              else
 55                begin
 56                link_write<=0;
 57                finish_F<=0;
 58                state<=stop_ack;
 59                ack<=1;            //????????
 60                end
 61              end 
 62         stop_ack:begin            //????
 63              ack<=0;
 64              state<=idle;
 65              end    
 66       endcase
 67     end
 68     
 69     task shift8_out;             //???????
 70     begin
 71     case(sh8out_state)
 72       idle:begin
 73            link_write<=1;        //?????????????????17?assign sda=link_write?sh8out_buf[7]:1'bz;  sda??????????sh8out_buf?????  
 74            sh8out_state<=bit7;
 75            end
 76       bit7:begin
 77            link_write<=1;       
 78            sh8out_buf=sh8out_buf<<1;   //?????data?????bit6
 79            sh8out_state<=bit6;
 80            end
 81       bit6:begin
 82            link_write<=1;       
 83            sh8out_buf=sh8out_buf<<1;  
 84            sh8out_state<=bit5;
 85            end
 86       bit5:begin
 87            link_write<=1;       
 88            sh8out_buf=sh8out_buf<<1;   
 89            sh8out_state<=bit4;
 90            end
 91       bit4:begin
 92            link_write<=1;       
 93            sh8out_buf=sh8out_buf<<1;   
 94            sh8out_state<=bit3;
 95            end
 96       bit3:begin
 97            link_write<=1;       
 98            sh8out_buf=sh8out_buf<<1;   
 99            sh8out_state<=bit2;
100            end
101       bit2:begin
102            link_write<=1;       
103            sh8out_buf=sh8out_buf<<1;   
104            sh8out_state<=bit1;
105            end
106       bit1:begin
107            link_write<=1;       
108            sh8out_buf=sh8out_buf<<1;   
109            sh8out_state<=bit0;
110            end
111       bit0:begin
112            link_write<=0;       
113            finish_F<=1;
114            end
115       endcase
116     end
117     endtask
118 endmodule
 
  

   
  
 
 
 
 
 
 
 
 测试程序：
 
 
 
 
 
 
  

   
  
 
  
 1 `timescale 1ns/1ns
 2 `define clk_period 50
 3 module parallel_to_serial_test;
 4   reg rst,clk;
 5   reg [7:0]data,addr;
 6   wire ack,sda;
 7   wire [2:0]state;                //main status,
 8   wire [4:0]sh8out_state; 
 9   
10   initial 
11   begin
12   clk=0;
13   rst=1;
14   data=0;
15   addr=0;
16   #(2*`clk_period) rst=0;
17   #(2*`clk_period) rst=1;
18   #(100*`clk_period) $stop;
19   end
20   
21   always #50 clk=~clk;
22   
23   
24 
25   always @(posedge clk)
26   begin data=data+1; addr=addr+1; end
27   
28   parallel_to_serial m(
29                        .rst(rst),
30                        .clk(clk),
31                        .addr(addr),
32                        .data(data),
33                        .sda(sda),
34                        .ack(ack)
35   );
36   
37   assign state=m.state;
38   assign sh8out_state=m.sh8out_state; 
39 endmodule
 
  

   
  
 
 
 
 
波形信号：
 
 
 
 
转载于:https://www.cnblogs.com/ZZiz/p/6752289.html

1 Verilog描述
 
module shift_p2s(
     input         clk,
     input [7:0]    din,
     input         load,
     output reg     q
 );
     reg [7:0] tmp;
     
     always@(posedge clk)begin
         if(load == 1'b1)
             tmp <= din;
         else begin
             q <= tmp[7];
             tmp <= {tmp[6:0],1'b0};
         end
     end
 
endmodule
 
2 RTL视图
 
 
3 功能仿真
 

并行转串行 串行转并行输出模块
 
夏宇闻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

 
 
测试信号，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