Subversion Repositories pdp1

`timescale 1ns / 1ps

//////////////////////////////////////////////////////////////////////////////////

// Engineer: Yann Vernier

// 

// Create Date:    21:37:32 02/19/2011 

// Design Name: 

// Module Name:    vector2scanline 

// Project Name: PDP-1

// Target Devices: Spartan 3A

// Tool versions: 

// Description: Converts vector data (exposed points) into raster video

//

// Dependencies: 

//

// Revision: $Id$

// $Log$

// Additional Comments: 

//

//////////////////////////////////////////////////////////////////////////////////

/*

 * Design: Two interfaces are provided, each with their own clock.

 *         The first is an XY plotting interface, where each new point

 *         is indicated by a rising edge on strobe_i.

 *         The second is the scanline/raster video port, where a pixel

 *         clock reads out a single scanline, and rising edges on

 *         newline_i and newframe_i indicate when a new or first line

 *         should start.

 *

 * The target design runs a pixel clock of 193MHz and plotting clock

 * of 50MHz, ensuring that no plotted point is missed.

 * A register to store the plotted point could be added instead, but

 * currently hold times are guaranteed to work (changes only occur on

 * a 200kHz cycle). Expect timing warnings, however.

 *

 * Internal structure: One ring buffer FIFO stores plotted points and their

 * respective age. Age is decremented only when the points are copied into

 * the scanline buffer (once per frame).

 * A dual-port scanline buffer is filled in with plotted points in a back-

 * buffer while the forward buffer is read out to video and subsequently

 * wiped.

 *

 * The FIFO could be factored out and converted to LFSR counting.

 *

 * TODO: Make the scanning stop once it has reached the edges.

 *       Connect to main design. Add next scanline ports, so double

 *       buffers do not delay everything one line.

 *

 */

module vector2scanline(

                       clk_xy_i,          // clock

                       strobe_i,      // new exposed pixel trigger

                       x_i,          // column of exposed pixel

                       y_i,          // row of exposed pixel

                       clk_fifo_i,

                       // Video output interface

                       clk_video_i,    // pixel clock

                       xout_i,         // current pixel column

                       yout_i,         // current pixel row

                       newline_i,      // line buffer swap signal

                       newframe_i,     // new frame signal

                       pixel_o,  // output pixel intensity, unregistered

                       /*AUTOARG*/

   // Inputs

   wipe_i

   );

   parameter X_WIDTH = 10;     // bit width of column coordinate

   parameter Y_WIDTH = 10;     // bit width of row coordinate

   parameter HIST_WIDTH = 10;  // log2 of maximum lit pixels (exposure buffer)

   parameter AGE_WIDTH = 8;    // width of exposure age counter

   input clk_xy_i;

   input strobe_i;

   input [X_WIDTH-1:0] x_i;

   input [Y_WIDTH-1:0] y_i;

   input               clk_fifo_i;

   input [AGE_WIDTH-1:0] wipe_i;

   input               clk_video_i;

   input [X_WIDTH-1:0] xout_i;

   input [Y_WIDTH-1:0] yout_i;

   input               newline_i, newframe_i;

   output [AGE_WIDTH-1:0] pixel_o;

   reg                    pixel_o;

   // Used for edge detection on strobe signals

   reg prev_strobe_i, prev_newline_i, prev_newframe_i;

   // Result of edge detectors

   wire strobe, newline, newframe;

   // positions and age of lit pixels

   reg [X_WIDTH+Y_WIDTH+AGE_WIDTH-1:0] exposures [(2**HIST_WIDTH)-1:0];

   // output register of exposed pixels buffer

   reg [X_WIDTH+Y_WIDTH+AGE_WIDTH-1:0] expr;

   // data for next pixel to store in exposure buffer

   wire [X_WIDTH-1:0]                   expx;

   wire [Y_WIDTH-1:0]                   expy;

   wire [AGE_WIDTH-1:0]         expi;

   // whether this pixel needs to be stored back in exposure buffer

   wire                                exposed;

   // whether this pixel belongs to the next (backbuffer) scanline

   wire                                rowmatch;

   // addresses for exposure buffer read and write ports

   reg [HIST_WIDTH-1:0]         exprptr=0, expwptr=0;

   // dual port scanline pixel buffer, stores intensity

   // double-buffered; one gets wiped as it is displayed

   // the other gets filled in with current exposures

   reg [AGE_WIDTH-1:0]                  scanlines [(2**X_WIDTH):0];

   // selection register for which scanline buffer is output/filled in

   reg                                 bufsel = 0;

   // address lines for the two memory ports

   wire [X_WIDTH:0]                     scanout_addr, lineplot_addr;

   wire                                scanout_clk, lineplot_clk;

   // Edge detectors for strobe lines

   always @(posedge clk_xy_i) prev_strobe_i <= strobe_i;

   assign strobe = strobe_i & ~prev_strobe_i;

   always @(posedge clk_video_i) prev_newline_i <= newline_i;

   assign newline = newline_i & ~prev_newline_i;

   always @(posedge clk_video_i) prev_newframe_i <= newframe_i;

   assign newframe = newframe_i & ~prev_newframe_i;

   // RAM read out of exposure buffer

   always @(posedge clk_fifo_i) begin

      // TODO: stop scanning until newline once we're through the entire buffer

      expr<=exposures[exprptr];

      if (!strobe) begin

         // do not skip current read position if strobe inserts a new pixel

         exprptr<=exprptr+1;

      end

   end

   // decode and mux: split fields from exposure buffer, or collect new at strobe

   assign expx = strobe?x_i:expr[X_WIDTH+Y_WIDTH+AGE_WIDTH-1:Y_WIDTH+AGE_WIDTH];

   assign expy = strobe?y_i:expr[Y_WIDTH+AGE_WIDTH-1:AGE_WIDTH];

   assign expi = strobe?(2**AGE_WIDTH)-1:expr[AGE_WIDTH-1:0];

   // detect whether pixel even needs to be stored back

   assign exposed = expi!=0;

   // detect whether pixel applies to current backbuffer

      // TODO: use a next line input port, the double buffering delays this data

      // by an entire scanline.

   assign rowmatch=(expy==yout_i);

   always @(posedge clk_fifo_i) begin

      // Feed incoming exposures into exposure buffer

      // TODO: stop scanning until newline once we're through the entire buffer

      if (exposed) begin

         exposures[expwptr] <= {expx, expy, expy==yout_i?expi-1:expi};

         expwptr <= expwptr+1;

      end

   end

   // Front buffer address

   assign scanout_addr = {bufsel,xout_i};

   assign scanout_clk = clk_video_i;

   always @(posedge scanout_clk) begin

      // Wipe front buffer

      scanlines[scanout_addr] <= wipe_i;

      // Read out front buffer

      pixel_o <= scanlines[scanout_addr];

   end

   // Back buffer address

   assign lineplot_addr = {~bufsel, expx};

   assign lineplot_clk = clk_fifo_i;

   always @(posedge lineplot_clk) begin

      //            pixel_o <= scanlines[lineplot_addr];

      // Store exposures for next scanline

      if (rowmatch) begin

         scanlines[lineplot_addr] <= expi;

      end

   end

   always @(posedge clk_video_i) begin

      // swap buffers when signaled

      if (newline) begin

         bufsel <= ~bufsel;

      end

   end

endmodule