Need a unique gift idea?
A Pastebin account makes a great Christmas gift
SHARE
TWEET

Untitled

a guest Dec 6th, 2018 166 Never
Upgrade to PRO!
ENDING IN00days00hours00mins00secs
 
  1. module Demo1(
  2.         CLOCK_50,                       //  On Board 50 MHz
  3.         // Your inputs and outputs here
  4.         SW,
  5.         KEY,
  6.         // The ports below are for the VGA output.  Do not change.
  7.         VGA_CLK,                        //  VGA Clock
  8.         VGA_HS,                         //  VGA H_SYNC
  9.         VGA_VS,                         //  VGA V_SYNC
  10.         VGA_BLANK_N,                        //  VGA BLANK
  11.         VGA_SYNC_N,                     //  VGA SYNC
  12.         VGA_R,                          //  VGA Red[9:0]
  13.         VGA_G,                          //  VGA Green[9:0]
  14.         VGA_B                           //  VGA Blue[9:0]
  15.                     );
  16.                    
  17.     input           CLOCK_50;               //  50 MHz
  18.     input   [9:0]   SW;
  19.     input   [3:0]   KEY;
  20.  
  21.     // Declare your inputs and outputs here
  22.     // Do not change the following outputs
  23.     output          VGA_CLK;                //  VGA Clock
  24.     output          VGA_HS;                 //  VGA H_SYNC
  25.     output          VGA_VS;                 //  VGA V_SYNC
  26.     output          VGA_BLANK_N;                //  VGA BLANK
  27.     output          VGA_SYNC_N;             //  VGA SYNC
  28.     output  [9:0]   VGA_R;                  //  VGA Red[9:0]
  29.     output  [9:0]   VGA_G;                  //  VGA Green[9:0]
  30.     output  [9:0]   VGA_B;                  //  VGA Blue[9:0]
  31.  
  32.     wire clk;
  33.     assign clk = CLOCK_50;
  34.     wire [2:0] colour;
  35.     wire [7:0] x;
  36.     wire [6:0] y;
  37.     wire write_en;
  38.     wire reset_n;
  39.     assign reset_n = KEY[3];
  40.      
  41.      
  42.     // Create an Instance of a VGA controller - there can be only one!
  43.     // Define the number of colours as well as the initial background
  44.     // image file (.MIF) for the controller.
  45.     /*
  46.     vga_adapter VGA(
  47.             .resetn(reset_n),
  48.             .clock(CLOCK_50),
  49.             .colour(colour),
  50.             .x(x),
  51.             .y(y),
  52.             .plot(write_en),
  53.             // Signals for the DAC to drive the monitor.
  54.             .VGA_R(VGA_R),
  55.             .VGA_G(VGA_G),
  56.             .VGA_B(VGA_B),
  57.             .VGA_HS(VGA_HS),
  58.             .VGA_VS(VGA_VS),
  59.             .VGA_BLANK(VGA_BLANK_N),
  60.             .VGA_SYNC(VGA_SYNC_N),
  61.             .VGA_CLK(VGA_CLK)
  62.             );
  63.            
  64.         defparam VGA.RESOLUTION = "160x120";
  65.         defparam VGA.MONOCHROME = "FALSE";
  66.         defparam VGA.BITS_PER_COLOUR_CHANNEL = 1;
  67.         defparam VGA.BACKGROUND_IMAGE = "black.mif";
  68.       */        
  69.    
  70.     wire draw, clear, save, go, dd_done, dump, wait_prime, waiting;
  71.     wire [7:0] count, offset;
  72.     wire [3:0] state;
  73.     wire [2:0] amp, past_amp, curr_amp, futr_amp;
  74.     wire [1:0] segment, mode;
  75.    
  76.    
  77.     draw_control dc1(
  78.         .clk(clk),
  79.         .reset_n(reset_n),
  80.         .clear_done(dd_done),   //dd_done
  81.         .draw_done(dd_done),
  82.         .go(go),           //from enable generator
  83.         .clear(clear), 
  84.         .waiting(waiting),
  85.         .draw(draw),
  86.         .save(save),
  87.         .segment(segment),
  88.         .current_state(state),
  89.         .wait_prime(wait_prime),
  90.         .offset(offset),
  91.         .write_en(write_en)
  92.     );
  93.  
  94.     wave_control wc1(   //temp needs to be read from music
  95.         .clk(clk),
  96.         .reset_n(reset_n),
  97.         .amp_in(SW[1:0]),
  98.         .amp_out(amp)
  99.     );
  100.    
  101.     draw_driver dd1(
  102.         .clk(clk),
  103.         .reset_n(reset_n),
  104.         .go(go),
  105.         .waiting(waiting),
  106.         .flag(dd_done),
  107.         .q(count),
  108.         .out_clk(dd_done)
  109.         );
  110.        
  111.     wave_datapath wd1(
  112.         .clk(clk),
  113.         .reset_n(reset_n),
  114.         .beat_sig(KEY[0]),
  115.         .amp(amp),
  116.         .past_amp(past_amp),
  117.         .curr_amp(curr_amp),
  118.         .futr_amp(futr_amp)
  119.     );
  120.    
  121.     interpret i1(
  122.         .clk(clk),
  123.         .reset_n(reset_n),
  124.         .past_amp(past_amp),
  125.         .curr_amp(curr_amp),
  126.         .futr_amp(futr_amp),
  127.         .count(count),
  128.         .segment(segment),
  129.         .draw(draw),
  130.         .clear(clear),
  131.         .offset(offset),
  132.         .x(x),
  133.         .y(y)
  134.     );
  135.    
  136.     enable_generator eg1(
  137.         .clk(clk),
  138.         .reset_n(reset_n),
  139.         .state(state),
  140.         .clear(clear),
  141.         .draw(draw),
  142.         .pamp(past_amp),
  143.         .camp(curr_amp),
  144.         .famp(futr_amp),  
  145.         .wait_prime(wait_prime),
  146.         .go(go)
  147.     );
  148.    
  149.     colour_controller cc1(
  150.         .clk(clk),
  151.         .reset_n(reset_n),
  152.         .in_mode(SW[9:8]),
  153.         .out_mode(mode)
  154.     );
  155.    
  156.     colour_datapath cd1(
  157.         .clk(clk),
  158.         .reset_n(reset_n),
  159.         .mode(mode),
  160.         .amp(amp),
  161.         .wait_prime(wait_prime),
  162.         .count(count),
  163.         .draw(draw),
  164.         .clear(clear),
  165.         .colour(colour)
  166.     );
  167.    
  168.                    
  169. endmodule
  170.  
  171. // dc1
  172. module draw_control(
  173.     input clk,
  174.     input reset_n,
  175.     input clear_done,
  176.     input draw_done,
  177.     input go,
  178.     output reg clear,      
  179.     output reg draw,
  180.     output reg waiting,
  181.     output reg save,
  182.     output reg [1:0] segment,
  183.     output reg [3:0] current_state,
  184.     output reg wait_prime,
  185.     output reg [7:0] offset,
  186.     output reg write_en
  187.     );
  188.    
  189.     reg [3:0] next_state;
  190.      
  191.     localparam  S_WAIT11    =   4'd0;   //wait (default case)
  192.     localparam  S_CLEAR1    =   4'd1;   //clear segment 1
  193.     localparam  S_WAIT12    =   4'd2;   //wait inbetween 1
  194.     localparam  S_DRAW1     =   4'd3;   //draw segment 1
  195.     localparam  S_WAIT21    =   4'd4;   //wait to redraw segment 2
  196.     localparam  S_CLEAR2    =   4'd5;   //clear segment 2
  197.     localparam  S_WAIT22    =   4'd6;   //wait inbetween 2
  198.     localparam  S_DRAW2     =   4'd7;   //draw segment 2
  199.     localparam  S_WAIT31    =   4'd8;   //wait to redraw segment 3
  200.     localparam  S_CLEAR3    =   4'd9;   //clear segment 3
  201.     localparam  S_WAIT32    =   4'd10;  //wait inbetween 3
  202.     localparam  S_DRAW3     =   4'd11;  //draw segment 3
  203.      
  204.     // Next state logic aka our state table
  205.    always@(posedge clk, posedge go)
  206.     begin: state_table
  207.             case(current_state)
  208.                 S_WAIT11: next_state = go           ? S_CLEAR1  : S_WAIT11;
  209.                 S_CLEAR1: next_state = clear_done   ? S_WAIT12  : S_CLEAR1;
  210.                 S_WAIT12: next_state = go           ? S_DRAW1   : S_WAIT12;
  211.                 S_DRAW1 : next_state = draw_done    ? S_WAIT21  : S_DRAW1;
  212.                 S_WAIT21: next_state = go           ? S_CLEAR2  : S_WAIT21;
  213.                 S_CLEAR2: next_state = clear_done   ? S_WAIT22  : S_CLEAR2;
  214.                 S_WAIT22: next_state = go           ? S_DRAW2   : S_WAIT22;
  215.                 S_DRAW2 : next_state = draw_done    ? S_WAIT31  : S_DRAW2;
  216.                 S_WAIT31: next_state = go           ? S_CLEAR3  : S_WAIT31;
  217.                 S_CLEAR3: next_state = clear_done   ? S_WAIT32  : S_CLEAR3;
  218.                 S_WAIT32: next_state = go           ? S_DRAW3   : S_WAIT32;
  219.                 S_DRAW3 : next_state = draw_done    ? S_WAIT11  : S_DRAW3;
  220.         endcase
  221.     end // state_table
  222.    
  223.     // Output logic aka all of our datapath control signals
  224.     always @(*)
  225.     begin: enable_signals
  226.         case (current_state)
  227.             S_WAIT11: begin
  228.                 offset <= 8'b0;
  229.                 wait_prime <= 1;
  230.                 waiting <= 1;
  231.                 clear <= 0;
  232.                 draw <= 0;
  233.                 save <= 0;
  234.                 segment <= 2'b10;
  235.                 write_en <= 1'b0;
  236.             end
  237.             S_CLEAR1: begin
  238.                 offset <= 8'b0;
  239.                 wait_prime <= 0;
  240.                 waiting <= 0;
  241.                 clear <= 1;
  242.                 draw <= 0;
  243.                 save <= 0;
  244.                 segment <= 2'b00;
  245.                 write_en <= 1'b1;
  246.             end
  247.             S_WAIT12: begin
  248.                 offset <= 8'b0;
  249.                 wait_prime <= 0;
  250.                 waiting <= 1;
  251.                 clear <= 0;
  252.                 draw <= 0;
  253.                 save <= 0;
  254.                 segment <= 2'b10;
  255.                 write_en <= 1'b0;
  256.             end
  257.             S_DRAW1: begin
  258.                 offset <= 8'b0;
  259.                 wait_prime <= 0;
  260.                 waiting <= 0;
  261.                 clear <= 0;
  262.                 draw <= 1;
  263.                 save <= 1;
  264.                 segment <= 2'b00;
  265.                 write_en <= 1'b1;
  266.             end
  267.             S_WAIT21: begin
  268.                 offset <= 8'd53;
  269.                 wait_prime <= 0;
  270.                 waiting <= 1;
  271.                 clear <= 0;
  272.                 draw <= 0;
  273.                 save <= 0;
  274.                 segment <= 2'b01;
  275.                 write_en <= 1'b0;
  276.             end
  277.             S_CLEAR2: begin
  278.                 offset <= 8'd53;
  279.                 wait_prime <= 0;
  280.                 waiting <= 0;
  281.                 clear <= 1;
  282.                 draw <= 0;
  283.                 save <= 0;
  284.                 segment <= 2'b01;
  285.                 write_en <= 1'b1;
  286.             end
  287.             S_WAIT22: begin
  288.                 offset <= 8'd53;
  289.                 wait_prime <= 0;
  290.                 waiting <= 1;
  291.                 clear <= 0;
  292.                 draw <= 0;
  293.                 save <= 0;
  294.                 segment <= 2'b01;
  295.                 write_en <= 1'b0;
  296.             end
  297.             S_DRAW2: begin
  298.                 offset <= 8'd53;
  299.                 wait_prime <= 0;
  300.                 waiting <= 0;
  301.                 clear <= 0;
  302.                 draw <= 1;
  303.                 save <= 1;
  304.                 segment <= 2'b01;
  305.                 write_en <= 1'b1;
  306.             end
  307.             S_WAIT31: begin
  308.                 offset <= 8'd106;
  309.                 wait_prime <= 0;
  310.                 waiting <= 1;
  311.                 clear <= 0;
  312.                 draw <= 0;
  313.                 save <= 0;
  314.                 segment <= 2'b10;
  315.                 write_en <= 1'b0;
  316.             end
  317.             S_CLEAR3: begin
  318.                 offset <= 8'd106;
  319.                 wait_prime <= 0;
  320.                 waiting <= 0;
  321.                 clear <= 1;
  322.                 draw <= 0;
  323.                 save <= 0;
  324.                 segment <= 2'b10;
  325.                 write_en <= 1'b1;
  326.             end
  327.             S_WAIT31: begin
  328.                 offset <= 8'd106;
  329.                 wait_prime <= 0;
  330.                 waiting <= 1;
  331.                 clear <= 0;
  332.                 draw <= 0;
  333.                 save <= 0;
  334.                 segment <= 2'b10;
  335.                 write_en <= 1'b0;
  336.             end
  337.             S_DRAW3: begin
  338.                 offset <= 8'd106;
  339.                 wait_prime <= 0;
  340.                 waiting <= 0;
  341.                 clear <= 0;
  342.                 draw <= 1;
  343.                 save <= 1;
  344.                 segment <= 2'b10;
  345.                 write_en <= 1'b1;
  346.             end
  347.             default begin
  348.                 wait_prime <= 0;
  349.                 waiting <= 1;
  350.                 clear <= 0;
  351.                 draw<= 0;
  352.                 save <= 0;
  353.                 segment <= 2'b11;
  354.                 write_en <= 1'b0;
  355.             end
  356.         endcase
  357.     end // enable_signals
  358.    
  359.     // current_state registers
  360.     always@(posedge clk)
  361.     begin: state_FFs
  362.         if(!reset_n)
  363.             current_state <= S_WAIT11;
  364.         else
  365.             current_state <= next_state;
  366.     end // state_FFS
  367. endmodule
  368.  
  369. // wc1
  370. module wave_control(
  371.     input clk,
  372.     input reset_n,
  373.     //input enable,
  374.     input [1:0] amp_in,
  375.     output reg [2:0] amp_out
  376.     //output reg play
  377.     );
  378.      
  379.     reg [2:0] current_state, next_state;
  380.  
  381.     // Next state logic aka our state table
  382.     always@(posedge clk)begin//: state_table
  383.         //if(enable)
  384.             next_state <= {1'b0,amp_in};
  385.             amp_out <= current_state;
  386.         //else
  387.         //    next_state <= current_state;
  388.     end // state_table
  389.    
  390.     // current_state registers
  391.     always@(posedge clk)
  392.     begin: state_FFs
  393.         if(!reset_n)
  394.             current_state <= 2'b00;
  395.         else
  396.             current_state <= next_state;
  397.     end // state_FFS
  398. endmodule
  399.  
  400. // dd1
  401. module draw_driver(
  402.     input clk,
  403.     input reset_n,
  404.     input go,
  405.     input waiting,
  406.     input flag,
  407.     output reg[7:0] q,
  408.     output reg out_clk
  409.     );
  410.     reg running;
  411.    
  412.     always@(posedge go, posedge flag)begin
  413.         if(flag == 1'b1)
  414.             running <= 0;
  415.         else if(go == 1'b1)
  416.             running <= 1;
  417.         else
  418.             running <= 0;
  419.     end
  420.      
  421.     always @(posedge clk, negedge reset_n)begin
  422.         if(reset_n == 1'b0)begin
  423.             q<=8'd55;
  424.             out_clk <= 0;
  425.         end
  426.         else if(running == 1'b1 && !waiting) begin
  427.             q<=q-8'b1;
  428.             if(q == 8'd0)begin
  429.                 out_clk <= 1;
  430.             end
  431.         end
  432.         else begin
  433.             q<=8'd55;
  434.             out_clk <= 0;
  435.         end
  436.     end
  437. endmodule
  438.  
  439. // wd1
  440. module wave_datapath(
  441.     input clk,
  442.     input reset_n,
  443.     input beat_sig,
  444.     input [2:0] amp,
  445.     output reg [2:0] past_amp,
  446.     output reg [2:0] curr_amp,
  447.     output reg [2:0] futr_amp
  448.     );
  449.    
  450.     reg [2:0] next_curr, next_past;
  451.    
  452.     always@(negedge reset_n, posedge beat_sig) begin
  453.         if(!reset_n)begin
  454.             next_past <= 3'b0;
  455.             next_curr <= 3'b0;
  456.         end
  457.         else begin
  458.             next_past <= next_curr;
  459.             next_curr <= amp;
  460.         end
  461.     end
  462.    
  463.     // Set the amplifiers
  464.     always @ (posedge clk, posedge beat_sig) begin
  465.         if(!reset_n)begin
  466.             past_amp <= 3'b0;
  467.             curr_amp <= 3'b0;
  468.             futr_amp <= 3'b0;
  469.         end
  470.         past_amp <= next_past;
  471.         curr_amp <= next_curr;
  472.         futr_amp <= amp;
  473.     end
  474. endmodule
  475.  
  476. //need to implement this
  477.  
  478. // i1
  479. module interpret(
  480.     input clk,
  481.     input reset_n,
  482.     input[2:0] past_amp,
  483.     input[2:0] curr_amp,
  484.     input[2:0] futr_amp,
  485.     input[7:0] count,
  486.     input [1:0] segment,
  487.     input draw,
  488.     input clear,
  489.     input [7:0] offset,
  490.     output reg [7:0] x,
  491.     output reg [6:0] y
  492.     );
  493.    
  494.     reg [2:0] left_seg;
  495.     reg [2:0] midl_seg;
  496.     reg [2:0] righ_seg;
  497.    
  498.     localparam y_pos = 7'd110;
  499.     localparam y_dif = 7'd20;
  500.    
  501.     always@ (posedge clk or negedge reset_n)begin
  502.         if(reset_n == 1'b0)begin
  503.             left_seg <= 3'b0;
  504.             midl_seg <= 3'b0;
  505.             righ_seg <= 3'b0;
  506.             x <= 8'b0;
  507.             y <= 7'b0;
  508.         end
  509.         else if(draw == 1'b1) begin
  510.             x <= count+offset;
  511.             case(segment)
  512.                 2'b00:begin
  513.                     left_seg <= past_amp;
  514.                     y <= y_pos-(y_dif*past_amp);
  515.                 end
  516.                 2'b01:begin
  517.                     midl_seg <= curr_amp;
  518.                     y <= y_pos-(y_dif*curr_amp);
  519.                 end
  520.                 2'b10:begin
  521.                     righ_seg <= futr_amp;
  522.                     y <= y_pos-(y_dif*futr_amp);
  523.                 end
  524.                 default: begin
  525.                 end            
  526.             endcase
  527.          
  528.         end
  529.         else if(clear == 1'b1)begin
  530.             x<=count+offset;
  531.             case(segment)
  532.                 2'b00: y <= y_pos-(y_dif*left_seg);
  533.                 2'b01: y <= y_pos-(y_dif*midl_seg);
  534.                 2'b10: y <= y_pos-(y_dif*righ_seg);
  535.                 default y<= y_pos;
  536.             endcase
  537.         end
  538.         else begin
  539.             x <= 8'b0;
  540.             y <= 7'b0;
  541.         end
  542.      end
  543. endmodule
  544.  
  545.  
  546. // eg1
  547. module enable_generator(
  548.     input clk,
  549.     input reset_n,
  550.     input clear,
  551.     input draw,
  552.     input [3:0] state,
  553.     input [2:0] pamp,
  554.     input [2:0] camp,
  555.     input [2:0] famp,
  556.     input wait_prime,
  557.     output reg go
  558.     );
  559.    
  560.     reg [2:0] prev_pamp;
  561.     reg [2:0] prev_camp;
  562.     reg [2:0] prev_famp;
  563.     reg [3:0] prev_state;
  564.    
  565.     always@(posedge clk)begin
  566.         if(reset_n == 1'b0)begin
  567.             go <= 1'b0;
  568.             prev_state <= state;
  569.             prev_pamp <= pamp;
  570.             prev_camp <= camp;
  571.             prev_famp <= famp;
  572.         end
  573.         else if (state != prev_state && !wait_prime && !clear && !draw)begin
  574.             go <= !go;
  575.         end
  576.         else if (pamp != prev_pamp)begin
  577.             go <= !go;
  578.         end
  579.         else if (camp != prev_camp)begin
  580.             go <= !go;
  581.         end
  582.         else if (famp != prev_famp)begin
  583.             go <= !go;
  584.         end
  585.         else
  586.             go = 1'b0;
  587.             prev_state <= state;
  588.             prev_pamp <= pamp;
  589.             prev_camp <= camp;
  590.             prev_famp <= famp;
  591.         end
  592. endmodule
  593.  
  594. //cc1
  595. module colour_controller(
  596.     input clk,
  597.     input reset_n,
  598.     input [1:0] in_mode,
  599.     output reg [1:0] out_mode
  600.     );
  601.    
  602.     reg [1:0] current_state, next_state;
  603.  
  604.     // Next state logic aka our state table
  605.     always@(posedge clk)begin//: state_table
  606.         next_state <= in_mode;
  607.         out_mode <= current_state;
  608.     end // state_table
  609.    
  610.     // current_state registers
  611.     always@(posedge clk)
  612.     begin: state_FFs
  613.         if(!reset_n)
  614.             current_state <= 2'b00;
  615.         else
  616.             current_state <= next_state;
  617.     end // state_FFS
  618. endmodule
  619.  
  620. //cd1
  621. module colour_datapath(
  622.     input clk,
  623.     input reset_n,
  624.     input [1:0] mode,
  625.     input [2:0] amp,
  626.     input wait_prime,
  627.     input [7:0] count,
  628.     input draw,
  629.     input clear,
  630.     output reg [2:0] colour
  631.     );
  632.        
  633.     reg [3:0] wait_colour;
  634.     always@(negedge wait_prime) begin
  635.         if(!reset_n)
  636.             wait_colour <= 3'b000;
  637.         else
  638.             wait_colour <= wait_colour + 3'b1;
  639.     end
  640.    
  641.    
  642.     always@(posedge clk)begin
  643.         if(!reset_n)
  644.             colour <= 3'b000;
  645.         else begin
  646.             if(clear == 1'b1)
  647.                 colour <= 3'b000;
  648.             else if(draw == 1'b1)begin
  649.                 case(mode)
  650.                     2'b00: colour <= 3'b111;
  651.                     2'b01:begin
  652.                         case(amp)
  653.                             3'b000: colour <= 3'b001;
  654.                             3'b001: colour <= 3'b011;
  655.                             3'b010: colour <= 3'b010;
  656.                             3'b011: colour <= 3'b111;
  657.                             default: colour <= 3'b000;
  658.                         endcase
  659.                     end
  660.                     2'b10: colour <= ((count % 6) + wait_colour);
  661.                     2'b11: colour <= wait_colour;
  662.                     default:colour <= 3'b000;
  663.                 endcase
  664.             end
  665.             else
  666.                 colour <= 3'b000;
  667.         end
  668.     end
  669. endmodule
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top