Subversion Repositories uart2bus_testbench

//-------------------------------------------------------------------------------------------------
//
//                             UART2BUS VERIFICATION
//
//-------------------------------------------------------------------------------------------------
// CREATOR    : HANY SALAH
// PROJECT    : UART2BUS UVM TEST BENCH
// UNIT       : DEFINITION LIBRARY
//-------------------------------------------------------------------------------------------------
// TITLE      : UART DEFINITION LIBRARY 
// DESCRIPTION: THIS LIBRARY INCLUDES ALL THE USER MACROSES, TIMESCALE, TRANSACTION DATA TYPES, 
//              GLOBAL FUNCTIONS AND CONFIGURATION DATA TYPES 
//-------------------------------------------------------------------------------------------------
// LOG DETAILS
//-------------
// VERSION      NAME        DATE        DESCRIPTION
//    1       HANY SALAH    25122015    FILE CREATION
//    2       HANY SALAH    31122015    ADD DATA TYPE DEFINITIONS
//    3       HANY SALAH    11012016    ADD TIMING PARAMETERS DEFINITION
//    4       HANY SALAH    18022016    IMPROVE BLOCK DESCRIPTION
//-------------------------------------------------------------------------------------------------
// ALL COPYRIGHTS ARE RESERVED FOR THE PRODUCER ONLY .THIS FILE IS PRODUCED FOR OPENCORES MEMBERS 
// ONLY AND IT IS PROHIBTED TO USE THIS MATERIAL WITHOUT THE CREATOR'S PERMISSION
//-------------------------------------------------------------------------------------------------

`timescale 1ns/1ns

//-------------------------------------------------------------------------------------------------
//
//                               Definition Identifiers
//
//-------------------------------------------------------------------------------------------------
  
  // Define high value
  `define one 1'b1

  // Define low value
  `define zero 1'b0
  
  // Define size of address line
  `define size  16

  // 2 power size
  `define mem_size 65536 

  // ASCII of 'r'
  `define r   8'h72     

  // ASCII of 'R'
  `define R   8'h52

  // ASCII of 'w'
  `define w   8'h77

  // ASCII of 'W'
  `define W   8'h57

  // BINARY COMMAND PREFIX
  `define bin_prfx 8'h0

  // Single Space
  `define space 8'h20

  // Signel Tab
  `define tab   8'h09

  // LF
  `define LF    8'h0A

  // CR
  `define CR    8'h0D

  //UNIFIED ACK
  `define ACK   8'h5A

  // work on positive edge
  `define _posedge      1

  // work on negative edge
  `define _negedge      2

  // start with MSB
  `define msb_first     1

  // start with LSB
  `define lsb_first     2

  // Text Mode Command
  `define text_mode     1

  // Binary Mode Command
  `define binary_mode   2

  // Wrong Mode text Command
  `define wrong_mode_txt 3

  // Wrong Mode bin Command
  `define wrong_mode_binry 4

  // Read Command
  `define read_comm     1

  // write Command
  `define write_comm    2

  // nop Command
  `define nop_comm      3

  // wrong Read Command
  `define wrong_comm_read 4

  // wrong Write Command
  `define wrong_comm_write 5

  // Use single white space
  `define single_space  1

  // Use multiple white space
  `define tab_space     2

  // Use wrong space character
  `define space_wrong   3

  // use cr as eol
  `define cr_eol        1

  // use lf as eol
  `define lf_eol        2

  // Use wrong eol
  `define eol_wrong     3

  // request either address increment or acknowledge
  `define _yes          1

  // don't request either address increment or acknowledge
  `define _no           2

  // Use capital Leter
  `define capital_let   1

  // Use small letter
  `define small_let     2

  // accept arbitration
  `define accept        1

  // declain arbitration
  `define declain       2

  // Binary represnetation
  `define binary_rep    1

  // ASCII Representation
  `define ascii_rep     2

  // NOP Control
  `define nop_ctrl      2'b00

  // Read Control
  `define read_ctrl     2'b01

  // Write Control
  `define write_ctrl    2'b10

  // Invalid Control
  `define invalid_ctrl  2'b11

  `define _parityoff    1

  `define _parityeven   2

  `define _parityodd    3
//-------------------------------------------------------------------------------------------------
//
//                                    Timing Defines
//
//-------------------------------------------------------------------------------------------------
  // Define stability time
  `define stab               10

  // Define the period of global clock in terms of ns
  `define glob_clk_period    25

  // Define the period of baud clock in terms of ns
  `define buad_clk_period    8680

//-------------------------------------------------------------------------------------------------
//
//                                Configuration Data Type
//
//-------------------------------------------------------------------------------------------------

  // Represents the active edge
  typedef enum {pos_edge=1,            // Based on positive edge 
                neg_edge=2} act_edge;  // Based on negative edge

  // Represent the starting bit
  typedef enum {msb=1,                 // Most Significant bit first
                lsb=2}  start_bit;     // Least Significant bit first

