用Verilog将0 -99和100-199交替写入第三个FIFO内，并输出当FIFO1写入时FIFO2暂停

这是一个比较复杂的Verilog设计题目，需要使用多个模块来实现。下面是一种可能的设计方案：

首先，我们需要设计一个FIFO模块，可以使用双端队列（deque）来实现。这个模块应该包括以下接口：

module fifo
(
  input clk,       // 时钟信号
  input reset,     // 复位信号
  input [7:0] data_in,   // 数据输入
  input write_en,  // 写使能信号
  output [7:0] data_out, // 数据输出
  input read_en    // 读使能信号
);

接下来，我们可以使用两个FIFO模块来实现题目要求的功能。第一个FIFO模块用于存储0-99和100-199交替写入的数据，第二个FIFO模块用于暂存第一个FIFO模块中的数据。同时，我们还需要一个控制模块，用于控制数据的读写和FIFO2的暂停。

下面是一个可能的Verilog代码实现：

// FIFO模块
// 使用双端队列实现
module fifo
(
  input clk,       // 时钟信号
  input reset,     // 复位信号
  input [7:0] data_in,   // 数据输入
  input write_en,  // 写使能信号
  output [7:0] data_out, // 数据输出
  input read_en    // 读使能信号
);

  reg [7:0] data [0:255];   // 双端队列，最多可以存储256个数据
  reg [7:0] head, tail;     // 双端队列的头和尾指针
  reg [7:0] count;          // 双端队列中当前存储的数据个数

  always @(posedge clk or posedge reset) begin
    if (reset) begin
      head <= 0;
      tail <= 0;
      count <= 0;
    end else begin
      if (write_en && count < 256) begin
        data[head] <= data_in;
        head <= head + 1;
        count <= count + 1;
      end
      if (read_en && count > 0) begin
        data_out <= data[tail];
        tail <= tail + 1;
        count <= count - 1;
      end
    end
  end

endmodule

// 控制模块
module control
(
  input clk,     // 时钟信号
  input reset,   // 复位信号
  output fifo1_write_en, // FIFO1写使能信号
  output fifo2_write_en, // FIFO2写使能信号
  output fifo2_read_en   // FIFO2读使能信号
);

  reg [1:0] state;  // 状态机状态
  reg [7:0] count;  // 计数器，用于记录FIFO1已经写入的数据个数

  parameter IDLE = 2'b00;
  parameter WRITE1 = 2'b01;
  parameter WRITE2 = 2'b10;

  always @(posedge clk or posedge reset) begin
    if (reset) begin
      state <= IDLE;
      count <= 0;
      fifo1_write_en <= 1'b0;
      fifo2_write_en <= 1'b0;
      fifo2_read_en <= 1'b0;
    end else begin
      case (state)
        IDLE: begin
          fifo1_write_en <= 1'b1;
          fifo2_write_en <= 1'b0;
          fifo2_read_en <= 1'b0;
          if (count == 199) begin
            state <= WRITE2;
            count <= 0;
          end else begin
            state <= WRITE1;
            count <= count + 1;
          end
        end
        WRITE1: begin
          fifo1_write_en <= 1'b1;
          fifo2_write_en <= 1'b0;
          fifo2_read_en <= 1'b0;
          if (count == 199) begin
            state <= WRITE2;
            count <= 0;
          end else begin
            state <= IDLE;
            count <= count + 1;
          end
        end
        WRITE2: begin
          fifo1_write_en <= 1'b0;
          fifo2_write_en <= 1'b1;
          fifo2_read_en <= 1'b1;
          if (count == 99) begin
            state <= IDLE;
            count <= 0;
          end else begin
            state <= WRITE2;
            count <= count + 1;
          end
        end
      endcase
    end
  end

endmodule

// 顶层模块
module top
(
  input clk,     // 时钟信号
  input reset   // 复位信号
);

  wire [7:0] fifo1_data_out;   // FIFO1的数据输出
  wire [7:0] fifo2_data_out;   // FIFO2的数据输出
  wire fifo1_write_en;         // FIFO1的写使能信号
  wire fifo2_write_en;         // FIFO2的写使能信号
  wire fifo2_read_en;          // FIFO2的读使能信号

  fifo fifo1 (
    .clk(clk),
    .reset(reset),
    .data_in(fifo2_data_out),
    .write_en(fifo1_write_en),
    .data_out(fifo1_data_out),
    .read_en(1'b0)
  );

  fifo fifo2 (
    .clk(clk),
    .reset(reset),
    .data_in({8'h0, 8'h0}),
    .write_en(fifo2_write_en),
    .data_out(fifo2_data_out),
    .read_en(fifo2_read_en)
  );

  control ctrl (
    .clk(clk),
    .reset(reset),
    .fifo1_write_en(fifo1_write_en),
    .fifo2_write_en(fifo2_write_en),
    .fifo2_read_en(fifo2_read_en)
  );

endmodule

在这个设计中，我们使用了一个状态机来控制数据的读写和FIFO2的暂停。状态机共有三个状态：IDLE、WRITE1和WRITE2。在IDLE状态下，我们向FIFO1写入数据，同时将FIFO2的写使能信号和读使能信号设置为0，表示暂不读取FIFO2中的数据。当FIFO1中已经写入了199个数据时，我们进入WRITE2状态，开始向FIFO2写入数据，并且设置FIFO1的写使能信号为0，表示暂停向FIFO1写入数据。当FIFO2中已经写入了99个数据时，我们重新进入IDLE状态，开始向FIFO1写入数据。

需要注意的是，我们在FIFO2的输入端加入了一个8位的空数据，这是为了避免FIFO2中的数据在一开始就被输出。当FIFO1写入的数据个数达到199时，FIFO2开始读取数据，并且在读取完一条数据后，将空数据写入FIFO2的输入端。这样可以保证FIFO2中始终有一条空数据，避免输出重复的数据。

以上是一种可能的设计方案，仅供参考。实际上，这个题目的实现方法可能有很多种，具体的实现方式需要根据具体的需求和硬件平台进行调整。