存储设备：SRAM 芯片特性与异步 SRAM 读写测试（HDL）

• 异步 SRAM 的特性：

CY7C1041CV33

• CY7C1041CV33 Automotive —— 车规级高性能 CMOS 静态随机存取存储器（SRAM）芯片。适用于：
  • 汽车电子控制单元（ECU）
  • 仪表盘系统
  • ADAS（高级驾驶辅助系统）
  • 需要高可靠性、宽温范围和抗干扰能力的嵌入式系统

基本规格

• 容量与结构： 该 SRAM 的组织方式为 262,144 个字 × 16 位，即总容量为： 262,144 × 16 = 4,194,304 bits = 512 KB（字节） 地址线为 A0–A17，共 18 根，可寻址 2^18 = 262,144 个地址。
• 数据总线： 16 位宽，分为低字节（I/O0–I/O7）和高字节（I/O8–I/O15）。

关键控制信号

• 一般可以将 BHE 和 BLE 直接接地。

写操作（Write）

• 可以只写低字节、只写高字节，或同时写两个字节（当 BLE 和 BHE 都为 LOW 时）。
• 要向芯片写入数据，需满足以下条件：
  • CE（Chip Enable，片选） = LOW
  • WE（Write Enable，写使能） = LOW
• 此时，根据两个字节使能信号决定写入哪一部分数据：
  • 若 BLE（Byte Low Enable） = LOW： 将 I/O0–I/O7 上的数据写入由 A0–A17 指定的地址的 低字节。
  • 若 BHE（Byte High Enable） = LOW： 将 I/O8–I/O15 上的数据写入同一地址的 高字节。

读操作（Read）

• 同样支持单独读低字节、高字节，或同时读取整个 16 位数据。
• 要从芯片读取数据，需满足：
  • CE = LOW
  • OE（Output Enable，输出使能） = LOW
  • WE = HIGH（必须为高，防止误写）
• 此时：
  • 若 BLE = LOW： 指定地址的 低字节数据 出现在 I/O0–I/O7。
  • 若 BHE = LOW： 指定地址的 高字节数据 出现在 I/O8–I/O15。

高阻态（High-Impedance / Tri-State）

• 高阻态对多设备共享总线非常重要，避免总线冲突。在以下任一情况下，所有 I/O 引脚（I/O0–I/O15）进入高阻态（即断开输出，不驱动总线）：
  • CE = HIGH（芯片未被选中）
  • OE = HIGH（输出被禁用）
  • BLE = HIGH 且 BHE = HIGH（两个字节使能都无效）
  • 正在进行写操作（CE = LOW 且 WE = LOW）—— 此时 I/O 作为输入，输出自然关闭

异步 SRAM 芯片

• CY7C1041CV33 是一款 异步 SRAM 芯片（Asynchronous Static RAM），本身 没有内部状态机或复杂协议，其读写完全由外部逻辑通过控制信号（CE、OE、WE、BLE、BHE）直接驱动。
• 示例：Verilog SRAM 控制器（支持字节/字写入、字读取）

这段 Verilog 代码实现了一个异步 SRAM（CY7C1041CV33，512KB×16 位）的控制器模块，核心作用是对接 CPU/FIFO 等上层逻辑与物理 SRAM 芯片：

• 接收上层的读写请求、地址、数据和字节选择信号；
• 按照 SRAM 的时序要求生成控制信号（片选、读使能、写使能、字节使能等）；
• 处理双向数据总线的三态逻辑，完成数据读写，并通过应答信号告知上层操作完成。

