• SDRAM学习笔记（MT48LC16M16A2，w9812g6kh）

    一、基本知识

    SDRAM : 即同步动态随机存储器（Synchronous Dynamic Random Access Memory）, 同步是指其时钟频率与对应控制器（CPU/FPGA）的系统时钟频率相同，并且内部命令 的发送与数据传输都是以该时钟为基准；动态是指存储阵列需要不断的刷新来保证数据不丢失；随机指数据的读取和写入可以随机指定地址，而不是必须按照严格的线性次序变化。

    SDRAM 使用电容的电荷存储特性存储数据，而 SRAM使用CMOS晶体管存储数据，这决定了SDRAM的运行功耗要远远低于SRAM。由于使用晶体管存储数据，要能够正确的存储一位数据，需要最少6个晶体管。因此，从芯片面积上来说，单片SRAM芯片的容量不可能做到很高。

    通常情况下，SDRAM 是拥有四个 BANK 的动态刷新存储器，存储器工作在 3.3V 的电 压下，拥有一个同步接口，SDRAM 的所有信号都在时钟信号的上升沿被寄存。对于 SDRAM 的读写是以突发的方式进行的，对 sdram 的获取（读或者写）是从一个指定的地址开始，并按照编程好的数量(长度)的地址，以编程好的数据顺序读写数据。

    教程：

    SDR SDRAM: SDRAM设计教程之SDRAM结构深入剖析 altera （b站小梅哥教程）

    DDR:小梅哥Xilinx ACX720 FPGA开发板自学教程V2.2.4 xilinx

    DDR2:小梅哥DDR2简明教程V1.1  altera （b站小梅哥教程）

    DDR3：blibli-小梅哥Xilinx FPGA基础入门到项目应用培训教程 xilinx

    存取原理：先通过行地址打开行地址线，后通过列地址线打开列地址，便实现把电容与数据线连通，实现读/写操作。

       打开行地址需要tRCD时间，后才能打开列地址。tRCD可查手册，计算需要多少个对应频率的时钟的延迟，进行设计。

       打开列地址后，如果是读操作，需要CL（CAS READ LATENCY）个时钟周期才会出数据，如果是写操作，则数据需要同时送出，不用CL。

      不同型号的sdram：命令、时序参数有区别

    二、型号MT48LC16M16A2的sdram

    引脚：

    对于sdram的控制，通过CS_N、RAS_N、CAS_N、WE_N四个引脚来控制，故记这四个引脚组成的状态为控制命令cmd。

    通过这个表来设置cmd。

    1.时序设计

    控制sdram只需要结合时序图和命令表，通过线性序列机和状态机来设计就可以。

    1.上电初始化：通过计数器使sdram处于nop状态 不少于100us后，发出一个precharge命令，经过tRP时间（一直处于nop，下同），发出一个autorefresh命令，经过tRFC时间，再autorefresh一次，经过tRFC时间，便可发出load mode register命令配置模式寄存器。

    通常都需要通过配置模式寄存器来设计突发类型（Burst type:即有两种模式）；突发长度（burst length：即每次读或写的数据长度），输出周期间隔（CAS:即发出命令后经过几个周期开始出数据）具体模式如下图解释：

    模式寄存器设置规则如下：

    2.读/写命令：

           器件手册给出了包括读/写在内的多种命令的时序图，根据时序图进行设计即可，比如常用的：

    2.代码设计

           类似IIC协议和SPI协议，依旧是状态机加线性序列机的形式来是实现。最底层用状态机实现每种状态需要的操作，中间层用线性序列机实现一个完整的读/写/其他操作需要经过几种状态的跳转。故先定义状态和命令cmd。

           注意，设计时仍然需要注意时钟问题，给sdram的时钟是在上升沿读取数据，所以输出的数据在上升沿应该是稳定的，具体可以通过设计与读写两个时钟的移相来实现。

    1. module sdram_driver(
    2. 	input clk ,
    3. 	input rst_n ,
    4. 	
    5. 	input write_sig ,
    6. 	input read_sig ,
    7. 	input initial_sig ,
    8. 	input [12:0]write_addr ,
    9. 	input [1:0]write_bank ,
    10. 	input [12:0]read_addr ,
    11. 	input [1:0]read_bank ,
    12. 	
    13. 	output reg [3:0]cmd ,
    14. 	output reg [1:0]bank ,
    15. 	output reg [12:0]addr ,
    16. 	output reg [11:0]mode ,
    17. 	output reg cke_ctrl ,
    18. 	output reg [1:0]dqm_ctrl ,
    19. 	output reg initial_done ,
    20. 	output reg [15:0]read_data ,
    21. 	output reg trans_done ,
    22. 	inout [15:0]DQ 
    23. );
    24.  
    25. //状态参数
    26. localparam nop1 = 					4'b1000 ; //空闲态:禁止命令
    27. localparam nop2 = 					4'b0111 ; //空闲态：空命令
    28. localparam active = 					4'b0011 ; //选bank与行
    29. localparam read = 					4'b0101 ; //选bank和列，启动突发读 ，最后一位为屏蔽位
    30. localparam write = 					4'b0100 ; //选bank和列，启动突发读 ，最后一位为屏蔽位
    31. localparam burst_terminate = 		4'b0110 ; //突发中止
    32. localparam precharge = 				4'b0010 ; //关闭行，预充电
    33. localparam refresh = 				4'b0001 ; //刷新
    34. localparam load_mode_register =	4'b0000 ; //a0 - a11 tmrd
    37. // mode register
    38. localparam M9_BL_mode = 1'b0 ; //length
    39. localparam M9_SL_mode = 1'b1 ; //single
    40. localparam M87_SO_mode = 2'b00 ; 
    41. localparam M654_CAS_2 = 3'b010 ;//CL
    42. localparam M654_CAS_3 = 3'b011 ;//CL
    43. localparam M3_seq = 1'b0 ;
    44. localparam M3_intl = 1'b1 ;
    45. localparam M210_BL_1 = 3'b000 ;//be able to replace single read/write (M9)
    46. localparam M210_BL_2 = 3'b001 ;
    47. localparam M210_BL_4 = 3'b010 ;
    48. localparam M210_BL_8 = 3'b011 ;
    49. localparam M210_BL_full = 3'b111 ;
    51. // read with auto precharge ?
    52. localparam auto_precharge = 1 ;
    53. wire rd_with_auto , wr_with_auto ;
    54. assign rd_with_auto = auto_precharge ;
    55. assign wr_with_auto = auto_precharge ;
    57. reg [15:0]cmd_cnt ;
    58. always@( posedge clk or negedge rst_n )	
    59. if(!rst_n)
    60. 	begin
    61. 		cmd_cnt 		<= 0 ;
    62. 		cmd 			<= nop2 ;
    63. 		bank			<= 0 ;
    64. 		addr			<= 0 ;
    65. 		mode			<= 0 ;
    66. 		cke_ctrl		<= 0 ;
    67. 		dqm_ctrl		<= 0 ;	
    68. 		trans_done 	<= 0 ;
    69. 		initial_done<= 0 ;
    70. 		read_data   <= 0 ;
    71. 	end
    72. else if(initial_sig)
    73. 	begin
    74. 		cmd_cnt <= cmd_cnt + 1 ;
    75. 		case(cmd_cnt)
    76. 			1:cmd <= nop2 ;//delay > 100 us
    77. 			10005: begin cke_ctrl <= 1 ;  end
    78. 			10010: begin cmd <= precharge ; addr[10] = 1 ;  end //precharge all banks : tRP >= 20ns (2T)
    79. 			10011: begin cmd <= nop2 ; end
    80. 			10015: begin cmd <= refresh ; cke_ctrl <= 1 ; end //auto refresh : >= 2T(RFC) ; T(RFC) >= 66ns    1T(auto)(256Mb) = 8192
    81. 			10016: begin cmd <= nop2 ; end
    82. 			10026: begin cmd <= refresh ; cke_ctrl <= 1 ; end // 
    83. 			10027: begin cmd <= nop2 ; end						  // 
    84. 			10040: begin cmd <= load_mode_register ; bank <= 0 ; mode <= { 2'b00 , M9_BL_mode , M87_SO_mode , M654_CAS_3 , M3_seq , M210_BL_4 } ;end //set mode :t(mrd) = 2t(ck) = 2*6 = 12 ns
    85. 			10041: begin cmd <= nop2 ; end
    86. 			10045: begin initial_done <= 1 ;  end
    87. 			10046: begin cmd_cnt <= 0 ; end
    88. 			default:cmd <= nop2 ;	
    89. 		endcase
    90. 	end
    91. else if(initial_done)
    92. 	begin
    93. 		if(write_sig)
    94. 			begin
    95. 				if(wr_with_auto)
    96. 					begin
    97. 						cmd_cnt <= cmd_cnt + 1 ;
    98. 						case(cmd_cnt)
    99. 							1:begin cmd <= active ; bank <= write_bank ; addr <= write_addr ; end
    100. 							4:begin cmd <= write ; bank <= write_bank ; addr <= {write_addr[12:11],1'b1,write_addr[9:0]}; end
    101. 							10:begin trans_done <= 1 ; cmd_cnt <= 0 ;end
    102. 							default:cmd<=nop2;
    103. 						endcase
    104. 					end
    105. 				else if(~wr_with_auto)
    106. 					begin
    107. 						cmd_cnt <= cmd_cnt + 1 ;
    108. 						case(cmd_cnt)
    109. 							1:begin cmd <= active ; bank <= write_bank ; addr <= write_addr ; end
    110. 							4:begin cmd <= write ; bank <= write_bank ; addr <= {write_addr[12:11],1'b1,write_addr[9:0]}; end
    111. 							9:begin cmd <= precharge ; addr[10] = 1 ;end
    112. 							12:begin trans_done <= 1 ; cmd_cnt <= 0 ;end
    113. 							default:cmd<=nop2;
    114. 						endcase
    115. 					end		
    116. 			end
    117. 		else if(read_sig)
    118. 			begin
    119. 				if( rd_with_auto )
    120. 					begin
    121. 						cmd_cnt <= cmd_cnt + 1 ;
    122. 						case(cmd_cnt)
    123. 							1:begin cmd <= active ; bank <= read_bank ; addr <= read_addr ;  end
    124. 							4:begin cmd <= read ; bank <= read_bank ; addr <= {read_addr[12:11],1'b1,read_addr[9:0]}; end //addr10 control auto charge
    125. 							9:begin read_data <= DQ ; end
    126. 							10:begin read_data <= DQ ; end
    127. 							11:begin read_data <= DQ ; end
    128. 							12:begin read_data <= DQ ; end
    129. 							13:begin trans_done<= 1 ; cmd_cnt <= 0 ; end
    130. 							default:begin cmd <= nop2 ;read_data <= DQ ;end
    131. 						endcase
    132. 					end
    133. 				else if( ~rd_with_auto )
    134. 					begin
    135. 					cmd_cnt <= cmd_cnt + 1 ;
    136. 						case(cmd_cnt)
    137. 							1:begin cmd <= active ; bank <= read_bank ; addr <= read_addr ;  end
    138. 							4:begin cmd <= read ; bank <= read_bank ; addr <= {read_addr[12:11],1'b0,read_addr[9:0]}; end //addr10: control auto charge
    139. 							9:begin read_data <= DQ ; end
    140. 							10:begin read_data <= DQ ; end
    141. 							11:begin read_data <= DQ ; cmd <= precharge ; addr[10] = 1 ; end //precharge
    142. 							12:begin read_data <= DQ ;  end
    143. 							14:begin trans_done<= 1 ; cmd_cnt <= 0 ; end
    144. 							default:cmd <= nop2 ;
    145. 						endcase
    146. 					end
    147. 			end
    148. 		else
    149. 			begin
    150. 				cmd <= nop2 ;
    151. 				cmd_cnt <= 0 ;
    152. 				trans_done<= 0 ;
    153. 			end
    154. 	end
    155. else
    156. 	begin
    157. 		cmd_cnt <= 0 ;
    158. 	end
    159.  
    160. 	
    161.  
    162.  
    163. endmodule
    1. //-75 100MHz CL = 2 setup = 1.5 hold = 0.8 上升沿读写数据//
    2. // 100MHz : T = 10ns //
    3. // tRP >= 20ns ； T(RFC) >= 66ns ; t(mrd) = 12 ns
    4. // 这里实现 普通的写和读 ；有特殊要求的根据手册进行cmd修改即可
    5.  
    6. module sdram_ctrl(
    7. 	input fpga_clk ,
    8. 	input rst_n ,
    9. 	
    10. 	input write_sig ,
    11. 	input read_sig ,
    12. 	input [12:0]write_addr ,
    13. 	input [1:0]write_bank ,
    14. 	input [15:0]write_data ,
    15. 	input [12:0]read_addr ,
    16. 	input [1:0]read_bank , 
    17. 	
    18. 	output trans_done ,
    19. 	output [15:0]read_data ,
    20. 	output sclk ,
    21. 	output  CKE ,
    22. 	output  CS_N ,
    23. 	output  RAS_N ,
    24. 	output  CAS_N ,
    25. 	output  WE_N ,
    26. 	output  [1:0]DQM ,//高电平时屏蔽
    27. 	output  [12:0]SA ,//A12 - A0
    28. 	output  [1:0]BA ,
    29. 	inout [15:0]DQ
    30. );
    31.  
    32. wire clk_100m;
    33. wire clk_100m_90shift ;
    34. pll pll_inst(
    35. 	.inclk0(fpga_clk),
    36. 	.c0(clk_100m),
    37. 	.c1(clk_100m_90shift)
    38. 	);
    39. assign sclk = clk_100m_90shift ;
    40.  
    41. //read / write signal catch
    42. reg write_sig_reg ;
    43. always@(posedge fpga_clk or negedge rst_n)
    44. if(!rst_n)
    45. 	write_sig_reg <= 0 ;
    46. else
    47. 	write_sig_reg <= write_sig ;
    48.  
    49. reg read_sig_reg ;
    50. always@(posedge fpga_clk or negedge rst_n)
    51. if(!rst_n)
    52. 	read_sig_reg <= 0 ;
    53. else 
    54. 	read_sig_reg <= read_sig ;
    55. 	
    56. reg write_signal ;
    57. reg read_signal ;
    58. always@(posedge fpga_clk or negedge rst_n)
    59. if(!rst_n)
    60. 	write_signal <= 0 ;
    61. else if( write_sig & (!write_sig_reg ) )
    62. 	write_signal <= 1 ;
    63. else if(trans_done)
    64. 	write_signal <= 0 ;
    65. 	
    66. always@(posedge fpga_clk or negedge rst_n)
    67. if(!rst_n)
    68. 	read_signal <= 0 ;
    69. else if( read_sig & (!read_sig_reg ) )
    70. 	read_signal <= 1 ;
    71. else if(trans_done)
    72. 	read_signal <= 0 ;	
    73.  
    74. // initial sdram
    75. reg [5:0]initial_cnt ;
    76. wire initial_done ;
    77. always@(posedge clk_100m or negedge rst_n)
    78. if(!rst_n)
    79. 	initial_cnt <= 0 ;
    80. else if( initial_cnt < 50 )
    81. 	initial_cnt <= initial_cnt + 1 ;
    82. else
    83. 	initial_cnt <= initial_cnt ;
    84.  
    85. reg initial_sig ;
    86. always@(posedge clk_100m or negedge rst_n)	
    87. if(!rst_n)
    88. 	initial_sig <= 0 ;
    89. else if(initial_cnt == 48)
    90. 	initial_sig <= 1 ;
    91. else if(initial_done)
    92. 	initial_sig <= 0 ;
    93. 	
    94. 	
    95. wire [3:0]cmd ;
    96. wire [1:0]bank ;
    97. wire [12:0]addr ;
    98. wire [11:0]mode ;
    99. wire cke_ctrl ;
    100. wire [1:0]dqm_ctrl ;
    101. sdram_driver sdram_driver_inst(
    102. 	.clk(clk_100m) ,
    103. 	.rst_n(rst_n) ,
    104. 	
    105. 	.write_sig(write_signal) ,
    106. 	.read_sig(read_signal) ,
    107. 	.initial_sig(initial_sig),
    108. 	.write_addr(write_addr) ,
    109. 	.write_bank(write_bank) ,
    110. 	.read_addr(read_addr) ,
    111. 	.read_bank(read_bank) ,
    112. 	
    113. 	.cmd(cmd) ,
    114. 	.bank(bank) ,
    115. 	.addr(addr) ,
    116. 	.mode(mode) ,
    117. 	.cke_ctrl(cke_ctrl) ,
    118. 	.dqm_ctrl(dqm_ctrl) ,
    119. 	.initial_done(initial_done),
    120. 	.read_data(read_data) ,
    121. 	.trans_done(trans_done) ,
    122. 	.DQ(DQ)
    123. );	
    124. 	
    125. sdram_underlying_logic sdram_underlying_logic_inst(
    126. 	.clk(clk_100m) ,
    127. 	.rst_n(rst_n) ,
    128. 	
    129. 	.mode(mode),//A11 -A0
    130. 	.cmd(cmd) ,
    131. 	.cke_ctrl(cke_ctrl) ,
    132. 	.bank(bank) ,
    133. 	.addr(addr) ,
    134. 	.write_data(write_data) ,
    135. 	.dqm_ctrl(dqm_ctrl),
    136. 	
    137.  
    138. 	.CKE(CKE) ,
    139. 	.CS_N(CS_N) ,
    140. 	.RAS_N(RAS_N) ,
    141. 	.CAS_N(CAS_N) ,
    142. 	.WE_N(WE_N) ,
    143. 	.DQM(DQM) ,//高电平时屏蔽
    144. 	.SA(SA) ,//A12 - A0
    145. 	.BA(BA) ,
    146. 	.DQ(DQ)
    147. );
    148.  
    149. 	
    150. endmodule
    1. module sdram_underlying_logic(
    2. 	input clk ,
    3. 	input rst_n ,
    4. 	
    5. 	input [11:0]mode,//A11 -A0
    6. 	input [3:0]cmd ,
    7. 	input cke_ctrl ,
    8. 	input [1:0]bank ,
    9. 	input [12:0]addr ,
    10. 	input [15:0]write_data ,
    11. 	input [1:0]dqm_ctrl,
    12. 	
    13. 	output reg CKE ,
    14. 	output reg CS_N ,
    15. 	output reg RAS_N ,
    16. 	output reg CAS_N ,
    17. 	output reg WE_N ,
    18. 	output reg[1:0]DQM ,//高电平时屏蔽
    19. 	output reg[12:0]SA ,//A12 - A0
    20. 	output reg [1:0]BA ,
    21. 	inout [15:0]DQ
    22. );
    23.  
    24. reg DQ_ctrl ;
    25. reg [15:0]DQ_out ;
    26. assign DQ = (DQ_ctrl ? DQ_out : 16'hzzzz) ;///
    28. //状态参数
    29. localparam nop1 = 					10'b1000000000 ; //空闲态:禁止命令
    30. localparam nop2 = 					10'b0100000000 ; //空闲态：空命令
    31. localparam active = 					10'b0010000000 ; //选bank与行
    32. localparam read = 					10'b0001000000 ; //选bank和列，启动突发读 ，最后一位为屏蔽位
    33. localparam write = 					10'b0000100000 ; //选bank和列，启动突发读 ，最后一位为屏蔽位
    34. localparam burst_terminate = 		10'b0000010000 ; //突发中止
    35. localparam precharge = 				10'b0000001000 ; //关闭行，预充电
    36. localparam auto_refresh = 			10'b0000000100 ; //自动刷新
    37. localparam self_refresh = 			10'b0000000010 ; //自刷新
    38. localparam load_mode_register =	10'b0000000001 ; //加载模式寄存器
    40. reg [9:0]state ;//状态机
    41. always@(posedge clk or negedge rst_n)
    42. if(!rst_n)
    43. 	state <= nop2 ;
    44. else if( cmd[3] )
    45. 	state <= nop1 ;
    46. else if( cmd == 4'b0111 )
    47. 	state <= nop2 ;
    48. else if( cmd == 4'b0011 )
    49. 	state <= active ;
    50. else if( cmd == 4'b0101 )
    51. 	state <= read ;
    52. else if( cmd == 4'b0100 )
    53. 	state <= write ;
    54. else if( cmd == 4'b0110 )
    55. 	state <= burst_terminate ;
    56. else if( cmd == 4'b0010 )
    57. 	state <= precharge ;
    58. else if( cmd == 4'b0001 )
    59. 	begin
    60. 		if(cke_ctrl)
    61. 			state <= auto_refresh ;
    62. 		else
    63. 			state <= self_refresh ;
    64. 	end
    65. else if( cmd == 4'b0000 )
    66. 	state <= load_mode_register ;
    67. 	
    68. 	
    69. reg [7:0]state_cnt ;
    70. always@(posedge clk or negedge rst_n)
    71. if(!rst_n)
    72. 	begin
    73. 		state_cnt <= 0 ;
    74. 		CKE <= 1 ;
    75. 		CS_N <= 1 ;
    76. 		RAS_N <= 1 ;
    77. 		CAS_N <= 1 ;
    78. 		WE_N <= 1 ;
    79. 		BA <= 0 ;
    80. 		SA <= 0 ;
    81. 		DQM <= 0 ;
    82. 		DQ_ctrl <= 1 ;//获取数据线的控制权
    83. 		DQ_out <= 0 ;
    84. 	end
    85. else 
    86. 	begin
    87. 		case(state)
    88. 			nop1 : begin CS_N <= 1 ;  end
    89. 			nop2 : begin CS_N <= 0 ; RAS_N <= 1 ; CAS_N <= 1 ; WE_N <= 1 ; DQ_out <= write_data ;end
    90. 			active: begin CS_N <= 0 ; RAS_N <= 0 ; CAS_N <= 1 ; WE_N <= 1 ; SA <= addr ; BA <= bank ;end		
    91. 			read : begin CS_N <= 0 ; RAS_N <= 1 ; CAS_N <= 0 ; WE_N <= 1 ; SA <= addr ; BA <= bank ; DQM <= dqm_ctrl ; DQ_ctrl <= 0 ; end
    92. 			write : begin CS_N <= 0 ; RAS_N <= 1 ; CAS_N <= 0 ; WE_N <= 0 ; SA <= addr ; BA <= bank ; DQM <= dqm_ctrl ; DQ_out <= write_data ;end
    93. 			precharge : begin CS_N <= 0 ; RAS_N <= 0 ; CAS_N <= 1 ; WE_N <= 0 ; SA[10] <= addr[10] ; BA <= bank ;DQ_ctrl <= 1 ; end//sa[10] = 1 :对所有bank预充电 ; sa[10] = 0 : 对ba1 ba0 选中的bank预充电
    94. 			auto_refresh : begin CS_N <= 0 ; RAS_N <= 0 ; CAS_N <= 0 ; WE_N <= 1 ; CKE <= 1 ; end
    95. 			self_refresh : begin CS_N <= 0 ; RAS_N <= 0 ; CAS_N <= 0 ; WE_N <= 1 ; CKE <= 0 ; end
    96. 			load_mode_register : begin CS_N <= 0 ; RAS_N <= 0 ; CAS_N <= 0 ; WE_N <= 0 ; SA <= { 1'b0 , mode } ; end
    97. 			default:;
    98. 		endcase
    99. 	end
    100.  
    101.  
    102.  
    103.  
    104. endmodule
    1. `timescale 1ns/1ns 
    2. module sdram_ctrl_tb();
    3.  
    4. reg fpga_clk ;
    5. reg rst_n ;
    6. reg write_sig ;
    7. reg read_sig ;
    8. reg [12:0]write_addr ;
    9. reg [1:0] write_bank ;
    10. reg [15:0]write_data ;
    11. reg [12:0]read_addr ;
    12. reg [1:0] read_bank ; 
    13.  
    14. wire sclk ;
    15. wire CKE ;
    16. wire CS_N ;
    17. wire RAS_N ;
    18. wire CAS_N ;
    19. wire WE_N ;
    20. wire [1:0]DQM ;//高电平时屏蔽
    21. wire [12:0]SA ;//A12 - A0
    22. wire [1:0]BA ;
    23. wire [15:0]DQ;
    24. wire [15:0]read_data;
    25. wire trans_done;
    26. wire [3:0]cmd_state ;
    27. sdram_ctrl sdram_ctrl_inst(
    28. 	.fpga_clk(fpga_clk) ,
    29. 	.rst_n(rst_n) ,
    30. 	
    31. 	.write_sig(write_sig) ,
    32. 	.read_sig(read_sig) ,
    33. 	.write_addr(write_addr) ,
    34. 	.write_bank(write_bank) ,
    35. 	.write_data(write_data) ,
    36. 	.read_addr(read_addr) ,
    37. 	.read_bank(read_bank) , 
    38. 	
    39. 	.trans_done(trans_done) ,
    40. 	.read_data(read_data) ,
    41. 	.sclk(sclk) ,
    42. 	.CKE(CKE) ,
    43. 	.CS_N(CS_N) ,
    44. 	.RAS_N(RAS_N) ,
    45. 	.CAS_N(CAS_N) ,
    46. 	.WE_N(WE_N) ,
    47. 	.DQM(DQM) ,
    48. 	.SA(SA) ,
    49. 	.BA(BA) ,
    50. 	.DQ(DQ)
    51. );
    52.  
    53. mt48lc16m16a2 mt48lc16m16a2_inst(
    54. 	.Dq(DQ),
    55. 	.Addr(SA),
    56. 	.Ba(BA),
    57. 	.Clk(sclk),
    58. 	.Cke(CKE),
    59. 	.Cs_n(CS_N),
    60. 	.Ras_n(RAS_N),
    61. 	.Cas_n(CAS_N),
    62. 	.We_n(WE_N),
    63. 	.Dqm(DQM)
    64. );
    65.  
    66. pulldown(DQ[15]);
    67. pulldown(DQ[14]);
    68. pulldown(DQ[13]);
    69. pulldown(DQ[12]);
    70. pulldown(DQ[11]);
    71. pulldown(DQ[10]);
    72. pulldown(DQ[9]);
    73. pulldown(DQ[8]);
    74. pulldown(DQ[7]);
    75. pulldown(DQ[6]);
    76. pulldown(DQ[5]);
    77. pulldown(DQ[4]);
    78. pulldown(DQ[3]);
    79. pulldown(DQ[2]);
    80. pulldown(DQ[1]);
    81. pulldown(DQ[0]);
    82. assign cmd_state = {CS_N,RAS_N,CAS_N,WE_N} ;
    83.  
    84. initial fpga_clk = 0 ;
    85. always #10 fpga_clk = !fpga_clk ;
    86. initial begin
    87. 	rst_n = 0 ;
    88. 	write_sig = 0 ;
    89. 	read_sig = 0 ;
    90. 	write_addr = 0 ;
    91. 	write_bank = 0 ;
    92. 	write_data = 0 ;
    93. 	read_addr  = 0 ;
    94. 	read_bank  = 0 ;
    95. 	#201 ;
    96. 	rst_n = 1 ;
    97. 	#102000;
    98. 	#200 ;
    99. 	write_addr = 13'd2 ;
    100. 	write_bank = 2'd1;
    101. 	write_data = 16'h5a5a ;
    102. 	write_sig = 1;
    103. 	#70;
    104. 	write_data = 16'h5a5b ;
    105. 	#10;
    106. 	write_data = 16'h5a5c ;
    107. 	#10;
    108. 	write_data = 16'h5a5d ;
    109. 	#200 ;
    110. 	write_sig = 0;
    111. 	#5000;
    112. 	read_addr = 13'd2 ;
    113. 	read_bank = 2'd1;
    114. 	read_sig = 1 ;
    115. 	#200 ;
    116. 	read_sig = 0 ;
    117. 	#10000;
    118. 	$stop ;
    119. 	
    120. end
    121.  
    122.  
    123.  
    124. endmodule

    3.仿真

    1.上点初始化

    2.写数据（带自动预充电）

    3.读数据（带自动预充电）

    读出来的数据，DQ的最后一个数据只有7.6ns，不知道是什么原因。

    但是移相适当仍然可以读取。

    接下来对AC609板载的SDRAM：w9812g6kh进行设计，并进行板级验证。

    三、型号w9812g6kh的sdram

            通过查看w9812g6kh芯片的器件手册，发现它的读/写/充电/等命令设置均与MT48LC16M16A2的规则相同，只是这两个芯片容量不一样，w9812g6kh为128M，只有12个地址引脚，而MT48LC16M16A2为256M，有13个地址引脚。所以程序上只需要修改地址引脚即可。

            为了上板验证程序的可行性，仿照IIC协议的测试方法，用uart-sdram联合测试，通过上位机发送读写数据来控制FPGA对w9812g6kh进行读写，此处仍需要建立通信帧，规则与IIC协议笔记差不多，如下：

    //***************** ******************//
    //        串口波特率：115200           //
    //            通信帧格式：             //
    //      AA AA HA LA RW DA DA 55      //
    //    其中，AA AA 为帧头；55为帧尾；   //
    //   HA、LA为存储器地址  //
    //   RW为读写控制，读：5A ;写：A5      //
    //   DA为要写入的数据，读的时候可为任意值 //
    // ********************************* //

    sdram的控制程序设置为BL=1的模式，（使用其他BL只需修改对应的线性序列机和模式寄存器即可）

    1.代码设计

    1. //***************** ******************//
    2. //        串口波特率：115200           //
    3. //            通信帧格式：             //
    4. //      AA AA HA LA RW DA DA 55      //
    5. //    其中，AA AA 为帧头；55为帧尾；   //
    6. //   HA、LA为存储器地址  //
    7. //   RW为读写控制，读：5A ;写：A5      //
    8. //   DA为要写入的数据，读的时候可为任意值 //
    9. // ********************************* //
    10.  
    11.  
    12. module uart_sdram(
    13. 	input fpga_clk ,
    14. 	input rst_n ,
    15. 	
    16. 	input uart_rx ,
    17. 	output rx_done ,
    18. 	output uart_tx ,
    19. 	
    20. 	output sclk ,
    21. 	output  CKE ,
    22. 	output  CS_N ,
    23. 	output  RAS_N ,
    24. 	output  CAS_N ,
    25. 	output  WE_N ,
    26. 	output  [1:0]DQM ,//高电平时屏蔽
    27. 	output  [11:0]SA ,//A12 - A0
    28. 	output  [1:0]BA ,
    29. 	inout [15:0]DQ
    30. 	
    31. );
    32.  
    33.  
    34. //receive uart data
    35. //wire rx_done ;
    36. wire [7:0]rx_data ;
    37. uart_receive uart_rec_inst(
    38.     .clk(fpga_clk) ,
    39.     .reset(rst_n) ,
    40.     .baud_rate('d5) ,//115200
    41.     .uart_rx(uart_rx), 
    42.     .data(rx_data) ,
    43.     .rx_done(rx_done)   
    44.     );
    46. //Shift register
    47. reg [7:0]rec_shift_reg[7:0] ;
    48. reg rw_flag ;
    49. wire trans_done ;
    50. always@(posedge fpga_clk or negedge rst_n)
    51. if(!rst_n)
    52. 	begin
    53. 		rec_shift_reg[0] <= 0 ;
    54. 		rec_shift_reg[1] <= 0 ;
    55. 		rec_shift_reg[2] <= 0 ;
    56. 		rec_shift_reg[3] <= 0 ;
    57. 		rec_shift_reg[4] <= 0 ;
    58. 		rec_shift_reg[5] <= 0 ;
    59. 		rec_shift_reg[6] <= 0 ;
    60. 		rec_shift_reg[7] <= 0 ;
    61. 		rw_flag <= 0 ;
    62. 	end
    63. else if(rx_done)
    64. 	begin
    65. 		rec_shift_reg[0] <= rec_shift_reg[1] ;
    66.  		rec_shift_reg[1] <= rec_shift_reg[2] ;
    67. 		rec_shift_reg[2] <= rec_shift_reg[3] ; 
    68. 		rec_shift_reg[3] <= rec_shift_reg[4] ; 
    69. 		rec_shift_reg[4] <= rec_shift_reg[5] ; 
    70. 		rec_shift_reg[5] <= rec_shift_reg[6] ; 
    71. 		rec_shift_reg[6] <= rec_shift_reg[7] ; 
    72. 		rec_shift_reg[7] <= rx_data ; 
    73. 		rw_flag <= 1 ;
    74. 	end
    75. else if(trans_done)
    76. 		rw_flag <= 0 ;
    78. reg [15:0]write_addr ;
    79. reg [15:0]read_addr ;
    80. reg [15:0]write_data ;
    81. reg [15:0]read_data ;
    82. wire [15:0]rd_data ;
    83. reg write_pulse ;
    84. reg read_pulse ;
    86. sdram_ctrl sdram_ctrl_inst(
    87. 	.fpga_clk(fpga_clk) ,
    88. 	.rst_n(rst_n) ,
    89. 	
    90. 	.write_sig(write_pulse) ,
    91. 	.read_sig(read_pulse) ,
    92. 	.write_addr(write_addr[11:0]) ,
    93. 	.write_bank(write_addr[15:14]) ,
    94. 	.write_data(write_data) ,
    95. 	.read_addr(read_addr[11:0]) ,
    96. 	.read_bank(read_addr[15:14]) , 
    97. 	
    98. 	.trans_done(trans_done) ,
    99. 	.read_data(rd_data) ,
    100. 	.sclk(sclk) ,
    101. 	.CKE(CKE) ,
    102. 	.CS_N(CS_N) ,
    103. 	.RAS_N(RAS_N) ,
    104. 	.CAS_N(CAS_N) ,
    105. 	.WE_N(WE_N) ,
    106. 	.DQM(DQM) ,//高电平时屏蔽
    107. 	.SA(SA) ,//A12 - A0
    108. 	.BA(BA) ,
    109. 	.DQ(DQ)
    110. );
    113. wire uart_send_done ;
    114. reg uart_send_en ;
    115. uart_send uart_send(  
    116.     .clk(fpga_clk),
    117.     .reset(rst_n),
    118.     .data(read_data[7:0]),
    119.     .send_en(uart_send_en),
    120.     .baud_rate(5),//115200
    121.     .uart_tx(uart_tx),
    122.     .tx_done(uart_send_done)
    123. );
    125. //Parsing frames
    126. localparam frames_header = 8'hAA ;
    127. localparam frames_tail   = 8'h55 ;
    128. localparam read_option   = 8'h5A ;
    129. localparam write_option  = 8'hA5 ;
    130. reg [15:0]wr_cnt ;
    131. reg [15:0]rd_cnt ;
    132. always@(posedge fpga_clk or negedge rst_n)
    133. if(!rst_n)
    134. 	begin
    135. 		write_addr <= 0 ;
    136. 		read_addr <= 0 ;
    137. 		write_data <= 0;
    138. 		read_data <= 0 ;
    139. 		write_pulse <= 0 ;
    140. 		read_pulse <= 0 ;
    141. 		wr_cnt <= 0 ;
    142. 		rd_cnt <= 0 ;
    143. 	end
    144. 	
    145. else if( rw_flag )
    146. 	begin
    147. 		if ( (rec_shift_reg[0] == frames_header) && (rec_shift_reg[1] == frames_header) && (rec_shift_reg[7] == frames_tail) )
    148. 			begin
    149. 				if(rec_shift_reg[4] == write_option )
    150. 					begin
    151. 						write_addr <= { rec_shift_reg[2] , rec_shift_reg[3] } ;
    152. 						write_data <= {rec_shift_reg[5],rec_shift_reg[6]} ;
    153. 						wr_cnt <= wr_cnt + 1 ;
    154. 						//write signal
    155. 						if( wr_cnt < 3 )
    156. 							write_pulse <= 1 ;
    157. 						else if(trans_done)
    158. 							begin
    159. 								wr_cnt <= 0 ;
    160. 								
    161. 							end	
    162. 						else
    163. 							write_pulse <= 0 ;	
    164. 					end
    165. 				else if ( rec_shift_reg[4] == read_option )
    166. 					begin
    167. 						read_addr <= { rec_shift_reg[2] , rec_shift_reg[3] } ;
    168. 						//read signal
    169. 						rd_cnt <= rd_cnt + 1 ;
    170. 						if(trans_done)
    171. 							begin
    172. 								read_data <= rd_data ;
    173. 								read_pulse <= 0 ;
    174. 								rd_cnt <= 0 ;
    175. 								
    176. 							end
    178. 						else if(rd_cnt <3)
    179. 							read_pulse <= 1 ;
    180. 						else
    181. 							read_pulse <= 0 ;
    182. 					end
    183. 			end
    184. 	end
    185. else
    186. 	begin
    187. 		write_pulse <= 0 ;
    188. 		read_pulse <= 0 ;
    189. 		wr_cnt <= 0 ;
    190. 		rd_cnt <= 0 ;
    191. 	end
    192. 	
    193. always@(posedge fpga_clk or negedge rst_n)
    194. if(!rst_n)
    195. 	uart_send_en <= 0 ;
    196. else if(trans_done && (rec_shift_reg[4] == read_option) )
    197. 	uart_send_en <= 1 ;
    198. else if(uart_send_done)
    199. 	uart_send_en <= 0 ;
    200. 	
    201. endmodule

    2.板级验证

            fpga向sdram芯片写入数据16‘h1234，并返回低位8’h34。

  • 相关阅读:
    吴恩达机器学习课程笔记3-4
    RTP和RTCP详解
    MVC架构和DDD架构的区别？
    Python | GUI | tinker不完全总结
    电商新趋势：Starday拿下黑色星期五的制胜法宝是物流速度
    YBTOJ 期望分数【第31章 期望问题】
    【idea】解决idea 执行maven build总下载 Downloading maven-metadata.xml文件
    ValueError: unsupported format character ‘；‘ (0x3b) at index 625
    经典算法之冒泡排序
    .NET 实现启动时重定向程序运行路径及 Windows 服务运行模式部署
  • 原文地址：https://blog.csdn.net/qq_44366923/article/details/134063833