ellisgl

YL-3 Module

Dec 30th, 2015
139
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
VeriLog 13.88 KB | None | 0 0
  1. `timescale 1ns / 1ps
  2. /**
  3.  * YL-3 Driver (http://www.dx.com/p/diy8-x-seven-segment-displays-module-for-arduino-595-driver-250813#.VoG5SPkrKHs)
  4.  * Modules based on driver_74hc595.v from Crazy_Bingo
  5.  * clk    = Clock from FPGA (50 MHz - Mojo V3)
  6.  * rst_n  = reset (inverted)
  7.  * data   = 8x8 (64 bits of the array)
  8.  * load    = load the data
  9.  *
  10.  * ready  = Ready for data to be loaded
  11.  * sclk   = SCK / Serial Data Clock
  12.  * sda    = DIO / Serial Data
  13.  * slatch = RCK / Serial Latch
  14.  */
  15.  
  16. module driver_yl3(
  17.   input        clk,    // External Clock (50Mhz in my project)
  18.   input        rst_n,  // Inverted Reset
  19.   input [63:0] data,   // All 8 Characters (8 x 8 bits)
  20.   input        load,   // Load the data in
  21.  
  22.   output       ready,     // Ready for input to be loaded
  23.   output       sda,
  24.   output       sclk,
  25.   output       slatch
  26. );
  27.  
  28.   localparam  DELAY_CNT    = 4'd1;        // "Clock Divider"
  29.   localparam  ST_READY     = 2'b00;       // Ready to load data
  30.   localparam  ST_READCHR   = 2'b01;       // Read Character
  31.   localparam  ST_SHIFT     = 2'b10;       // Shift Character
  32.   localparam  ST_LATCH     = 2'b11;
  33.  
  34.   reg  [7:0]  chrarr [0:7];              // 8 Character array
  35.   reg  [3:0]  aidx;                      // Index of our array
  36.   reg  [7:0]  posreg;                    // Position on display
  37.   reg  [7:0]  chrreg;                    // Character in .GFEDBC inverse binary
  38.   reg  [15:0] dataout;                   // Concatinated position and character data to output to YL-3
  39.   reg  [4:0]  delaycnt;                  // Clock divider
  40.   reg  [4:0]  bitcnt;                    // Counter / state-machine for which bit has been shifted
  41.   reg  [2:0]  lchcnt;                    // Counter for holding the latch high.
  42.   reg  [1:0]  state;                     // Our current state
  43.   reg         loaded;                    // Data is loaded
  44.  
  45.   wire shift_flag          = (delaycnt == DELAY_CNT)    ? 1'b1 : 1'b0;
  46.   wire shift_clk           = (delaycnt > DELAY_CNT / 2) ? 1'b1 : 1'b0;
  47.  
  48.   // Load our data
  49.   always @(posedge clk or negedge rst_n)
  50.     begin
  51.       if(!rst_n)
  52.         begin
  53.           state     <= ST_READY;
  54.           chrarr[0]  = 0;
  55.           chrarr[1]  = 0;
  56.           chrarr[2]  = 0;
  57.           chrarr[3]  = 0;
  58.           chrarr[4]  = 0;
  59.           chrarr[5]  = 0;
  60.           chrarr[6]  = 0;
  61.           chrarr[7]  = 0;
  62.           aidx      <= 4'b0;
  63.           posreg    <= 8'b0;
  64.           chrreg    <= 8'b0;
  65.           dataout   <= 16'b1111_1111_1111_1111;
  66.           delaycnt  <= 4'b0;
  67.           lchcnt    <= 3'b0;
  68.           bitcnt    <= 5'b0;
  69.           loaded    <= 1'b0;
  70.         end
  71.       else
  72.         begin
  73.           // Divide clock for serial data clock.
  74.           if(state == ST_SHIFT)
  75.             begin
  76.               delaycnt <= (delaycnt == DELAY_CNT) ? 4'b0 : delaycnt + 1'b1;
  77.             end
  78.           else
  79.             begin
  80.               delaycnt <= 4'b0;
  81.             end
  82.  
  83.           // Deal with states
  84.           case(state)
  85.             ST_READY:
  86.               begin
  87.                 loaded <= 1'b0;
  88.  
  89.                 if(load == 1)
  90.                   begin
  91.                     if({chrarr[0], chrarr[1], chrarr[2], chrarr[3], chrarr[4], chrarr[5], chrarr[6], chrarr[7]} != data)
  92.                       begin
  93.                         //$display("NEEDS TO LOAD DATA");
  94.                         chrarr[0] = data[63:56];
  95.                         chrarr[1] = data[55:48];
  96.                         chrarr[2] = data[47:40];
  97.                         chrarr[3] = data[39:32];
  98.                         chrarr[4] = data[31:24];
  99.                         chrarr[5] = data[23:16];
  100.                         chrarr[6] = data[15:8];
  101.                         chrarr[7] = data[7:0];          
  102.                       end
  103.                     else
  104.                       begin
  105.                         //$display("DATA: %h", data);
  106.                         //$display("ARRY: %h", {chrarr[0], chrarr[1], chrarr[2], chrarr[3], chrarr[4], chrarr[5], chrarr[6], chrarr[7]});
  107.                         //$display("DATA LOADED");
  108.                         loaded <= 1'b0;
  109.                         state  <= ST_READCHR;
  110.                       end              
  111.                   end
  112.               end
  113.             ST_READCHR:
  114.               begin
  115.                 //$display("DATAOUT: %b", dataout);
  116.                 //$display("POSCHR : %b", {posreg, chrreg});
  117.                 if({posreg, chrreg} != dataout)
  118.                   begin
  119.                     //$display("DATAOUT NEEDS TO BE CREATED!");
  120.                     case (aidx)
  121.                       0:
  122.                         begin
  123.                           posreg <= 8'b0000_0001;
  124.                         end
  125.                       1:
  126.                         begin
  127.                           posreg <= 8'b0000_0010;
  128.                         end
  129.                       2:
  130.                         begin
  131.                           posreg <= 8'b0000_0100;
  132.                         end
  133.                       3:
  134.                         begin
  135.                           posreg <= 8'b0000_1000;
  136.                         end
  137.                       4:
  138.                         begin
  139.                           posreg <= 8'b0001_0000;
  140.                         end
  141.                       5:
  142.                         begin
  143.                           posreg <= 8'b0010_0000;
  144.                         end
  145.                       6:
  146.                         begin
  147.                           posreg <= 8'b0100_0000;
  148.                         end
  149.                       7:
  150.                         begin
  151.                           posreg <= 8'b1000_0000;
  152.                         end
  153.                       default:
  154.                         begin
  155.                           //posreg <= 8'b0000_0001;
  156.                         end
  157.                     endcase
  158.                    
  159.                     case (chrarr[aidx])
  160.                       "0", "O":
  161.                         begin
  162.                           chrreg <= 8'b1100_0000;
  163.                         end
  164.                       "1":
  165.                         begin
  166.                           chrreg <= 8'b1111_1001;
  167.                         end
  168.                       "2":
  169.                         begin
  170.                           chrreg <= 8'b1010_0100;
  171.                         end
  172.                       "3":
  173.                         begin
  174.                           chrreg <= 8'b1011_0000;
  175.                         end
  176.                       "4":
  177.                         begin
  178.                           chrreg <= 8'b1001_1001;
  179.                         end
  180.                       "5", "S", "s":
  181.                         begin
  182.                           chrreg <= 8'b1001_0010;
  183.                         end
  184.                       "6":
  185.                         begin
  186.                           chrreg <= 8'b1000_0010;
  187.                         end
  188.                       "7":
  189.                         begin
  190.                           chrreg <= 8'b1111_1000;
  191.                         end
  192.                       "8":
  193.                         begin
  194.                           chrreg <= 8'b1000_0000;
  195.                         end
  196.                       "9":
  197.                         begin
  198.                           chrreg <= 8'b1001_1000;
  199.                         end
  200.                       "A":
  201.                         begin
  202.                           chrreg <= 8'b1000_1000;
  203.                         end
  204.                       "a":
  205.                         begin
  206.                           chrreg <= 8'b1010_0000;
  207.                         end
  208.                       "B", "b":
  209.                         begin
  210.                           chrreg <= 8'b1000_0011;
  211.                         end
  212.                       "C":
  213.                         begin
  214.                           chrreg <= 8'b1100_0110;
  215.                         end
  216.                       "c":
  217.                         begin
  218.                           chrreg <= 8'b1010_0111;
  219.                         end
  220.                       "D", "d":
  221.                         begin
  222.                           chrreg <= 8'b1010_0001;
  223.                         end
  224.                       "E":
  225.                         begin
  226.                           chrreg <= 8'b1000_0110;
  227.                         end
  228.                       "e":
  229.                         begin
  230.                           chrreg <= 8'b1000_0100;
  231.                         end
  232.                       "F", "f":
  233.                         begin
  234.                           chrreg <= 8'b1000_1110;
  235.                         end
  236.                       "G", "g":
  237.                         begin
  238.                           chrreg <= 8'b1001_0000;
  239.                         end              
  240.                       "H":
  241.                         begin
  242.                           chrreg <= 8'b1000_1001;
  243.                         end
  244.                       "h":
  245.                         begin
  246.                           chrreg <= 8'b1000_1011;
  247.                         end
  248.                       "J":
  249.                         begin
  250.                           chrreg <= 8'b1111_0001;
  251.                         end
  252.                       "j":
  253.                         begin
  254.                           chrreg <= 8'b1111_0011;
  255.                         end
  256.                       "L":
  257.                         begin
  258.                           chrreg <= 8'b1100_0111;
  259.                         end
  260.                       "l":
  261.                         begin
  262.                           chrreg <= 8'b1110_0111;
  263.                         end
  264.                       "N", "n":
  265.                         begin
  266.                           chrreg <= 8'b1010_1011;
  267.                         end
  268.                       "o":
  269.                         begin
  270.                           chrreg <= 8'b1010_0011;
  271.                         end
  272.                       "P", "p":
  273.                         begin
  274.                           chrreg <= 8'b1000_1100;
  275.                         end
  276.                       "Q":
  277.                         begin
  278.                           chrreg <= 8'b100_0000;
  279.                         end
  280.                       "q":
  281.                         begin
  282.                           chrreg <= 8'b0010_0011;
  283.                         end
  284.                       "R":
  285.                         begin
  286.                           chrreg <= 8'b1100_1110;
  287.                         end
  288.                       "r":  
  289.                         begin
  290.                           chrreg <= 8'b1010_1111;
  291.                         end
  292.                       "T", "t":
  293.                         begin
  294.                           chrreg <= 8'b1000_0111;
  295.                         end
  296.                       "U":
  297.                         begin
  298.                           chrreg <= 8'b1100_0001;
  299.                         end
  300.                       "u":
  301.                         begin
  302.                           chrreg <= 8'b1110_0011;
  303.                         end
  304.                       "°":
  305.                         begin
  306.                           chrreg <= 8'b1001_1100;
  307.                         end
  308.                       ".":
  309.                         begin
  310.                           chrreg <= 8'b0111_1111;
  311.                         end
  312.                       default:
  313.                         begin
  314.                           chrreg <= 8'b1111_1111;
  315.                         end
  316.                     endcase
  317.                    
  318.                     dataout <= {posreg, chrreg};
  319.                   end
  320.                 else
  321.                   begin
  322.                     //$display("DATAOUT GOOD");
  323.                     //$display("DATAOUT: %b", dataout);
  324.                     aidx    <= aidx + 1'b1;
  325.                     state   <= ST_SHIFT;
  326.                   end          
  327.               end
  328.             ST_SHIFT:
  329.               begin
  330.                 if(shift_flag)
  331.                   begin
  332.                     if(bitcnt == 16)
  333.                       begin
  334.                         //$display("ST_SHIFT -> ST_LATCH");
  335.                         bitcnt <= 0;
  336.                         state  <= ST_LATCH;
  337.                       end
  338.                     else
  339.                       begin
  340.                         //$display("ST_SHIFT -> ST_SHIFT");
  341.                         //$display("BITCNT: %d", bitcnt);
  342.                         //$display("DATAOUT[%d]: %b", 15-bitcnt, dataout[15-bitcnt]);
  343.                         bitcnt <= bitcnt + 1'b1;
  344.                         state  <= ST_SHIFT;
  345.                       end
  346.                   end
  347.                 else
  348.                    begin
  349.                      // Is this else needed? Delay or sorts?
  350.                      bitcnt <= bitcnt;
  351.                      state  <= state;
  352.                    end
  353.               end
  354.             ST_LATCH:
  355.               begin
  356.                 if(lchcnt < 3)
  357.                   begin
  358.                     //$display("LCHCNT: %d", lchcnt);
  359.                     lchcnt <= lchcnt + 1'b1;
  360.                     state  <= ST_LATCH;
  361.                   end
  362.                 else
  363.                   begin
  364.                     lchcnt <= 0;
  365.  
  366.                     if(aidx < 8)
  367.                       begin
  368.                         //$display("ST_LATCH -> ST_READCHR");
  369.                         posreg  <= 8'b0;
  370.                         chrreg  <= 8'b0;
  371.                         dataout <= 16'b1;                  
  372.                         state   <= ST_READCHR;
  373.                       end
  374.                     else
  375.                       begin
  376.                         //$display("ST_LATCH -> ST_READY");
  377.                         state <= ST_READY;
  378.                       end
  379.                   end                
  380.               end
  381.           endcase
  382.         end
  383.     end
  384.  
  385.   // Assign the outputs.
  386.   assign ready  = (state == ST_READY && loaded == 0)  ? 1'b1                    : 1'b0;
  387.   assign sda    = (state == ST_SHIFT && bitcnt <  16) ? dataout[8'd15 - bitcnt] : 1'b0;
  388.   assign sclk   = (state == ST_SHIFT && bitcnt <  16) ? shift_clk               : 1'b0;
  389.   assign slatch = (state == ST_LATCH)                 ? 1'b1                    : 1'b0;
  390. endmodule
Advertisement
Add Comment
Please, Sign In to add comment