// sram_controller.v // 注：CY7C1041CV33 是异步 SRAM 芯片，容量 512KB 字节（按 16 位宽算，共 2^18=262144 个存储单元）; 前提假设：系统时钟频率足够高，能满足 SRAM 的时序要求（如地址访问时间 tAA、写周期 tWC） // 模块定义，带参数化配置（方便适配不同规格 SRAM） module sram_controller #( parameter ADDR_WIDTH = 18, // 地址位宽：2^18=262144 个存储单元，对应 512KB(512×1024) parameter DATA_WIDTH = 16 // 数据位宽：16 位（与 SRAM 的 16 位宽匹配） )( // 时钟与复位 input clk, // 系统时钟（控制器同步时钟） input rst_n, // 低电平有效的异步复位 // CPU/FIFO 上层接口（控制器的输入/输出） input req, // 读写请求有效信号（高电平表示有请求） input wr_en, // 写使能：1=写操作，0=读操作 input [ADDR_WIDTH-1:0] addr, // 读写地址 input [DATA_WIDTH-1:0] wdata, // 写数据（CPU/FIFO→SRAM） output reg [DATA_WIDTH-1:0] rdata, // 读数据（SRAM→CPU/FIFO） input byte_sel_low, // 低字节选择：1=操作低 8 位（I/O0-7） input byte_sel_high, // 高字节选择：1=操作高 8 位（I/O8-15） output reg ack, // 应答有效信号：高电平表示操作完成 // SRAM 物理引脚接口（直接连接 SRAM 芯片） output reg [ADDR_WIDTH-1:0] sram_addr, // SRAM 地址线 inout [DATA_WIDTH-1:0] sram_dq, // SRAM 双向数据总线（关键：inout 类型） output reg sram_ce_n, // SRAM 片选（低有效） output reg sram_oe_n, // SRAM 读使能（低有效） output reg sram_we_n, // SRAM 写使能（低有效） output reg sram_ble_n, // SRAM 低字节使能（低有效，对应 I/O0-7） output reg sram_bhe_n // SRAM 高字节使能（低有效，对应 I/O8-15） ); // Tri-state data bus：三态数据总线控制（核心！处理双向总线） // 逻辑：只有写操作、片选有效、写使能有效时，才把 wdata 输出到 sram_dq；否则总线置高阻（z） assign sram_dq = (wr_en && !sram_ce_n && !sram_we_n) ? wdata : {DATA_WIDTH{1'bz}}; // Internal state (simple 2-cycle: setup + access)：内部状态机定义（简单 2 周期：建立 + 访问） reg [1:0] state; // 状态寄存器（2 位足够表示 3 个状态） // 状态常量定义（提高代码可读性） localparam IDLE = 2'b00, // 空闲态：无请求，所有 SRAM 控制信号置无效 SETUP = 2'b01, // 建立态：锁存地址、字节选择，置位片选和读写使能 ACCESS = 2'b10; // 访问态：读操作锁存数据，置位应答，完成一次交易 // 时序逻辑：状态机核心（时钟上升沿/复位下降沿触发） always @(posedge clk or negedge rst_n) begin if (!rst_n) begin // 异步复位（低有效）：所有信号置初始态 state <= IDLE; // 回到空闲态 ack <= 0; // 应答无效 sram_ce_n <= 1'b1; // 片选无效（高） sram_oe_n <= 1'b1; // 读使能无效（高） sram_we_n <= 1'b1; // 写使能无效（高） sram_ble_n <= 1'b1; // 低字节使能无效（高） sram_bhe_n <= 1'b1; // 高字节使能无效（高） sram_addr <= 0; // 地址置 0 end else begin // 非复位状态：状态机逻辑 ack <= 0; // 先默认应答无效（避免锁存，仅在 ACCESS 态置 1） case (state) IDLE: begin // 空闲态：等待请求 // 空闲态下，所有 SRAM 控制信号置无效（防止误操作） sram_ce_n <= 1'b1; sram_oe_n <= 1'b1; sram_we_n <= 1'b1; sram_ble_n <= 1'b1; sram_bhe_n <= 1'b1; // 检测到有效请求（req=1），进入建立态 if (req) begin sram_addr <= addr; // 锁存上层输入的地址 sram_ble_n <= ~byte_sel_low; // 字节使能：低有效，所以取反（sel=1→ble_n=0） sram_bhe_n <= ~byte_sel_high;// 同理，高字节选择→bhe_n 置低 state <= SETUP; // 进入建立态 end end SETUP: begin // 建立态：配置 SRAM 控制信号，为读写做准备 // Address and enables are already set：地址和字节使能已在 IDLE→SETUP 时锁存 // Assert CE and direction-specific enables：置位片选，并区分读写使能 sram_ce_n <= 1'b0; // 片选有效（低）：选中 SRAM 芯片 if (wr_en) begin // 写操作 sram_we_n <= 1'b0; // 写使能有效（低） sram_oe_n <= 1'b1; // 读使能无效（避免读写冲突） end else begin // 读操作 sram_we_n <= 1'b1; // 写使能无效 sram_oe_n <= 1'b0; // 读使能有效（低） end state <= ACCESS; // 进入访问态 end ACCESS: begin // 访问态：完成读写，置位应答 // Sample read data or hold write data：读操作锁存数据，写操作保持数据 if (~wr_en) begin // 仅读操作时 rdata <= sram_dq; // 锁存 SRAM 输出的读数据到 rdata end ack <= 1'b1; // 应答有效：告知上层本次操作完成 state <= IDLE;// 回到空闲态，等待下一次请求 end default: state <= IDLE; // 异常状态：回到空闲态（提高鲁棒性） endcase end end endmodule 