//-------------------------------------------------------------------------------------------------
//
//                               New Data Type Definitions
//
//-------------------------------------------------------------------------------------------------

  // Represents the mode of command to be one of the following options {text, command, wrong}. 
  // Wrong command mode is used to send a tricky fault command to test our DUT.
  typedef enum {text=1,                         // Communicate using text mode
                binary=2,                       // Communicate using command mode
                wrong_mode_text=3,              // Communicate using wrong prefix(text mode)
                wrong_mode_bin=4} mode;         // Communicate using wrong prefix(binary mode)

  // Represents the type of the used white space to be one of the following options {single, tab, 
  // wrong}. Wrong type also is used to push tricky byte in the text mode.
  typedef enum {single=1,             // Using single space as a white space
                tab=2,                // Using tab as a white space
                wrong_space=3} space_type;  // Using wrong white space

  // Represents the type of end of line used to be one of the following choices{cr, lf, wrong}.
  // Wrong type is also used to push DUT in tricky manner.
  typedef enum {cr=1,                      // Using CR as EOL
                lf=2,                      // Using LF as EOL
                wrong_eol=3} eol_type;    // Using wrong EOL

  // Represents the command either to be one of the following choices {read, write, NOP}
  typedef enum {read=1,                     // Read Command
                write=2,                    // Write Command
                nop=3,                      // Make No Operation
                invalid_read=4,             // Invalid Command with read data
                invalid_write=5} command;   // Invalid Command with write data

  // Represents both acknowledge and incremental address request{yes, no}
  typedef enum {yes=1,                // Request Acknowledge
                no=2} req;            // Request No Acknowledge

  // Represents the type of prefix in text mode either to be {capital, small}.
  typedef enum {cap=1,                // Capital Letter
                smal=2} char_type;    // Small Letter

  // Represents the internal bus state either {accept, refuse}
  typedef enum {accept=1,             // Accept Bus Grant
                declain=2} arbit;     // Refuse Bus Grant

  // Define mode of data {ascii or binary}
  typedef enum {bin=1,                // Binary Representation (data remains unchanged)
                ascii=2} data_mode;   // ASCII Representation  (each niblle is converted into 
                                      // ASCII byte)

  // Define mode of the used parity
  typedef enum {parity_off=1,                 // Don't Add Parity Field
                parity_even=2,                // Add Even Parity to fields 
                parity_odd=3}  parity_mode ;  // Add Odd Parity to fields

//-------------------------------------------------------------------------------------------------
//
//                                 GLOBAL FUNCTIONS
//
//-------------------------------------------------------------------------------------------------

  // Binary To ASCII Conversion to convert nibble into ASCII byte through the following look-up-
  // table
  function byte bin_asci_conv (bit[3:0] data);
    byte temp;
    case (data)
      4'h0:
        begin
        temp = 8'h30;
        end
      4'h1:
        begin
        temp = 8'h31;
        end
      4'h2:
        begin
        temp = 8'h32;
        end
      4'h3:
        begin
        temp = 8'h33;
        end
      4'h4:
        begin
        temp = 8'h34;
        end
      4'h5:
        begin
        temp = 8'h35;
        end
      4'h6:
        begin
        temp = 8'h36;
        end
      4'h7:
        begin
        temp = 8'h37;
        end
      4'h8:
        begin
        temp = 8'h38;
        end
      4'h9:
        begin
        temp = 8'h39;
        end
      4'hA:
        begin
        temp = 8'h41;
        end
      4'hB:
        begin
        temp = 8'h42;
        end
      4'hC:
        begin
        temp = 8'h43;
        end
      4'hD:
        begin
        temp = 8'h44;
        end
      4'hE:
        begin
        temp = 8'h45;
        end
      4'hF:
        begin
        temp = 8'h46;
        end
    endcase
    return temp;
  endfunction:bin_asci_conv

  // ASCII To Binary Conversion is to convert ASCII byte into Binary nibble through the following 
  // Look-Up-Table
  function bit [3:0] asci_bin_conv (byte data);
    bit [3:0] temp;
    case (data)
      8'h30:
        begin
        temp = 4'h0;
        end
      8'h31:
        begin
        temp = 4'h1;
        end
      8'h32:
        begin
        temp = 4'h2;
        end
      8'h33:
        begin
        temp = 4'h3;
        end
      8'h34:
        begin
        temp = 4'h4;
        end
      8'h35:
        begin
        temp = 4'h5;
        end
      8'h36:
        begin
        temp = 4'h6;
        end
      8'h37:
        begin
        temp = 4'h7;
        end
      8'h38:
        begin
        temp = 4'h8;
        end
      8'h39:
        begin
        temp = 4'h9;
        end
      8'h41:
        begin
        temp = 4'hA;
        end
      8'h42:
        begin
        temp = 4'hB;
        end
      8'h43:
        begin
        temp = 4'hC;
        end
      8'h44:
        begin
        temp = 4'hD;
        end
      8'h45:
        begin
        temp = 4'hE;
        end
      8'h46:
        begin
        temp = 4'hF;
        end
      default:
        begin
        $error("undefined ascii symbol");
        end
    endcase
    return temp;
  endfunction:asci_bin_conv