eydwyz
eydwyz

SDRAM驱动篇之简易SDRAM控制器的verilog代码实现

在Kevin写的上一篇博文《SDRAM理论篇之基础知识及操作时序》中，已经把SDRAM工作的基本原理和SDRAM初始化、读、写及自动刷新操作的时序讲清楚了，在这一片博文中，Kevin来根据在上一篇博文中分析的思路来把写一个简单的SDRAM控制器。

我们在上一篇博文中提到了这样一个问题，SDRAM是每隔15us进行刷新一次，但是如果当SDRAM需要进行刷新时，而SDRAM正在写数据，这两个操作之间怎么进行协调呢？因为我们是肯定需要保证写的数据不能丢失，所以，我们可以考虑这样来做：如果刷新的时间到了，先让写操作把正在写的4个数据（突发长度为4）写完，然后再去进行刷新操作。而如果在执行读操作也遇到需要刷新的情况，我们也可以这样来做，先让数据读完，再去执行刷新操作。

大家看完可能会想，说是这么说，那代码怎么来写呢？似乎还是没什么思路。大家可以想象一下，我们写的SDRAM控制器是肯定包括初始化、读操作、写操作及自动刷新这些操作的，既然这样，我们就可以给每一个操作写上一个模块独立开来，这样也便于我们每个模块的调试，显然这种思路是正确的。那怎么让我们的各个模块工作起来呢，虽然都是独立的模块，但很显然这几个模块之间又是相互关联的。就拿上面刚才说的那个情况来讲，如果SDRAM需要刷新了，而SDRAM却正在执行写操作，那我们刷新模块与写模块之间怎么进行控制呢？这个问题解决了，读模块与刷新模块之间的这个问题也可以很轻松的解决。大家不妨可以自己先想一下。

主状态机与各模块间的连线

为了解决各个模块之间不方便控制的情况，我们引入一个新的机制 ——“仲裁”机制。“仲裁”用来干什么呢？在这里边，“仲裁”相当于我们这个SDRAM控制器的老大，对SDRAM的各个操作统一协调：读、写及自动刷新都由“仲裁”来控制。说到这里，显然我们可以再写一个“仲裁”模块，既然在仲裁模块中要控制这么多操作，那自然而然的肯定想到了利用状态机。那我们的状态机怎么来设计呢？请看下图：

SDRAM驱动篇之简易SDRAM控制器的verilog代码实现_第1张图片

只给一个状态机的图，Kevin还是觉得不够说明问题，再上一个模块之间的示意图：

SDRAM驱动篇之简易SDRAM控制器的verilog代码实现_第2张图片

在讲之前，Kevin 要给大家打一下预防针：在接下来讲的过程中，大家一定要搞清楚Kevin说的是模块之间连线的关系还是状态机之间跳转的关系哦。

在仲裁模块中，初始化操作完成之后便进入到了“ARBIT”仲裁状态，只有处于仲裁状态的时候，“仲裁老大”才能进行下命令。我们先来模拟一下，当状态机处于“WRITE”写状态时，如果SDRAM刷新的时间到了，刷新模块同时向写模块和仲裁模块发送刷新请求ref_req信号，当写模块接受到ref_req之后，写模块在写完当前4个数据（突发长度为4）之后，写模块的写结束标志flag_wr_end拉高，然后状态机进入“ARBIT”仲裁状态，处于仲裁状态之后，此时有刷新请求ref_req，然后状态机跳转到“AREF”状态并且仲裁模块发送ref_en刷新使能，然后呢，刷新模块将刷新请求信号ref_req拉低并给sdram发送刷新的命令。等刷新完毕之后，刷新模块给仲裁模块发送flag_ref_end刷新结束标志，状态机跳转到“ARBIT”仲裁状态。

注意了，当刷新完跳转到“ARBIT”仲裁状态之后，如果之前我们的全部数据仍然没有写完（Kevin指的是全部数据，并不是一个突发长度的4个数据哦），那么此时我们仍然要给仲裁模块写请求“wr_req”，然后仲裁模块经过一系列判断之后，如果符合写操作的时机，那就给写模块一个写使能信号“wr_en”，然后跳转到“WRITE”写状态并且写模块开始工作。

对于读模块与刷新操作之间的协调，相信大家应该也能想象得到了，Kevin在这里就不再啰嗦了。

仲裁模块（顶层模块）代码介绍