三态总线（sram_dq）

• SRAM 的数据线是双向的（读时 SRAM 输出，写时控制器输出），Verilog 中用 inout 类型表示；
• 控制器写 SRAM 时，把 wdata 驱动到 sram_dq；读 SRAM 时，sram_dq 置高阻（z），由 SRAM 驱动数据；
• 条件 (wr_en && !sram_ce_n && !sram_we_n) 确保只有'写操作 + 片选有效 + 写使能有效'时才输出数据，避免总线冲突。

Testbench

• Testbench 包含以下关键部分：
  • 时钟/复位生成：产生 50MHz 系统时钟（20ns 周期）和异步复位信号；
  • SRAM 行为模型：模拟 CY7C1041CV33 异步 SRAM 的读写行为（存储数据、响应控制信号）；
  • 激励生成：向控制器发送写请求→读请求（验证写后读）、单字节读写、全字读写等测试用例；
  • 结果检查：自动比对读回数据与写入数据，输出测试结果。

`timescale 1ns / 1ps module sram_controller_tb; // ====================== 1. 参数定义 ====================== parameter ADDR_WIDTH = 18; parameter DATA_WIDTH = 16; parameter CLK_PERIOD = 20; // 50 MHz // ====================== 2. 信号声明 ====================== reg clk; reg rst_n; reg req; reg wr_en; reg [ADDR_WIDTH-1:0] addr; reg [DATA_WIDTH-1:0] wdata; reg byte_sel_low; reg byte_sel_high; wire [DATA_WIDTH-1:0] rdata; wire ack; wire [ADDR_WIDTH-1:0] sram_addr; wire [DATA_WIDTH-1:0] sram_dq; wire sram_ce_n; wire sram_oe_n; wire sram_we_n; wire sram_ble_n; wire sram_bhe_n; // SRAM 行为模型存储 reg [7:0] sram_mem [0:(1<<ADDR_WIDTH)-1][1:0]; // [addr][0=low, 1=high] reg [DATA_WIDTH-1:0] sram_dq_out; // ====================== 3. 时钟生成 ====================== initial begin clk = 1'b0; forever #(CLK_PERIOD/2) clk = ~clk; end // ====================== 4. 实例化 DUT ====================== sram_controller #(.ADDR_WIDTH(ADDR_WIDTH), .DATA_WIDTH(DATA_WIDTH)) u_dut ( .clk(clk), .rst_n(rst_n), .req(req), .wr_en(wr_en), .addr(addr), .wdata(wdata), .byte_sel_low(byte_sel_low), .byte_sel_high(byte_sel_high), .ack(ack), .rdata(rdata), .sram_addr(sram_addr), .sram_dq(sram_dq), .sram_ce_n(sram_ce_n), .sram_oe_n(sram_oe_n), .sram_we_n(sram_we_n), .sram_ble_n(sram_ble_n), .sram_bhe_n(sram_bhe_n) ); // ====================== 5. SRAM 行为模型 ====================== assign sram_dq = (!sram_ce_n && !sram_oe_n && sram_we_n) ? sram_dq_out : {DATA_WIDTH{1'bz}}; // 写操作：在 WE_n 下降沿锁存数据（按字节使能） always @(negedge sram_we_n or negedge rst_n) begin if (!rst_n) begin // 初始化数据 end else if (!sram_ce_n) begin if (!sram_ble_n) sram_mem[sram_addr][0] = sram_dq[7:0]; if (!sram_bhe_n) sram_mem[sram_addr][1] = sram_dq[15:8]; end end // 读操作：在 OE_n 下降沿输出数据 always @(negedge sram_oe_n or negedge rst_n) begin if (!rst_n) begin sram_dq_out <= {DATA_WIDTH{1'b0}}; end else if (!sram_ce_n) begin sram_dq_out <= {16{1'b0}}; if (!sram_ble_n) sram_dq_out[7:0] <= sram_mem[sram_addr][0]; if (!sram_bhe_n) sram_dq_out[15:8] <= sram_mem[sram_addr][1]; end end // ====================== 6. 单次写入测试激励 ====================== initial begin // 初始化 rst_n = 1'b0; req = 1'b0; wr_en = 1'b0; addr = 0; wdata = 0; byte_sel_low = 1'b0; byte_sel_high = 1'b0; // 复位保持 2 个周期 repeat(2) @(posedge clk); rst_n = 1'b1; // === 单次写入：地址 0x1000，数据 0xABCD，全字节 === @(posedge clk); req = 1'b1; wr_en = 1'b1; addr = 18'h1000; wdata = 16'hABCD; byte_sel_low = 1'b1; // 使能低字节 byte_sel_high = 1'b1; // 使能高字节 wait(ack == 1'b1); // 等待写完成 @(posedge clk); req = 1'b0; // 撤销请求 // 仿真再跑几个周期以便观察波形 repeat(5) @(posedge clk); $finish; end endmodule 

• 用二维数组 sram_mem[地址][0/1] 模拟 SRAM 存储阵列（0=低字节，1=高字节），支持按字节读写；
• 双向总线 sram_dq 处理：读操作时 SRAM 输出数据（sram_dq_out），写操作时 SRAM 接收数据并存储；
• 响应 sram_we_n（写使能）和 sram_oe_n（读使能）的低电平有效信号，模拟真实 SRAM 的读写时序。
• 输入接口：
  • req：发起一次访问
  • wr_en：1=写，0=读
  • addr：18 位地址（A0–A17）
  • wdata：要写入的数据（16 位）
  • byte_sel_low/high：控制是否操作低/高字节（类似 ARM 的 strb）
• 输出：
  • ack：操作完成标志（单周期脉冲）
  • rdata：读取的数据（仅在读操作有效）
• SRAM 引脚：
  • 所有 _n 信号为低有效（符合芯片手册）
  • sram_dq 为双向三态总线

电气建议

• 对于 CY7C1041CV33 这类纯异步 SRAM，关键在于 满足最小脉冲宽度和地址建立/保持时间，通常需在 FPGA 中插入等待周期或使用 slower clock domain。
• 如果时钟较快（如 >50 MHz），建议在访问 SRAM 时插入 1~2 个等待周期，或使用 状态机延时 来满足 t（地址到数据有效时间，典型值 10–12 ns）。

// 新增延时计数器参数 parameter WAIT_CYCLES = 2; // 可配置等待周期，适配不同 SRAM 时序 reg [3:0] wait_cnt; // 延时计数器 // 在 SETUP 态后增加 WAIT 态，计数器减到 0 再进入 ACCESS 态 localparam IDLE=0, SETUP=1, WAIT=2, ACCESS=3; always @(posedge clk) begin if(state == WAIT) begin wait_cnt <= wait_cnt - 1'b1; if(wait_cnt == 0) state <= ACCESS; end end 

• 对于车规应用，请确保 FPGA I/O 电压与 SRAM 兼容（CY7C1041CV33 为 3.3V）

读写测试

• 实例化 sram_controller 控制器，自动生成 一次写操作（地址 0，数据 0x1234） ，紧接着执行 一次读操作（地址 0） ，将读回的数据输出到顶层端口（便于仿真观察）。SRAM 是易失性、无内部状态机的存储器，只要能正确完成'写入 → 读出 → 数据比对'流程，基本可判定芯片功能完好。
• 一般将 BHE 和 BLE 直接接地。

// sramt.v // Top-level module to perform: WRITE(addr=0, data=0x1234) → READ(addr=0) // 模块 sramt 实现（先写后读地址 0） Uses the provided 'sram_controller' controller module sramt ( input clk, input rst_n, // Debug output: read-back data from address 0 output reg [15:0] final_rdata, output reg done // High when both write and read are complete ); parameter ADDR_WIDTH = 18; parameter DATA_WIDTH = 16; // Internal signals for sram controller interface reg req; reg wr_en; reg [ADDR_WIDTH-1:0] addr; reg [DATA_WIDTH-1:0] wdata; reg byte_sel_low; reg byte_sel_high; wire [DATA_WIDTH-1:0] rdata; wire ack; // SRAM physical pins (not exposed at top level) wire [ADDR_WIDTH-1:0] sram_addr; wire [DATA_WIDTH-1:0] sram_dq; wire sram_ce_n; wire sram_oe_n; wire sram_we_n; wire sram_ble_n; wire sram_bhe_n; // State machine for test sequence typedef enum logic [1:0] { IDLE_ST, WRITE_REQ, WAIT_WRITE_ACK, READ_REQ, WAIT_READ_ACK, FINISHED } test_state_t; test_state_t test_state; // Instantiate the sram controller sram_controller #(.ADDR_WIDTH(ADDR_WIDTH), .DATA_WIDTH(DATA_WIDTH)) u_sram ( .clk(clk), .rst_n(rst_n), .req(req), .wr_en(wr_en), .addr(addr), .wdata(wdata), .byte_sel_low(byte_sel_low), .byte_sel_high(byte_sel_high), .rdata(rdata), .ack(ack), .sram_addr(sram_addr), .sram_dq(sram_dq), .sram_ce_n(sram_ce_n), .sram_oe_n(sram_oe_n), .sram_we_n(sram_we_n), .sram_ble_n(sram_ble_n), .sram_bhe_n(sram_bhe_n) ); // Test control logic always @(posedge clk or negedge rst_n) begin if (!rst_n) begin test_state <= IDLE_ST; req <= 1'b0; wr_en <= 1'b0; addr <= 18'd0; wdata <= 16'd0; byte_sel_low <= 1'b0; byte_sel_high <= 1'b0; final_rdata <= 16'd0; done <= 1'b0; end else begin req <= 1'b0; // default deassert request case (test_state) IDLE_ST: begin if (rst_n) begin test_state <= WRITE_REQ; end end WRITE_REQ: begin req <= 1'b1; wr_en <= 1'b1; addr <= 18'd0; // Address 0 wdata <= 16'h1234; // Write data byte_sel_low <= 1'b1; // Enable low byte byte_sel_high <= 1'b1; // Enable high byte test_state <= WAIT_WRITE_ACK; end WAIT_WRITE_ACK: begin if (ack) begin test_state <= READ_REQ; end end READ_REQ: begin req <= 1'b1; wr_en <= 1'b0; // Read operation addr <= 18'd0; // Address 0 byte_sel_low <= 1'b1; byte_sel_high <= 1'b1; test_state <= WAIT_READ_ACK; end WAIT_READ_ACK: begin if (ack) begin final_rdata <= rdata; // Capture read data done <= 1'b1; test_state <= FINISHED; end end FINISHED: begin done <= 1'b1; // Hold done high // Stay here forever end default: test_state <= IDLE_ST; endcase end end endmodule