下面先看一下在我们的仲裁模块（顶层模块）中状态机的定义：

   
   
   
   
    
    
    
    
    
  1. //state
    2. 
    
    
    
    
  2. 	always	@(posedge sclk or negedge s_rst_n)
    3. 
    
    
    
    
  3. 		if(s_rst_n == 1'b0)
    4. 
    
    
    
    
  4. 			state	<=	IDLE;
    5. 
    
    
    
    
  5. 		else case(state)
    6. 
    
    
    
    
  6. 			IDLE:
    7. 
    
    
    
    
  7. 				if(key[0] == 1'b1)
    8. 
    
    
    
    
  8. 					state	<=	INIT;
    9. 
    
    
    
    
  9. 				else
    10. 
    
    
    
    
  10. 					state	<=	IDLE;
    11. 
    
    
    
    
  11. 			INIT:
    12. 
    
    
    
    
  12. 				if(flag_init_end == 1'b1)	//初始化结束标志
    13. 
    
    
    
    
  13. 					state	<=	ARBIT;
    14. 
    
    
    
    
  14. 				else
    15. 
    
    
    
    
  15. 					state	<=	INIT;
    16. 
    
    
    
    
  16. 			ARBIT:
    17. 
    
    
    
    
  17. 				if(ref_req == 1'b1)	//刷新请求到来且已经写完
    18. 
    
    
    
    
  18. 					state	<=	AREF;
    19. 
    
    
    
    
  19. 				else if(ref_req == 1'b0 && rd_en == 1'b1)	//默认读操作优先于写操作
    20. 
    
    
    
    
  20. 					state	<=	READ;			
    21. 
    
    
    
    
  21. 				else if(ref_req == 1'b0 && wr_en == 1'b1)	//无刷新请求且写请求到来
    22. 
    
    
    
    
  22. 					state	<=	WRITE;
    23. 
    
    
    
    
  23. 				else
    24. 
    
    
    
    
  24. 					state	<=	ARBIT;
    25. 
    
    
    
    
  25. 			AREF:
    26. 
    
    
    
    
  26. 				if(flag_ref_end == 1'b1)
    27. 
    
    
    
    
  27. 					state	<=	ARBIT;
    28. 
    
    
    
    
  28. 				else
    29. 
    
    
    
    
  29. 					state	<=	AREF;
    30. 
    
    
    
    
  30. 			WRITE:
    31. 
    
    
    
    
  31. 				if(flag_wr_end == 1'b1)
    32. 
    
    
    
    
  32. 					state	<=	ARBIT;
    33. 
    
    
    
    
  33. 				else
    34. 
    
    
    
    
  34. 					state	<=	WRITE;
    35. 
    
    
    
    
  35. 			READ:
    36. 
    
    
    
    
  36. 				if(flag_rd_end == 1'b1)
    37. 
    
    
    
    
  37. 					state	<=	ARBIT;
    38. 
    
    
    
    
  38. 				else
    39. 
    
    
    
    
  39. 					state	<=	READ;
    40. 
    
    
    
    
  40. 			default:
    41. 
    
    
    
    
  41. 				state	<=	IDLE;			
    42. 
    
    
    
    
  42. 		endcase	
    43.

下面简单的介绍一下状态机代码：

key[0]作为我们初始化的一个使能信号，如果是实际下板子的时候，我们还需要给按键加一个按键消抖模块。当按键0按下之后，代表我们的SDRAM的初始化使能信号来了，所以状态机从“IDLE”跳转到了“INIT”状态。在初始化状态，如果我们的初始化模块传来了初始化结束标志“flag_init_end”，那状态机跳转到“ARBIT”仲裁状态，在仲裁状态中，第一个“if”是判断刷新请求的，这也就说明了我们刷新的优先级最高。之后，如果处于仲裁状态，来了读使能信号或者写使能信号并且没有刷新请求，那状态机就跳转到对应的状态。如果处于读或写的状态，当读结束标志或者写结束标志来临的时候（这里的写结束标志和读结束标志都是指突发读或突发写的结束标志），那么就会跳转到仲裁状态。

初始化模块代码简单介绍

下面再简单的看下初始化模块中的代码：

   
   
   
   
    
    
    
    
    
  1. /***********************************************
    2. 
    
    
    
    
  2. *	Module	Name	:	sdram_init
    3. 
    
    
    
    
  3. *	Engineer	:	Kevin
    4. 
    
    
    
    
  4. *	Function	:	sdram初始化模块
    5. 
    
    
    
    
  5. *	Date		:	2016.01.10
    6. 
    
    
    
    
  6. *	Blog	Website	:	dengkanwen.com
    7. 
    
    
    
    
  7. *	Version		:	v1.0
    8. 
    
    
    
    
  8. ***********************************************/
    9. 
    
    
    
    
  9. module	sdram_init(
    10. 
    
    
    
    
  10. 		input	wire		sclk,		//系统时钟为50M，即T=20ns
    11. 
    
    
    
    
  11. 		input	wire		s_rst_n,
    12. 
    
    
    
    
  12. 		
    13. 
    
    
    
    
  13. 		output	reg	[3:0]	cmd_reg,	//sdram命令寄存器
    14. 
    
    
    
    
  14. 		output	reg	[11:0]	sdram_addr,	//地址线
    15. 
    
    
    
    
  15. 		output	reg	[1:0]	sdram_bank,	//bank地址
    16. 
    
    
    
    
  16. 		output	reg		flag_init_end	//sdram初始化结束标志	
    17. 
    
    
    
    
  17. 		);
    18. 
    
    
    
    
  18. 		
    19. 
    
    
    
    
  19. 	parameter	CMD_END		=	4'd11,		//初始化结束时的命令计数器的值
    20. 
    
    
    
    
  20. 			CNT_200US	=	14'd1_0000,	
    21. 
    
    
    
    
  21. 			NOP		=	4'b0111,	//空操作命令
    22. 
    
    
    
    
  22. 			PRECHARGE	=	4'b0010,	//预充电命令
    23. 
    
    
    
    
  23. 			AUTO_REF	=	4'b0001,	//自刷新命令
    24. 
    
    
    
    
  24. 			MRSET		=	4'b0000;	//模式寄存器设置命令
    25. 
    
    
    
    
  25.  
    26. 
    
    
    
    
  26. 	reg	[13:0]	cnt_200us;		//200us计数器
    27. 
    
    
    
    
  27. 	reg		flag_200us;		//200us结束标志（200us结束后，一直拉高）
    28. 
    
    
    
    
  28. 	reg	[3:0]	cnt_cmd;		//命令计数器，便于控制在某个时候发送特定指令
    29. 
    
    
    
    
  29. 	reg		flag_init;		//初始化标志：初始化结束后，该标志拉低
    30. 
    
    
    
    
  30. //flag_init 
    31. 
    
    
    
    
  31. 	always	@(posedge sclk or negedge s_rst_n)
    32. 
    
    
    
    
  32. 		if(s_rst_n == 1'b0)
    33. 
    
    
    
    
  33. 			flag_init	<=	1'b1;
    34. 
    
    
    
    
  34. 		else if(cnt_cmd == CMD_END)
    35. 
    
    
    
    
  35. 			flag_init	<=	1'b0;	
    36. 
    
    
    
    
  36. //cnt_200us	
    37. 
    
    
    
    
  37. 	always	@(posedge sclk or negedge s_rst_n)
    38. 
    
    
    
    
  38. 		if(s_rst_n == 1'b0)
    39. 
    
    
    
    
  39. 			cnt_200us	<=	14'd0;
    40. 
    
    
    
    
  40. 		else if(cnt_200us == CNT_200US)
    41. 
    
    
    
    
  41. 			cnt_200us	<=	14'd0;
    42. 
    
    
    
    
  42. 		else if(flag_200us == 1'b0)
    43. 
    
    
    
    
  43. 			cnt_200us	<=	cnt_200us + 1'b1;
    44. 
    
    
    
    
  44. //flag_200us
    45. 
    
    
    
    
  45. 	always	@(posedge sclk or negedge s_rst_n)
    46. 
    
    
    
    
  46. 		if(s_rst_n == 1'b0)
    47. 
    
    
    
    
  47. 			flag_200us	<=	1'b0;
    48. 
    
    
    
    
  48. 		else if(cnt_200us == CNT_200US)
    49. 
    
    
    
    
  49. 			flag_200us	<=	1'b1;
    50. 
    
    
    
    
  50. //cnt_cmd
    51. 
    
    
    
    
  51. 	always	@(posedge sclk or negedge s_rst_n)
    52. 
    
    
    
    
  52. 		if(s_rst_n == 1'b0)
    53. 
    
    
    
    
  53. 			cnt_cmd	<=	4'd0;
    54. 
    
    
    
    
  54. 		else if(flag_200us == 1'b1 && flag_init == 1'b1)
    55. 
    
    
    
    
  55. 			cnt_cmd	<=	cnt_cmd + 1'b1;
    56. 
    
    
    
    
  56. //flag_init_end
    57. 
    
    
    
    
  57. 	always	@(posedge sclk or negedge s_rst_n)
    58. 
    
    
    
    
  58. 		if(s_rst_n == 1'b0)
    59. 
    
    
    
    
  59. 			flag_init_end	<=	1'b0;
    60. 
    
    
    
    
  60. 		else if(cnt_cmd == CMD_END)
    61. 
    
    
    
    
  61. 			flag_init_end	<=	1'b1;
    62. 
    
    
    
    
  62. 		else
    63. 
    
    
    
    
  63. 			flag_init_end	<=	1'b0;
    64. 
    
    
    
    
  64. //cmd_reg
    65. 
    
    
    
    
  65. 	always	@(posedge sclk or negedge s_rst_n)
    66. 
    
    
    
    
  66. 		if(s_rst_n == 1'b0)
    67. 
    
    
    
    
  67. 			cmd_reg	<=	NOP;
    68. 
    
    
    
    
  68. 		else if(cnt_200us == CNT_200US)
    69. 
    
    
    
    
  69. 			cmd_reg	<=	PRECHARGE;
    70. 
    
    
    
    
  70. 		else if(flag_200us)
    71. 
    
    
    
    
  71. 			case(cnt_cmd)
    72. 
    
    
    
    
  72. 				4'd0:
    73. 
    
    
    
    
  73. 					cmd_reg	<=	AUTO_REF;	//预充电命令
    74. 
    
    
    
    
  74. 				4'd6:
    75. 
    
    
    
    
  75. 					cmd_reg	<=	AUTO_REF;
    76. 
    
    
    
    
  76. 				4'd10:
    77. 
    
    
    
    
  77. 					cmd_reg	<=	MRSET;		//模式寄存器设置
    78. 
    
    
    
    
  78. 				default:
    79. 
    
    
    
    
  79. 					cmd_reg	<=	NOP;
    80. 
    
    
    
    
  80. 			endcase
    81. 
    
    
    
    
  81. //sdram_addr
    82. 
    
    
    
    
  82. 	always	@(posedge sclk or negedge s_rst_n)
    83. 
    
    
    
    
  83. 		if(s_rst_n == 1'b0)
    84. 
    
    
    
    
  84. 			sdram_addr	<=	12'd0;
    85. 
    
    
    
    
  85. 		else case(cnt_cmd)
    86. 
    
    
    
    
  86. 			4'd0:
    87. 
    
    
    
    
  87. 				sdram_addr	<=	12'b0100_0000_0000;	//预充电时，A10拉高，对所有Bank操作
    88. 
    
    
    
    
  88. 			4'd10:
    89. 
    
    
    
    
  89. 				sdram_addr	<=	12'b0000_0011_0010;	//模式寄存器设置时的指令:CAS=2,Burst Length=4;
    90. 
    
    
    
    
  90. 			default:
    91. 
    
    
    
    
  91. 				sdram_addr	<=	12'd0;
    92. 
    
    
    
    
  92. 		endcase
    93. 
    
    
    
    
  93. //sdram_bank
    94. 
    
    
    
    
  94. 	always	@(posedge sclk or negedge s_rst_n)
    95. 
    
    
    
    
  95. 		if(s_rst_n == 1'b0)
    96. 
    
    
    
    
  96. 			sdram_bank	<=	2'd0;	//这里仅仅只是初始化，在模式寄存器设置时才会用到且其值为全零，故不赋值
    97. 
    
    
    
    
  97.  
    98. 
    
    
    
    
  98. //sdram_clk
    99. 
    
    
    
    
  99. 	assign	sdram_clk	=	~sclk;
    100. 
    
    
    
    
  100. 			
    101. 
    
    
    
    
  101. endmodule
    102.

下面我们来结合代码回顾下初始化过程：

首先，我们需要有200us的稳定期，所以我们便有了一个200us的计数器cnt_200us，而这个计数器是根据flag_200us的低电平来工作的。大家可以看到，falg_200us在200us计时之后一直拉高。在200us计满，即flag_200us拉高之后，我们就需要先给一个“NOP”命令，然后给两次“Precharge”命令，同时选中ALL Banks。

SDRAM写模块介绍

下面咱们先不对SDRAM的初始化进行仿真，等把全部的模块讲完再来仿真。接下来再继续说写操作：首先在我们的仲裁模块，初始化完成之后，就已经跳转到“ARBIT”仲裁状态了，然后，我们在testbench中模拟一个外部的写请求信号。咱们先看下写模块的代码：

 

   
   
   
   
    
    
    
    
    
  1. module	sdram_write(
    2. 
    
    
    
    
  2. 		input	wire		sclk,
    3. 
    
    
    
    
  3. 		input	wire		s_rst_n,
    4. 
    
    
    
    
  4. 		input	wire		key_wr,
    5. 
    
    
    
    
  5. 		input	wire		wr_en,		//来自仲裁模块的写使能
    6. 
    
    
    
    
  6. 		input	wire		ref_req,	//来自刷新模块的刷新请求
    7. 
    
    
    
    
  7. 		input	wire	[5:0]	state,		//顶层模块的状态
    8. 
    
    
    
    
  8. 		
    9. 
    
    
    
    
  9. 		output	reg	[15:0]	sdram_dq,	//sdram输入/输出端口
    10. 
    
    
    
    
  10. 		//output	reg	[3:0]	sdram_dqm,	//输入/输出掩码
    11. 
    
    
    
    
  11. 		output	reg	[11:0]	sdram_addr,	//sdram地址线
    12. 
    
    
    
    
  12. 		output	reg	[1:0]	sdram_bank,	//sdram的bank地址线
    13. 
    
    
    
    
  13. 		output	reg	[3:0]	sdram_cmd,	//sdram的命令寄存器
    14. 
    
    
    
    
  14. 		output	reg		wr_req,		//写请求（不在写状态时向仲裁进行写请求）
    15. 
    
    
    
    
  15. 		output	reg		flag_wr_end	//写结束标志（有刷新请求来时，向仲裁输出写结束）
    16. 
    
    
    
    
  16. 		);
    17. 
    
    
    
    
  17. 		
    18. 
    
    
    
    
  18. 	parameter	NOP	=	4'b0111,	//NOP命令
    19. 
    
    
    
    
  19. 			ACT	=	4'b0011,	//ACT命令
    20. 
    
    
    
    
  20. 			WR	=	4'b0100,	//写命令（需要将A10拉高）
    21. 
    
    
    
    
  21. 			PRE	=	4'b0010,	//precharge命令
    22. 
    
    
    
    
  22. 			CMD_END	=	4'd8,
    23. 
    
    
    
    
  23. 			COL_END	=	9'd508,		//最后四个列地址的第一个地址
    24. 
    
    
    
    
  24. 			ROW_END	=	12'd4095,	//行地址结束
    25. 
    
    
    
    
  25. 			AREF	=	6'b10_0000,	//自动刷新状态
    26. 
    
    
    
    
  26. 			WRITE	=	6'b00_1000;	//状态机的写状态
    27. 
    
    
    
    
  27. 			
    28. 
    
    
    
    
  28. 	reg		flag_act;			//需要发送ACT的标志			
    29. 
    
    
    
    
  29. 	reg	[3:0]	cmd_cnt;			//命令计数器
    30. 
    
    
    
    
  30. 	reg	[11:0]	row_addr;			//行地址
    31. 
    
    
    
    
  31. 	reg	[11:0]	row_addr_reg;			//行地址寄存器
    32. 
    
    
    
    
  32. 	reg	[8:0]	col_addr;			//列地址
    33. 
    
    
    
    
  33. 	reg		flag_pre;			//在sdram内部为写状态时需要给precharge命令的标志
    34. 
    
    
    
    
  34.  
    35. 
    
    
    
    
  35. //flag_pre
    36. 
    
    
    
    
  36. 	always	@(posedge sclk or negedge s_rst_n)
    37. 
    
    
    
    
  37. 		if(s_rst_n == 1'b0)
    38. 
    
    
    
    
  38. 			flag_pre	<=	1'b0;
    39. 
    
    
    
    
  39. 		else if(col_addr == 9'd0 && flag_wr_end == 1'b1)
    40. 
    
    
    
    
  40. 			flag_pre	<=	1'b1;
    41. 
    
    
    
    
  41. 		else if(flag_wr_end == 1'b1)
    42. 
    
    
    
    
  42. 			flag_pre	<=	1'b0;
    43. 
    
    
    
    
  43. 	
    44. 
    
    
    
    
  44. //flag_act
    45. 
    
    
    
    
  45. 	always	@(posedge sclk or negedge s_rst_n)
    46. 
    
    
    
    
  46. 		if(s_rst_n == 1'b0)
    47. 
    
    
    
    
  47. 			flag_act	<=	1'b0;
    48. 
    
    
    
    
  48. 		else if(flag_wr_end)
    49. 
    
    
    
    
  49. 			flag_act	<=	1'b0;
    50. 
    
    
    
    
  50. 		else if(ref_req == 1'b1 && state == AREF)
    51. 
    
    
    
    
  51. 			flag_act	<=	1'b1;
    52. 
    
    
    
    
  52. //wr_req
    53. 
    
    
    
    
  53. 	always	@(posedge sclk or negedge s_rst_n)
    54. 
    
    
    
    
  54. 		if(s_rst_n == 1'b0)
    55. 
    
    
    
    
  55. 			wr_req	<=	1'b0;
    56. 
    
    
    
    
  56. 		else if(wr_en == 1'b1)
    57. 
    
    
    
    
  57. 			wr_req	<=	1'b0;
    58. 
    
    
    
    
  58. 		else if(state != WRITE && key_wr == 1'b1)
    59. 
    
    
    
    
  59. 			wr_req	<=	1'b1;
    60. 
    
    
    
    
  60. //flag_wr_end
    61. 
    
    
    
    
  61. 	always	@(posedge sclk or negedge s_rst_n)
    62. 
    
    
    
    
  62. 		if(s_rst_n == 1'b0)
    63. 
    
    
    
    
  63. 			flag_wr_end	<=	1'b0;
    64. 
    
    
    
    
  64. 		else if(cmd_cnt == CMD_END)
    65. 
    
    
    
    
  65. 			flag_wr_end	<=	1'b1;
    66. 
    
    
    
    
  66. 		else
    67. 
    
    
    
    
  67. 			flag_wr_end	<=	1'b0;
    68. 
    
    
    
    
  68. //cmd_cnt
    69. 
    
    
    
    
  69. 	always	@(posedge sclk or negedge s_rst_n)
    70. 
    
    
    
    
  70. 		if(s_rst_n == 1'b0)
    71. 
    
    
    
    
  71. 			cmd_cnt	<=	4'd0;
    72. 
    
    
    
    
  72. 		else if(state == WRITE)
    73. 
    
    
    
    
  73. 			cmd_cnt	<=	cmd_cnt + 1'b1;
    74. 
    
    
    
    
  74. 		else 
    75. 
    
    
    
    
  75. 			cmd_cnt	<=	4'd0;
    76. 
    
    
    
    
  76. 		
    77. 
    
    
    
    
  77. //sdram_cmd
    78. 
    
    
    
    
  78. 	always	@(posedge sclk or negedge s_rst_n)
    79. 
    
    
    
    
  79. 		if(s_rst_n == 1'b0)
    80. 
    
    
    
    
  80. 			sdram_cmd	<=	4'd0;
    81. 
    
    
    
    
  81. 		else case(cmd_cnt)
    82. 
    
    
    
    
  82. 			3'd1:
    83. 
    
    
    
    
  83. 				if(flag_pre == 1'b1)
    84. 
    
    
    
    
  84. 					sdram_cmd	<=	PRE;
    85. 
    
    
    
    
  85. 				else
    86. 
    
    
    
    
  86. 					sdram_cmd	<=	NOP;
    87. 
    
    
    
    
  87. 			3'd2:
    88. 
    
    
    
    
  88. 				if(flag_act == 1'b1 || col_addr == 9'd0)
    89. 
    
    
    
    
  89. 					sdram_cmd	<=	ACT;
    90. 
    
    
    
    
  90. 				else
    91. 
    
    
    
    
  91. 					sdram_cmd	<=	NOP;
    92. 
    
    
    
    
  92. 			3'd3: 		
    93. 
    
    
    
    
  93. 				sdram_cmd	<=	WR;
    94. 
    
    
    
    
  94.  
    95. 
    
    
    
    
  95. 			default:
    96. 
    
    
    
    
  96. 				sdram_cmd	<=	NOP;		
    97. 
    
    
    
    
  97. 		endcase
    98. 
    
    
    
    
  98. //sdram_dq
    99. 
    
    
    
    
  99. 	always	@(posedge sclk or negedge s_rst_n)
    100. 
    
    
    
    
  100. 		if(s_rst_n == 1'b0)
    101. 
    
    
    
    
  101. 			sdram_dq	<=	16'd0;
    102. 
    
    
    
    
  102. 		else case(cmd_cnt)
    103. 
    
    
    
    
  103. 			3'd3:
    104. 
    
    
    
    
  104. 				sdram_dq	<=	16'h0012;
    105. 
    
    
    
    
  105. 			3'd4:
    106. 
    
    
    
    
  106. 				sdram_dq	<=	16'h1203;
    107. 
    
    
    
    
  107. 			3'd5:
    108. 
    
    
    
    
  108. 				sdram_dq	<=	16'h562f;
    109. 
    
    
    
    
  109. 			3'd6:
    110. 
    
    
    
    
  110. 				sdram_dq	<=	16'hfe12;
    111. 
    
    
    
    
  111. 			default:
    112. 
    
    
    
    
  112. 				sdram_dq	<=	16'd0;
    113. 
    
    
    
    
  113. 		endcase
    114. 
    
    
    
    
  114. /* //sdram_dq_m
    115. 
    
    
    
    
  115. 	always	@(posedge sclk or negedge s_rst_n)
    116. 
    
    
    
    
  116. 		if(s_rst_n == 1'b0)
    117. 
    
    
    
    
  117. 			sdram_dqm	<=	4'd0; */
    118. 
    
    
    
    
  118. //row_addr_reg
    119. 
    
    
    
    
  119. 	always	@(posedge sclk or negedge s_rst_n)
    120. 
    
    
    
    
  120. 		if(s_rst_n == 1'b0)
    121. 
    
    
    
    
  121. 			row_addr_reg	<=	12'd0;
    122. 
    
    
    
    
  122. 		else if(row_addr_reg == ROW_END && col_addr == COL_END && cmd_cnt == CMD_END)
    123. 
    
    
    
    
  123. 			row_addr_reg	<=	12'd0;
    124. 
    
    
    
    
  124. 		else if(col_addr == COL_END && flag_wr_end == 1'b1)
    125. 
    
    
    
    
  125. 			row_addr_reg	<=	row_addr_reg + 1'b1;
    126. 
    
    
    
    
  126. 		
    127. 
    
    
    
    
  127. //row_addr
    128. 
    
    
    
    
  128. 	always	@(posedge sclk or negedge s_rst_n)
    129. 
    
    
    
    
  129. 		if(s_rst_n == 1'b0)
    130. 
    
    
    
    
  130. 			row_addr	<=	12'd0;
    131. 
    
    
    
    
  131. 		else case(cmd_cnt)
    132. 
    
    
    
    
  132. 		//因为下边的命令是通过行、列地址分开再给addr赋值，所以需要提前一个周期赋值，以保证在命令到来时能读到正确的地址
    133. 
    
    
    
    
  133. 			3'd2:
    134. 
    
    
    
    
  134. 				row_addr	<=	12'b0000_0000_0000;	//在写命令时，不允许auto-precharge	
    135. 
    
    
    
    
  135. 			default:
    136. 
    
    
    
    
  136. 				row_addr	<=	row_addr_reg;
    137. 
    
    
    
    
  137. 		endcase
    138. 
    
    
    
    
  138. //col_addr
    139. 
    
    
    
    
  139. 	always	@(posedge sclk or negedge s_rst_n)
    140. 
    
    
    
    
  140. 		if(s_rst_n == 1'b0)
    141. 
    
    
    
    
  141. 			col_addr	<=	9'd0;
    142. 
    
    
    
    
  142. 		else if(col_addr == COL_END && cmd_cnt == CMD_END)
    143. 
    
    
    
    
  143. 			col_addr	<=	9'd0;
    144. 
    
    
    
    
  144. 		else if(cmd_cnt == CMD_END)
    145. 
    
    
    
    
  145. 			col_addr	<=	col_addr + 3'd4;
    146. 
    
    
    
    
  146. //sdram_addr
    147. 
    
    
    
    
  147. 	always	@(posedge sclk or negedge s_rst_n)
    148. 
    
    
    
    
  148. 		if(s_rst_n == 1'b0)
    149. 
    
    
    
    
  149. 			sdram_addr	<=	12'd0;
    150. 
    
    
    
    
  150. 		else case(cmd_cnt)
    151. 
    
    
    
    
  151. 			3'd2:
    152. 
    
    
    
    
  152. 				sdram_addr	<=	row_addr;
    153. 
    
    
    
    
  153. 			3'd3:
    154. 
    
    
    
    
  154. 				sdram_addr	<=	col_addr;
    155. 
    
    
    
    
  155. 			
    156. 
    
    
    
    
  156. 			default:
    157. 
    
    
    
    
  157. 				sdram_addr	<=	row_addr;
    158. 
    
    
    
    
  158. 		endcase
    159. 
    
    
    
    
  159. //sdram_bank
    160. 
    
    
    
    
  160. 	always	@(posedge sclk or negedge s_rst_n)
    161. 
    
    
    
    
  161. 		if(s_rst_n == 1'b0)
    162. 
    
    
    
    
  162. 			sdram_bank	<=	2'b00;
    163. 
    
    
    
    
  163. endmodule
    164.

在我们的模块端口列表中，用key_wr来接收写请求信号，这个写请求信号，是在没有写完之前一直拉高的，在写完了全部数据之后才拉低的。当然这个代码的话，还是按照Kevin在上一篇博文中的理论来的，大家只要好好理解理论就可以很轻松的明白为什么代码要这样写了。

在写模块中，Kevin是让SDRAM循环着写16’h0012，16’h1203，16’h562f，16’hfe12这四个数据。

另外一点，在我们的这个写模块中，Kevin是在每写完4个数据，也就是突发结束后，有一个写完标志，从而使状态机跳转到仲裁状态，然后如果数据没写完，由于写请求是拉高的，所以如果此时没有刷新请求，那状态机还是会跳转到写状态继续写的。

SDRAM读操作模块

首先，咱们依然先上代码：

   
   
   
   
    
    
    
    
    
  1. module	sdram_read(
    2. 
    
    
    
    
  2. 		input	wire		sclk,
    3. 
    
    
    
    
  3. 		input	wire		s_rst_n,
    4. 
    
    
    
    
  4. 		input	wire		rd_en,
    5. 
    
    
    
    
  5. 		input	wire	[5:0]	state,
    6. 
    
    
    
    
  6. 		input	wire		ref_req,		//自动刷新请求
    7. 
    
    
    
    
  7. 		input	wire		key_rd,			//来自外部的读请求信号
    8. 
    
    
    
    
  8. 		input	wire	[15:0]	rd_dq,		//sdram的数据端口
    9. 
    
    
    
    
  9. 		
    10. 
    
    
    
    
  10. 		output	reg	[3:0]	sdram_cmd,
    11. 
    
    
    
    
  11. 		output	reg	[11:0]	sdram_addr,
    12. 
    
    
    
    
  12. 		output	reg	[1:0]	sdram_bank,
    13. 
    
    
    
    
  13. 		output	reg		rd_req,			//读请求
    14. 
    
    
    
    
  14. 		output	reg		flag_rd_end		//突发读结束标志
    15. 
    
    
    
    
  15. 		);
    16. 
    
    
    
    
  16.  
    17. 
    
    
    
    
  17. 	parameter	NOP	=	4'b0111,
    18. 
    
    
    
    
  18. 			PRE	=	4'b0010,
    19. 
    
    
    
    
  19. 			ACT	=	4'b0011,
    20. 
    
    
    
    
  20. 			RD	=	4'b0101,		//SDRAM的读命令（给读命令时需要给A10拉低）
    21. 
    
    
    
    
  21. 			CMD_END	=	4'd12,			//
    22. 
    
    
    
    
  22. 			COL_END	=	9'd508,			//最后四个列地址的第一个地址
    23. 
    
    
    
    
  23. 			ROW_END	=	12'd4095,		//行地址结束
    24. 
    
    
    
    
  24. 			AREF	=	6'b10_0000,		//自动刷新状态
    25. 
    
    
    
    
  25. 			READ	=	6'b01_0000;		//状态机的读状态
    26. 
    
    
    
    
  26. 		
    27. 
    
    
    
    
  27. 	reg	[11:0]	row_addr;
    28. 
    
    
    
    
  28. 	reg	[8:0]	col_addr;
    29. 
    
    
    
    
  29. 	reg	[3:0]	cmd_cnt;
    30. 
    
    
    
    
  30. 	reg		flag_act;				//发送ACT命令标志（单独设立标志，便于跑高速）
    31. 
    
    
    
    
  31.  
    32. 
    
    
    
    
  32. //flag_act
    33. 
    
    
    
    
  33. 	always	@(posedge sclk or negedge s_rst_n)
    34. 
    
    
    
    
  34. 		if(s_rst_n == 1'b0)
    35. 
    
    
    
    
  35. 			flag_act	<=	1'b0;
    36. 
    
    
    
    
  36. 		else if(flag_rd_end == 1'b1 && ref_req == 1'b1)
    37. 
    
    
    
    
  37. 			flag_act	<=	1'b1;
    38. 
    
    
    
    
  38. 		else if(flag_rd_end == 1'b1)
    39. 
    
    
    
    
  39. 			flag_act	<=	1'b0;
    40. 
    
    
    
    
  40. //rd_req
    41. 
    
    
    
    
  41. 	always	@(posedge sclk or negedge s_rst_n)
    42. 
    
    
    
    
  42. 		if(s_rst_n == 1'b0)
    43. 
    
    
    
    
  43. 			rd_req	<=	1'b0;
    44. 
    
    
    
    
  44. 		else if(rd_en == 1'b1)
    45. 
    
    
    
    
  45. 			rd_req	<=	1'b0;
    46. 
    
    
    
    
  46. 		else if(key_rd == 1'b1 && state != READ)
    47. 
    
    
    
    
  47. 			rd_req	<=	1'b1;
    48. 
    
    
    
    
  48. //cmd_cnt
    49. 
    
    
    
    
  49. 	always	@(posedge sclk or negedge s_rst_n)
    50. 
    
    
    
    
  50. 		if(s_rst_n == 1'b0)
    51. 
    
    
    
    
  51. 			cmd_cnt	<=	4'd0;
    52. 
    
    
    
    
  52. 		else if(state == READ)
    53. 
    
    
    
    
  53. 			cmd_cnt	<=	cmd_cnt + 1'b1;
    54. 
    
    
    
    
  54. 		else
    55. 
    
    
    
    
  55. 			cmd_cnt	<=	4'd0;
    56. 
    
    
    
    
  56. //flag_rd_end
    57. 
    
    
    
    
  57. 	always	@(posedge sclk or negedge s_rst_n)
    58. 
    
    
    
    
  58. 		if(s_rst_n == 1'b0)
    59. 
    
    
    
    
  59. 			flag_rd_end	<=	1'b0;
    60. 
    
    
    
    
  60. 		else if(cmd_cnt == CMD_END)
    61. 
    
    
    
    
  61. 			flag_rd_end	<=	1'b1;
    62. 
    
    
    
    
  62. 		else
    63. 
    
    
    
    
  63. 			flag_rd_end	<=	1'b0;
    64. 
    
    
    
    
  64. //row_addr
    65. 
    
    
    
    
  65. 	always	@(posedge sclk or negedge s_rst_n)
    66. 
    
    
    
    
  66. 		if(s_rst_n == 1'b0)
    67. 
    
    
    
    
  67. 			row_addr	<=	12'd0;
    68. 
    
    
    
    
  68. 		else if(row_addr == ROW_END && col_addr == COL_END && flag_rd_end == 1'b1)
    69. 
    
    
    
    
  69. 			row_addr	<=	12'd0;
    70. 
    
    
    
    
  70. 		else if(col_addr == COL_END && flag_rd_end == 1'b1)
    71. 
    
    
    
    
  71. 			row_addr	<=	row_addr + 1'b1;
    72. 
    
    
    
    
  72. //col_addr
    73. 
    
    
    
    
  73. 	always	@(posedge sclk or negedge s_rst_n)
    74. 
    
    
    
    
  74. 		if(s_rst_n == 1'b0)
    75. 
    
    
    
    
  75. 			col_addr	<=	9'd0;
    76. 
    
    
    
    
  76. 		else if(col_addr == COL_END && flag_rd_end == 1'b1)
    77. 
    
    
    
    
  77. 			col_addr	<=	9'd0;
    78. 
    
    
    
    
  78. 		else if(flag_rd_end == 1'b1)
    79. 
    
    
    
    
  79. 			col_addr	<=	col_addr + 3'd4;
    80. 
    
    
    
    
  80. //cmd_cnt
    81. 
    
    
    
    
  81. 	always	@(posedge sclk or negedge s_rst_n)
    82. 
    
    
    
    
  82. 		if(s_rst_n == 1'b0)
    83. 
    
    
    
    
  83. 			cmd_cnt	<=	4'd0;
    84. 
    
    
    
    
  84. 		else if(state == READ)
    85. 
    
    
    
    
  85. 			cmd_cnt	<=	cmd_cnt + 1'b1;
    86. 
    
    
    
    
  86. 		else
    87. 
    
    
    
    
  87. 			cmd_cnt	<=	4'd0;
    88. 
    
    
    
    
  88. //sdram_cmd
    89. 
    
    
    
    
  89. 	always	@(posedge sclk or negedge s_rst_n)
    90. 
    
    
    
    
  90. 		if(s_rst_n == 1'b0)
    91. 
    
    
    
    
  91. 			sdram_cmd	<=	NOP;
    92. 
    
    
    
    
  92. 		else case(cmd_cnt)
    93. 
    
    
    
    
  93. 			4'd2:
    94. 
    
    
    
    
  94. 				if(col_addr == 9'd0)
    95. 
    
    
    
    
  95. 					sdram_cmd	<=	PRE;
    96. 
    
    
    
    
  96. 				else
    97. 
    
    
    
    
  97. 					sdram_cmd	<=	NOP;
    98. 
    
    
    
    
  98. 			4'd3:	
    99. 
    
    
    
    
  99. 				if(flag_act == 1'b1 || col_addr == 9'd0)
    100. 
    
    
    
    
  100. 					sdram_cmd	<=	ACT;
    101. 
    
    
    
    
  101. 				else
    102. 
    
    
    
    
  102. 					sdram_cmd	<=	NOP;
    103. 
    
    
    
    
  103. 			4'd4:
    104. 
    
    
    
    
  104. 				sdram_cmd	<=	RD;
    105. 
    
    
    
    
  105. 			default:
    106. 
    
    
    
    
  106. 				sdram_cmd	<=	NOP;
    107. 
    
    
    
    
  107. 		endcase
    108. 
    
    
    
    
  108. //sdram_addr
    109. 
    
    
    
    
  109. 	always	@(posedge sclk or negedge s_rst_n)
    110. 
    
    
    
    
  110. 		if(s_rst_n == 1'b0)
    111. 
    
    
    
    
  111. 			sdram_addr	<=	12'd0;
    112. 
    
    
    
    
  112. 		else case(cmd_cnt)
    113. 
    
    
    
    
  113. 			4'd4:
    114. 
    
    
    
    
  114. 				sdram_addr	<=	{3'd0, col_addr};
    115. 
    
    
    
    
  115. 			default:
    116. 
    
    
    
    
  116. 				sdram_addr	<=	row_addr;
    117. 
    
    
    
    
  117. 		endcase
    118. 
    
    
    
    
  118. //sdram_bank
    119. 
    
    
    
    
  119. 	always	@(posedge sclk or negedge s_rst_n)
    120. 
    
    
    
    
  120. 		if(s_rst_n == 1'b0)
    121. 
    
    
    
    
  121. 			sdram_bank	<=	2'd0;
    122. 
    
    
    
    
  122. 		
    123. 
    
    
    
    
  123.  
    124. 
    
    
    
    
  124. endmodule
    125.

其实读模块和写模块是极其相似的，所以在这里，Kevin就不做赘述，大家慢慢消化吧。

SDRAM自动刷新模块

自动刷新模块算是比较简单的，等15us的时间过了，就向仲裁模块发刷新请求，然后在刷新完成之后，产生刷新结束标志：

   
   
   
   
    
    
    
    
    
  1. /*****************************************************************
    2. 
    
    
    
    
  2. *	Module	Name	:	auto_refresh
    3. 
    
    
    
    
  3. *	Enegineer	:	Kevin
    4. 
    
    
    
    
  4. *	Function	:	sdram自动刷新
    5. 
    
    
    
    
  5. *	Blog	Website	:	http://dengkanwen.com
    6. 
    
    
    
    
  6. *	Comment		:	在这个模块中并没有bank地址的输出线，需要在顶层模块中设置
    7. 
    
    
    
    
  7. ******************************************************************/
    8. 
    
    
    
    
  8. module	auto_refresh(
    9. 
    
    
    
    
  9. 		input	wire		sclk,
    10. 
    
    
    
    
  10. 		input	wire		s_rst_n,
    11. 
    
    
    
    
  11. 		input	wire		ref_en,
    12. 
    
    
    
    
  12. 		input	wire		flag_init_end,	//初始化结束标志（初始化结束后，启动自刷新标志）
    13. 
    
    
    
    
  13. 		
    14. 
    
    
    
    
  14. 		output	reg	[11:0]	sdram_addr,
    15. 
    
    
    
    
  15. 		output	reg	[1:0]	sdram_bank,
    16. 
    
    
    
    
  16. 		output	reg		ref_req,
    17. 
    
    
    
    
  17. 		output	reg	[3:0]	cmd_reg,
    18. 
    
    
    
    
  18. 		output	reg		flag_ref_end
    19. 
    
    
    
    
  19. 		);
    20. 
    
    
    
    
  20.  
    21. 
    
    
    
    
  21. 	parameter	BANK	=	12'd0100_0000_0000,	//自动刷新是对所有bank刷新
    22. 
    
    
    
    
  22. 			CMD_END	=	4'd10,
    23. 
    
    
    
    
  23. 			CNT_END	=	10'd749,	//15us计时结束
    24. 
    
    
    
    
  24. 			NOP	=	4'b0111,	//
    25. 
    
    
    
    
  25. 			PRE	=	4'b0010,	//precharge命令
    26. 
    
    
    
    
  26. 			AREF	=	4'b0001;	//auto-refresh命令
    27. 
    
    
    
    
  27. 			
    28. 
    
    
    
    
  28. 			
    29. 
    
    
    
    
  29. 	reg	[9:0]	cnt_15ms;	//15ms计数器
    30. 
    
    
    
    
  30. 	reg		flag_ref;	//处于自刷新阶段标志
    31. 
    
    
    
    
  31. 	reg		flag_start;	//自动刷新启动标志
    32. 
    
    
    
    
  32. 	reg	[3:0]	cnt_cmd;	//指令计数器
    33. 
    
    
    
    
  33. //flag_start
    34. 
    
    
    
    
  34. 	always	@(posedge sclk or negedge s_rst_n)
    35. 
    
    
    
    
  35. 		if(s_rst_n == 1'b0)
    36. 
    
    
    
    
  36. 			flag_start	<=	1'b0;
    37. 
    
    
    
    
  37. 		else if(flag_init_end == 1'b1)
    38. 
    
    
    
    
  38. 			flag_start	<=	1'b1;
    39. 
    
    
    
    
  39. //cnt_15ms
    40. 
    
    
    
    
  40. 	always	@(posedge sclk or negedge s_rst_n)
    41. 
    
    
    
    
  41. 		if(s_rst_n == 1'b0)
    42. 
    
    
    
    
  42. 			cnt_15ms	<=	10'd0;
    43. 
    
    
    
    
  43. 		else if(cnt_15ms == CNT_END)
    44. 
    
    
    
    
  44. 			cnt_15ms	<=	10'd0;
    45. 
    
    
    
    
  45. 		else if(flag_start == 1'b1)
    46. 
    
    
    
    
  46. 			cnt_15ms	<=	cnt_15ms + 1'b1;
    47. 
    
    
    
    
  47. //flag_ref
    48. 
    
    
    
    
  48. 	always	@(posedge sclk or negedge s_rst_n)
    49. 
    
    
    
    
  49. 		if(s_rst_n == 1'b0)
    50. 
    
    
    
    
  50. 			flag_ref	<=	1'b0;
    51. 
    
    
    
    
  51. 		else if(cnt_cmd == CMD_END)
    52. 
    
    
    
    
  52. 			flag_ref	<=	1'b0;
    53. 
    
    
    
    
  53. 		else if(ref_en == 1'b1)
    54. 
    
    
    
    
  54. 			flag_ref	<=	1'b1;
    55. 
    
    
    
    
  55. //cnt_cmd
    56. 
    
    
    
    
  56. 	always	@(posedge sclk or negedge s_rst_n)
    57. 
    
    
    
    
  57. 		if(s_rst_n == 1'b0)
    58. 
    
    
    
    
  58. 			cnt_cmd	<=	4'd0;
    59. 
    
    
    
    
  59. 		else if(flag_ref == 1'b1)
    60. 
    
    
    
    
  60. 			cnt_cmd	<=	cnt_cmd + 1'b1;
    61. 
    
    
    
    
  61. 		else
    62. 
    
    
    
    
  62. 			cnt_cmd	<=	4'd0;
    63. 
    
    
    
    
  63. //flag_ref_end
    64. 
    
    
    
    
  64. 	always	@(posedge sclk or negedge s_rst_n)
    65. 
    
    
    
    
  65. 		if(s_rst_n == 1'b0)
    66. 
    
    
    
    
  66. 			flag_ref_end	<=	1'b0;
    67. 
    
    
    
    
  67. 		else if(cnt_cmd == CMD_END)
    68. 
    
    
    
    
  68. 			flag_ref_end	<=	1'b1;
    69. 
    
    
    
    
  69. 		else
    70. 
    
    
    
    
  70. 			flag_ref_end	<=	1'b0;
    71. 
    
    
    
    
  71. //cmd_reg
    72. 
    
    
    
    
  72. 	always	@(posedge sclk or negedge s_rst_n)
    73. 
    
    
    
    
  73. 		if(s_rst_n == 1'b0)
    74. 
    
    
    
    
  74. 			cmd_reg	<=	NOP;
    75. 
    
    
    
    
  75. 		else case(cnt_cmd)
    76. 
    
    
    
    
  76. 			3'd0:
    77. 
    
    
    
    
  77. 				if(flag_ref == 1'b1)
    78. 
    
    
    
    
  78. 					cmd_reg	<=	PRE;
    79. 
    
    
    
    
  79. 				else
    80. 
    
    
    
    
  80. 					cmd_reg	<=	NOP;
    81. 
    
    
    
    
  81. 			3'd1:
    82. 
    
    
    
    
  82. 				cmd_reg	<=	AREF;
    83. 
    
    
    
    
  83. 			3'd5:
    84. 
    
    
    
    
  84. 				cmd_reg	<=	AREF;
    85. 
    
    
    
    
  85. 			default:
    86. 
    
    
    
    
  86. 				cmd_reg	<=	NOP;
    87. 
    
    
    
    
  87. 		endcase
    88. 
    
    
    
    
  88. //sdram_addr
    89. 
    
    
    
    
  89. 	always	@(posedge sclk or negedge s_rst_n)
    90. 
    
    
    
    
  90. 		if(s_rst_n == 1'b0)
    91. 
    
    
    
    
  91. 			sdram_addr	<=	12'd0;
    92. 
    
    
    
    
  92. 		else case(cnt_cmd)
    93. 
    
    
    
    
  93. 			4'd0:
    94. 
    
    
    
    
  94. 				sdram_addr	<=	BANK;	//bank进行刷新时指定allbank or signle bank
    95. 
    
    
    
    
  95. 			default:
    96. 
    
    
    
    
  96. 				sdram_addr	<=	12'd0;
    97. 
    
    
    
    
  97. 		endcase
    98. 
    
    
    
    
  98. //sdram_bank
    99. 
    
    
    
    
  99. 	always	@(posedge sclk or negedge s_rst_n)
    100. 
    
    
    
    
  100. 		if(s_rst_n == 1'b0)
    101. 
    
    
    
    
  101. 			sdram_bank	<=	2'd0;		//刷新指定的bank
    102. 
    
    
    
    
  102. //ref_req
    103. 
    
    
    
    
  103. 	always	@(posedge sclk or negedge s_rst_n)
    104. 
    
    
    
    
  104. 		if(s_rst_n == 1'b0)
    105. 
    
    
    
    
  105. 			ref_req	<=	1'b0;
    106. 
    
    
    
    
  106. 		else if(ref_en == 1'b1)
    107. 
    
    
    
    
  107. 			ref_req	<=	1'b0;
    108. 
    
    
    
    
  108. 		else if(cnt_15ms == CNT_END)
    109. 
    
    
    
    
  109. 			ref_req	<=	1'b1;
    110. 
    
    
    
    
  110. //flag_ref_end
    111. 
    
    
    
    
  111. 	always	@(posedge sclk or negedge s_rst_n)
    112. 
    
    
    
    
  112. 		if(s_rst_n == 1'b0)
    113. 
    
    
    
    
  113. 			flag_ref_end	<=	1'b0;
    114. 
    
    
    
    
  114. 		else if(cnt_cmd == CMD_END)
    115. 
    
    
    
    
  115. 			flag_ref_end	<=	1'b1;
    116. 
    
    
    
    
  116. 		else
    117. 
    
    
    
    
  117. 			flag_ref_end	<=	1'b0;
    118. 
    
    
    
    
  118.  
    119. 
    
    
    
    
  119. endmodule
    120.

至此，咱们的整个设计就已经讲完了，至于模块之间怎么连线，Kevin就不再硬性灌输了，留给大家自己完成吧。当然Kevin还是想提醒大家，因为SDRAM的数据总线是双向的，所以需要弄个三态门，在向SDRAM写数据的时候，模块定义的数据总线应为输出型，在接收数据时，需要定义成高阻态。

SDRAM仿真

设计讲完了，咱们来说下仿真，在我们仿真的时候，我们需要用到SDRAM的仿真模型（关于仿真模型，Kevin已经上传到“福利/文档手册”这个栏目下了）。

因为我们需要有一个200us的稳定期，所以我们可以先让Modelsim跑个200us，可以直接在命令窗口输入”run 200us”;200us的稳定器过了之后，接下来应该就是咱们的初始话了，所以我们在让modelsim跑600ns，下面是仿真的结果：

SDRAM驱动篇之简易SDRAM控制器的verilog代码实现_第3张图片

SDRAM驱动篇之简易SDRAM控制器的verilog代码实现_第4张图片

在上边的仿真中，我们已经知道SDRAM已经初始化成功了，设置的潜伏期为3，突发长度为4

下面我们再运行一段时间，就运行1us吧，往SDRAM中写数据：

SDRAM驱动篇之简易SDRAM控制器的verilog代码实现_第5张图片

这里的写的数据，就是咱们在写模块中设置的那4个数，只是之前的是用16进制定义的，这里显示的是10进制。

然后我们再看一下读数据：SDRAM驱动篇之简易SDRAM控制器的verilog代码实现_第6张图片

大家可以看下，我们读出来的数据和写进来的数据是不是一样的呢？

你可能感兴趣的:(硬件)

  • Faiss Tips：高效向量搜索与聚类的利器 焦习娜Samantha
    FaissTips：高效向量搜索与聚类的利器faiss_tipsSomeusefultipsforfaiss项目地址:https://gitcode.com/gh_mirrors/fa/faiss_tips项目介绍Faiss是由FacebookAIResearch开发的一个用于高效相似性搜索和密集向量聚类的库。它支持多种硬件平台，包括CPU和GPU，能够在海量数据集上实现快速的近似最近邻搜索（AN
  • ARM中断处理过程 落汤老狗 嵌入式linux
    一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 简单说说关于shell中zsh和bash的选择 秋刀prince MacOS小猿们的开发日常bash
    希望文章能给到你启发和灵感～如果觉得文章对你有帮助的话，点赞+关注+收藏支持一下博主吧～阅读指南开篇说明一、基础环境说明1.1硬件环境1.2软件环境二、什么是shell、bash、zsh?2.1bash2.2zsh三、选择Bash还是Zsh？四、一些常见问题开篇说明本篇主要简单说明一下，shell中bash和zsh的区别和选择；我们经常会把这两个搞混，不知道什么时候用哪一个，以及怎么使用；一、基础
  • ARM V8 base instruction -- Debug instructions xiaozhiwise Assemblyarm
    /**Debuginstructions*/BRK#imm16进入monitormodedebug，那里有on-chipdebugmonitorcodeHLT#imm16进入haltmodedebug，连接有外部调试硬件
  • ARMv8 Debug __pop_ ARMv8ARM64架构linux运维
    内容来自DEN0024A_v8_architecture_PG.pdf本质ARMv8Debug是什么历史在ARMv4开始被引入,并已发展成一系列广泛的调试(debug1)和跟踪(trace)功能ARMv6和ARMv7-a新增了自托管调试(debug2)和性能评测(trace-enhance)ARMv8处理器提供硬件功能侵入式:调试工具能够对核心活动提供显著级别的控制非侵入式:以非侵入性方式收集有关
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • 【Python搞定车载自动化测试】——Python实现车载以太网DoIP刷写（含Python源码） 疯狂的机器人 Python搞定车载自动化pythonDoIPUDSISO142291SO13400Bootloadertcp/ip
    系列文章目录【Python搞定车载自动化测试】系列文章目录汇总文章目录系列文章目录前言一、环境搭建1.软件环境2.硬件环境二、目录结构三、源码展示1.DoIP诊断基础函数方法2.DoIP诊断业务函数方法3.27服务安全解锁4.DoIP自动化刷写四、测试日志1.测试日志五、完整源码链接前言随着智能电动汽车行业的发展，汽车=智能终端+四个轮子，各家车企都推出了各自的OTA升级方案，本章节主要介绍如何使
  • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化 xiaoli8748_软件开发 系统架构系统架构负载均衡nginx
    一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
  • C++常见知识掌握 nfgo c++开发语言
    1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
  • KVM虚拟机源代码分析【转】 xidianjiapei001 #虚拟化技术
    1.KVM结构及工作原理1.1KVM结构KVM基本结构有两部分组成。一个是KVMDriver，已经成为Linux内核的一个模块。负责虚拟机的创建，虚拟内存的分配，虚拟CPU寄存器的读写以及虚拟CPU的运行等。另外一个是稍微修改过的Qemu，用于模拟PC硬件的用户空间组件，提供I/O设备模型以及访问外设的途径。KVM基本结构如图1所示。其中KVM加入到标准的Linux内核中，被组织成Linux中标准
  • 嵌入式单片机中数码管基本实现方法 嵌入式开发星球 单片机项目实战操作之优秀单片机
    1.点亮数码管本节课利用已经学习的LED知识去控制一个8位数码管。本节的原理比较简单。不需要多少时间讲。更多时间是跟大家一起编码调试，从中学习一些编码思路和学习方法。1.1.什么是数码管数码管是什么？下图就是一个数码管从硬件上个看，其实就是8个LED组合在一起。8个LED应该有16个引脚，但是数码管上只有10个引脚。为什么呢？请看下图：1个LED有两个引脚，要控制LED，1个引脚接控制信号，另外一
  • 家庭教育，先家庭后教育：家庭是硬件，教育是软件 唯唯育家
    很多家长为孩子付出很多，也学习很多家庭教育课程，看很多家庭教育书籍，为什么还是教育孩子很困难？因为主次颠倒，没有抓住家庭教育的主干！家庭教育，很多家长只行使“教育”功能，忽视了“家庭”功能！家长总想着怎么教孩子，怎么教育孩子！如果单靠教育，就能把孩子教好，学校老师在教育方面比家长在行，孩子应该在学校就被教好了，哪还需要家庭教育？为什么只有学校教育不够，还需要家庭教育？家庭教育的主要功能不在“教育”
  • Rust是否会取代C/C++？Rust与C/C++的较量 AI与编程之窗 源码编译与开发rustc语言c++内存安全并发编程代码安全性能优化
    目录引言第一部分：Rust语言的优势内存安全性并发性性能社区和生态系统的成长第二部分：C/C++语言的优势和地位历史积淀和成熟度广泛的库和工具支持性能优化和硬件控制丰富的行业应用社区和行业支持第三部分：挑战和阻碍学习曲线现有代码库的迁移成本生态系统和工具链的完善度社区和人才培养行业应用和推广法规和标准化第四部分：未来趋势和可能性行业趋势教育和人才培养兼容和共存行业标准化企业支持和应用开源社区和生态
  • 如何建设数据中台（五）——数据汇集—打破企业数据孤岛 weixin_47088026 学习记录和总结中台数据中台程序人生经验分享
    数据汇集——打破企业数据孤岛要构建企业级数据中台，第一步就是将企业内部各个业务系统的数据实现互通互联，打破数据孤岛，主要通过数据汇聚和交换来实现。企业采集的数据可以是线上采集、线下数据采集、互联网数据采集、内部数据采集等。线上数据采集主要载体分为互联网和移动互联网两种，对应有系统平台、网页、H5、小程序、App等，可以采用前端或后端埋点方式采集数据。线下数据采集主要是通过硬件来采集，例如：WiFi
  • 云防火墙和Web应用防火墙（WAF）区别 快快小毛毛 前端网络
    随着互联网的进一步发展，Web应用防火墙（WAF）和云防火墙步入大家的视野。防火墙针对web应用拥有很好的保护作用，由硬件和软件组合，在内部网和外部网、专用网和公共网之间形成一道强有力的保护屏障，使用者可配置不同保护级别的防火墙，高级别的保护会阻止运营一些服务。那么，我们如何理解这两种防火墙，他们有什么区别？一、web防火墙Web应用防火墙,属于硬件级别防火墙（WebApplicationFire
  • MATLAB在无线通信系统测试和验证中的应用 2401_85812053 matlab开发语言
    在无线通信系统的开发过程中，测试和验证是确保系统性能满足设计要求的关键步骤。MATLAB提供了一系列的工具和功能，这些工具在无线通信系统的测试和验证中发挥着重要作用。本文将详细介绍MATLAB在无线通信系统测试和验证中的应用，包括信道建模、调制解调、射频（RF）链路分析以及硬件验证等方面。1.信道建模信道建模是无线通信系统设计中的关键环节，它影响着信号的传输质量和系统的整体性能。MATLAB提供了
  • 机电综合管理系统架构 小熊coder 机载系统系统架构
    文章目录一、机电综合管理系统架构1.系统概述2.架构层次3.核心组件二、余度管理1.余度概述2.硬件冗余3.软件冗余4.通信冗余三、总线架构1.MIL-STD-1553B总线2.ARINC429总线3.ARINC629总线4.AFDX/ARINC664总线四、未来发展趋势1.分布式架构2.高速网络3.智能化与自动化结语机电综合管理系统（ElectromechanicalManagementSyst
  • 【STM32系统】基于STM32设计的锂电池电量/电压检测报警器系统——文末完整资料下载（程序源码/电路原理图/电路PCB/设计文档/模块资料/元器件清单/实物图/答辩问题技巧/PPT模版等） 阿齐Archie 单片机嵌入式项目stm32嵌入式硬件单片机
    基于STM32设计的锂电池电量/电压检测报警器系统系统视频：摘要：本设计旨在研究一个基于STM32F103C8T6微控制器的锂电池电量/电压检测报警器系统，应用于便携式电子设备电池管理。系统通过STM32的ADC模块对锂电池电压进行采集，利用LCD1602显示模块实时显示电池电压，当检测到电池电量不足或电压异常时，蜂鸣器报警模块会发出警报提醒用户。系统采用简单的硬件结构和优化的软件架构，通过对实际
  • 使用STM32实现简单的智能温控系统 棂梓知识 stm32单片机嵌入式硬件
    智能温控系统是一种能够根据环境温度实时调整设备的工作状态的系统。在本篇文章中，我们将使用STM32微控制器来实现一个简单的智能温控系统。该系统将会有以下功能：实时监测环境温度，并显示在LCD屏幕上。当环境温度超过设定的阈值时，自动开启风扇。当环境温度恢复正常时，自动关闭风扇。通过按键模拟调节设定的阈值。系统设计首先，我们需要准备一些硬件设备。具体而言，我们需要以下组件：STM32F103C8T6开
  • Xilinx 7系列FPGA架构之器件配置（二） FPGA技术实战 FPGA器件架构XinxFPGA硬件设计fpga开发
    引言：本文我们介绍下7系列FPGA的配置接口，在进行硬件电路图设计时，这也是我们非常关心的内容，本文主要介绍配置模式的选择、配置管脚定义以及如何选择CFGBVS管脚电压及Bank14/15电压。1.概述Xilinx®7系列设备有五个配置接口。每个配置接口对应一个或多个配置模式和总线宽度，如表1所示。有关接口详细的时序信息，可以参阅相应的7系列FPGA数据手册。配置时序主要与FPGA配置时钟管脚CC
  • 硬伤 半盏清风逐明月
    硬伤，一般是指某人或某组织存在的一些无法改变的软肋，通常作用在人体上，比如：智商是硬伤、身高是硬伤、相貌是硬伤、残疾是硬伤等。硬伤指在文学作品中的一些常识性错误。也指非软件性伤害，一般就是指人为损坏或者碰撞等发生的硬件损坏。也指科幻小说中的技术设定上无法自我圆满解释或者与当前科学技术理论有冲突矛盾的描述。科幻小说中的技术设定上，无法自我圆满解释或者与当前科学技术理论有冲突矛盾的描述。身高乃我硬伤！
  • 通过与AI代理结对编程在集成课程中促进AI辅助学习循环的方法 神一样的老师 论文阅读分享人工智能结对编程学习
    本篇论文提出了一种新的方法论，利用人工智能（AI）技术的最新进展，为学生制定一个AI辅助的代码学习循环。这种方法在现有的学习过程中创新性地融入了结对编程，以增强学生的互动式学习体验。以下是论文的主要内容概述：摘要(Abstract)：提出了一种新方法，利用AI技术来辅助学生学习编程。方法包括将示例代码转化为脚手架代码作为练习，通过教师与AI的配对来实现。脚手架代码作为学生在硬件平台上迭代完成和调试
  • 操作系统简介 像风一样自由2020 操作系统linuxubuntuwindowsharmonyos
    操作系统简介操作系统（OperatingSystem，简称OS）是管理计算机硬件和软件资源的系统软件，为用户和应用程序提供接口。现今，操作系统种类繁多，主要分为桌面操作系统、服务器操作系统和移动操作系统等。以下是对目前存在的主要操作系统的详细介绍。1.Windows简介：Windows是由微软公司开发的系列图形界面操作系统，是全球使用最广泛的桌面操作系统之一。最新版本：截至2023年10月，最新版
  • oracle数据库安装和配置详细讲解 程序员小羊！ 运维数据库oracle
    大家好，我是程序员小羊！前言：Oracle数据库是全球广泛使用的关系型数据库管理系统(RDBMS)，提供高性能、可靠性、安全性和可扩展性，广泛应用于企业关键任务系统。下面详细介绍如何在CentOS系统上安装和配置Oracle数据库。1.前提条件1.1硬件要求内存：最小1GB，推荐2GB以上。硬盘：至少10GB的可用空间，视具体应用需求而定。1.2软件要求操作系统：CentOS7或CentOS8（确
  • 显卡新拐点，涨价或成必然！2019下半年如何选购笔记本？ 笔点酷玩
    电脑硬件的售价经常浮动，普通消费者完全无法摸透。这是一场持久战，你需要一颗强劲的心脏，以及一些超出预算的资金，降价还好办，万一涨价呢？比如近大半年内存、SSD的持续降价，不少装机人已经沉浸在历史舒适区难以自拔，ddr266616GB已从千元降至500价位段，ddr432008GB也能二百多入手，很难想象1年前还要600入手。除了内存和SSD，处于“换代”的显卡同样带来香甜价格，比如RX5808GB
  • GD32的虚拟串口CDC的一些注意事项 跳动的代码 单片机mcu
    在移植GD32CDC的USB虚拟串口，即CDC设备时，需要注意一下几点。我这里已GD32E503为例。1、时钟要正确，GD32E503的时钟必须为168M才能用2、硬件问题，GD32E503的USB必须要三个脚，除了DPDM外，还有DP一个上拉脚要配置。3、不要忘了移植中断部分代码，USB是有中断函数的。4、关于CDC的发送和接收问题：用官方的例程，发送和接收是没问题的。但是在我们代码里是不能直接
  • Kubernetes——组件 窒息う Kuberneteskubernetes容器
    文章目录K8S的优势核心架构角色与功能集群图例K8S的优势能管理大量跨主机容器快速部署应用快速扩展应用无缝对接新的应用节省资源，优化硬件资源的使用核心架构master（管理节点）node（计算节点）images（镜像节点）角色与功能Master功能提供集群的控制对集群进行全局决策检测和响应集群事件Master节点核心组件APIServer是整个系统的对外接口，提供客户端和其他组件调用后端元数据存储
  • Spring Boot实现多租户架构 spring_root springboot架构后端
    一、概述1什么是多租户架构？多租户架构是指在一个应用中支持多个租户（Tenant）同时访问，每个租户拥有独立的资源和数据，并且彼此之间完全隔离。通俗来说，多租户就是把一个应用按照客户的需求“分割”成多个独立的实例，每个实例互不干扰。2多租户架构的优势更好地满足不同租户的个性化需求。可以降低运维成本，减少硬件、网络等基础设施的投入。节约开发成本，通过复用代码，快速上线新的租户实例。增强了系统的可扩展
  • 单片机中断 woainizhongguo. STM32单片机原理解析篇单片机嵌入式硬件
    **在51单片机中，中断向量表的地址是如何被设置的？**在51单片机中，中断向量表的设置是中断系统的核心部分，它定义了中断服务程序的入口地址。以下是中断向量表的设置方法：中断向量表的位置：51单片机的中断向量表通常位于程序存储器的起始位置，即地址0x0000到0x000F（对于双字节的中断向量，实际占用0x0000到0x001F）。这些地址是固定的，由单片机的硬件设计决定。中断向量的分配：每个中断
  • xml解析 小猪猪08 xml
    1、DOM解析的步奏 准备工作：    1.创建DocumentBuilderFactory的对象    2.创建DocumentBuilder对象    3.通过DocumentBuilder对象的parse(String fileName)方法解析xml文件    4.通过Document的getElem
  • 每个开发人员都需要了解的一个SQL技巧 brotherlamp linuxlinux视频linux教程linux自学linux资料
      对于数据过滤而言CHECK约束已经算是相当不错了。然而它仍存在一些缺陷，比如说它们是应用到表上面的，但有的时候你可能希望指定一条约束，而它只在特定条件下才生效。 使用SQL标准的WITH CHECK OPTION子句就能完成这点，至少Oracle和SQL Server都实现了这个功能。下面是实现方式： CREATE TABLE books (   id &
  • Quartz——CronTrigger触发器 eksliang quartzCronTrigger
    转载请出自出处：http://eksliang.iteye.com/blog/2208295 一.概述 CronTrigger 能够提供比 SimpleTrigger 更有具体实际意义的调度方案，调度规则基于 Cron 表达式，CronTrigger 支持日历相关的重复时间间隔（比如每月第一个周一执行），而不是简单的周期时间间隔。 二.Cron表达式介绍 1）Cron表达式规则表 Quartz
  • Informatica基础 18289753290 InformaticaMonitormanagerworkflowDesigner
    1. 1）PowerCenter Designer：设计开发环境，定义源及目标数据结构；设计转换规则，生成ETL映射。 2）Workflow  Manager：合理地实现复杂的ETL工作流，基于时间，事件的作业调度 3）Workflow  Monitor：监控Workflow和Session运行情况，生成日志和报告 4）Repository  Manager：
  • linux下为程序创建启动和关闭的的sh文件，scrapyd为例 酷的飞上天空 scrapy
    对于一些未提供service管理的程序  每次启动和关闭都要加上全部路径，想到可以做一个简单的启动和关闭控制的文件   下面以scrapy启动server为例，文件名为run.sh：   #端口号，根据此端口号确定PID PORT=6800 #启动命令所在目录 HOME='/home/jmscra/scrapy/' #查询出监听了PORT端口
  • 人--自私与无私 永夜-极光
                今天上毛概课,老师提出一个问题--人是自私的还是无私的,根源是什么?               从客观的角度来看,人有自私的行为,也有无私的
  • Ubuntu安装NS-3 环境脚本 随便小屋 ubuntu
      将附件下载下来之后解压，将解压后的文件ns3environment.sh复制到下载目录下（其实放在哪里都可以，就是为了和我下面的命令相统一）。输入命令：   sudo ./ns3environment.sh >>result   这样系统就自动安装ns3的环境，运行的结果在result文件中，如果提示     com
  • 创业的简单感受 aijuans 创业的简单感受
           2009年11月9日我进入a公司实习，2012年4月26日，我离开a公司，开始自己的创业之旅。      今天是2012年5月30日，我忽然很想谈谈自己创业一个月的感受。 当初离开边锋时，我就对自己说：“自己选择的路，就是跪着也要把他走完”，我也做好了心理准备，准备迎接一次次的困难。我这次走出来，不管成败
  • 如何经营自己的独立人脉 aoyouzi 如何经营自己的独立人脉
    独立人脉不是父母、亲戚的人脉，而是自己主动投入构造的人脉圈。“放长线，钓大鱼”，先行投入才能产生后续产出。   现在几乎做所有的事情都需要人脉。以银行柜员为例，需要拉储户，而其本质就是社会人脉，就是社交！很多人都说，人脉我不行，因为我爸不行、我妈不行、我姨不行、我舅不行……我谁谁谁都不行，怎么能建立人脉？我这里说的人脉，是你的独立人脉。   以一个普通的银行柜员
  • JSP基础 百合不是茶 jsp注释隐式对象
      1,JSP语句的声明 <%! 声明 %> 　　 声明：这个就是提供java代码声明变量、方法等的场所。 表达式 <%= 表达式 %> 　　 这个相当于赋值，可以在页面上显示表达式的结果， 程序代码段/小型指令　<% 程序代码片段 %>   2,JSP的注释   <!-- -->
  • web.xml之session-config、mime-mapping bijian1013 javaweb.xmlservletsession-configmime-mapping
    session-config 1.定义： <session-config> <session-timeout>20</session-timeout> </session-config> 2.作用：用于定义整个WEB站点session的有效期限，单位是分钟。   mime-mapping 1.定义： <mime-m
  • 互联网开放平台（1） Bill_chen 互联网qq新浪微博百度腾讯
    现在各互联网公司都推出了自己的开放平台供用户创造自己的应用，互联网的开放技术欣欣向荣，自己总结如下： 1.淘宝开放平台(TOP) 网址：http://open.taobao.com/ 依赖淘宝强大的电子商务数据，将淘宝内部业务数据作为API开放出去，同时将外部ISV的应用引入进来。 目前TOP的三条主线： TOP访问网站：open.taobao.com ISV后台：my.open.ta
  • 【MongoDB学习笔记九】MongoDB索引 bit1129 mongodb
    索引 可以在任意列上建立索引 索引的构造和使用与传统关系型数据库几乎一样,适用于Oracle的索引优化技巧也适用于Mongodb 使用索引可以加快查询,但同时会降低修改,插入等的性能 内嵌文档照样可以建立使用索引 测试数据     var p1 = { "name":"Jack", "age&q
  • JDBC常用API之外的总结 白糖_ jdbc
    做JAVA的人玩JDBC肯定已经很熟练了，像DriverManager、Connection、ResultSet、Statement这些基本类大家肯定很常用啦，我不赘述那些诸如注册JDBC驱动、创建连接、获取数据集的API了，在这我介绍一些写框架时常用的API，大家共同学习吧。     ResultSetMetaData获取ResultSet对象的元数据信息
  • apache VelocityEngine使用记录 bozch VelocityEngine
    VelocityEngine是一个模板引擎，能够基于模板生成指定的文件代码。   使用方法如下：     VelocityEngine engine = new VelocityEngine();// 定义模板引擎     Properties properties = new Properties();// 模板引擎属
  • 编程之美-快速找出故障机器 bylijinnan 编程之美
    package beautyOfCoding; import java.util.Arrays; public class TheLostID { /*编程之美 假设一个机器仅存储一个标号为ID的记录，假设机器总量在10亿以下且ID是小于10亿的整数，假设每份数据保存两个备份，这样就有两个机器存储了同样的数据。 1.假设在某个时间得到一个数据文件ID的列表，是
  • 关于Java中redirect与forward的区别 chenbowen00 javaservlet
    在Servlet中两种实现： forward方式：request.getRequestDispatcher(“/somePage.jsp”).forward(request, response); redirect方式：response.sendRedirect(“/somePage.jsp”); forward是服务器内部重定向，程序收到请求后重新定向到另一个程序，客户机并不知
  • [信号与系统]人体最关键的两个信号节点 comsci 系统
            如果把人体看做是一个带生物磁场的导体,那么这个导体有两个很重要的节点,第一个在头部,中医的名称叫做 百汇穴, 另外一个节点在腰部,中医的名称叫做 命门         如果要保护自己的脑部磁场不受到外界有害信号的攻击,最简单的
  • oracle 存储过程执行权限 daizj oracle存储过程权限执行者调用者
    在数据库系统中存储过程是必不可少的利器，存储过程是预先编译好的为实现一个复杂功能的一段Sql语句集合。它的优点我就不多说了，说一下我碰到的问题吧。我在项目开发的过程中需要用存储过程来实现一个功能，其中涉及到判断一张表是否已经建立，没有建立就由存储过程来建立这张表。 CREATE OR REPLACE PROCEDURE TestProc  IS    fla
  • 为mysql数据库建立索引 dengkane mysql性能索引
    前些时候，一位颇高级的程序员居然问我什么叫做索引，令我感到十分的惊奇，我想这绝不会是沧海一粟，因为有成千上万的开发者（可能大部分是使用MySQL的）都没有受过有关数据库的正规培训，尽管他们都为客户做过一些开发，但却对如何为数据库建立适当的索引所知较少，因此我起了写一篇相关文章的念头。  最普通的情况，是为出现在where子句的字段建一个索引。为方便讲述，我们先建立一个如下的表。
  • 学习C语言常见误区 如何看懂一个程序 如何掌握一个程序以及几个小题目示例 dcj3sjt126com c算法
    如果看懂一个程序，分三步   1、流程   2、每个语句的功能   3、试数   如何学习一些小算法的程序 尝试自己去编程解决它，大部分人都自己无法解决 如果解决不了就看答案 关键是把答案看懂，这个是要花很大的精力，也是我们学习的重点 看懂之后尝试自己去修改程序，并且知道修改之后程序的不同输出结果的含义 照着答案去敲 调试错误
  • centos6.3安装php5.4报错 dcj3sjt126com centos6
    报错内容如下: Resolving Dependencies --> Running transaction check ---> Package php54w.x86_64 0:5.4.38-1.w6 will be installed --> Processing Dependency: php54w-common(x86-64) = 5.4.38-1.w6 for
  • JSONP请求 flyer0126 jsonp
          使用jsonp不能发起POST请求。 It is not possible to make a JSONP POST request. JSONP works by creating a <script> tag that executes Javascript from a different domain; it is not pos
  • Spring Security（03）——核心类简介 234390216 Authentication
    核心类简介 目录 1.1     Authentication 1.2     SecurityContextHolder 1.3     AuthenticationManager和AuthenticationProvider 1.3.1  &nb
  • 在CentOS上部署JAVA服务 java--hhf javajdkcentosJava服务
        本文将介绍如何在CentOS上运行Java Web服务，其中将包括如何搭建JAVA运行环境、如何开启端口号、如何使得服务在命令执行窗口关闭后依旧运行     第一步：卸载旧Linux自带的JDK ①查看本机JDK版本 java -version    结果如下 java version "1.6.0"
  • oracle、sqlserver、mysql常用函数对比[to_char、to_number、to_date] ldzyz007 oraclemysqlSQL Server
    oracle                                &n
  • 记Protocol Oriented Programming in Swift of WWDC 2015 ningandjin protocolWWDC 2015Swift2.0
    其实最先朋友让我就这个题目写篇文章的时候，我是拒绝的，因为觉得苹果就是在炒冷饭， 把已经流行了数十年的OOP中的“面向接口编程”还拿来讲，看完整个Session之后呢，虽然还是觉得在炒冷饭，但是毕竟还是加了蛋的，有些东西还是值得说说的。 通常谈到面向接口编程，其主要作用是把系统设计和具体实现分离开，让系统的每个部分都可以在不影响别的部分的情况下，改变自身的具体实现。接口的设计就反映了系统
  • 搭建 CentOS 6 服务器(15) - Keepalived、HAProxy、LVS rensanning keepalived
    （一）Keepalived （1）安装 # cd /usr/local/src # wget http://www.keepalived.org/software/keepalived-1.2.15.tar.gz # tar zxvf keepalived-1.2.15.tar.gz # cd keepalived-1.2.15 # ./configure # make &a
  • ORACLE数据库SCN和时间的互相转换 tomcat_oracle oraclesql
    SCN（System Change Number 简称 SCN）是当Oracle数据库更新后，由DBMS自动维护去累积递增的一个数字，可以理解成ORACLE数据库的时间戳，从ORACLE 10G开始，提供了函数可以实现SCN和时间进行相互转换； 　　 用途：在进行数据库的还原和利用数据库的闪回功能时，进行SCN和时间的转换就变的非常必要了； 　 　操作方法： 　　1、通过dbms_f
  • Spring MVC 方法注解拦截器 xp9802 spring mvc
    应用场景，在方法级别对本次调用进行鉴权，如api接口中有个用户唯一标示accessToken,对于有accessToken的每次请求可以在方法加一个拦截器，获得本次请求的用户，存放到request或者session域。 python中，之前在python flask中可以使用装饰器来对方法进行预处理，进行权限处理 先看一个实例,使用@access_required拦截： ?
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他