basico

mail@pastecode.io avatar
unknown
plain_text
3 years ago
5.2 kB
2
Indexable
Never
// Módulo: timer
// Descripción: Temporizador
// Proyecto: Sistema de control de una barrera
// Autor: Jorge Juan-Chico <jjchico@dte.us.es>
// Copyright Universidad de Sevilla, Spain
// Fecha original: 21-02-2019

// Contador/temporizador

/*
   necesitamos un contador que pueda ser habilitado y deshabilitado,
   puesto a cero y que genere una señal de fin de cuenta cuando alcance
   un valor máximo.
 */
`timescale 1ns / 1ps

module servo_gate #(
    parameter FS = 100,             // clock frequency (Hz)
    parameter DELAY = 4             // whole range delay (s)
    )(
    input wire clk,                 // system clock
    input wire gate,                // servo angle (0-minimum, 1-maximum)
    output wire servo,              // output signal
    output reg finished = 1         // target angle reached
    );

    localparam MAXCOUNT = FS * DELAY;
    reg [31:0] counter = 0;

    // time counter control: stop at min. and max. value
    always @(posedge clk)
        if(gate == 1'b1 && counter < MAXCOUNT)
            counter <= counter + 1;
        else if(gate == 1'b0 && counter > 0)
            counter <= counter - 1;

    // set finished when at max. if open, or at min. if closed
    always @*
        if(gate == 1'b1 && counter == MAXCOUNT ||
           gate == 1'b0 && counter == 0)
            finished = 1'b1;
        else
            finished = 1'b0;

    assign servo = 1'bx;
endmodule
module timer #(
    parameter SYS_FREQ = 50000000,  // frecuencia de reloj del sistema (Hz)
    parameter DELAY = 10            // tiempo de expiración (s)
    )(
    input wire clk,         // reloj del sistema
    input wire clear,       // puesta a cero del sistema
    input wire enable,      // habilitación
    output wire eoc         // fin de cuenta
    );

    // valor del contador para generar la señal de fin de cuenta
    localparam MAX_COUNT = SYS_FREQ * DELAY;

    // estado y señales del contador
    /* debe tener suficientes bits para almacenar MAX_COUNT */
  	reg [31:0] count = 0;      // estado del contador

    // descripción del contador

    /*** código del contador ***/
  	always @(posedge clk)
      begin
        if (clear==1)
          	count<=0;
        else if (enable==1)
          	count<=count+1;
      end

    /*** generación fin de cuenta ***/
  	assign eoc = (count==MAX_COUNT) ? 1'b1 :1'b0;
endmodule // timer
module control (
    input wire clk,         // reloj del sistema
    input wire reset,       // puesta a cero del sistema
    input wire open,        // señal de apertura (activa en alto)
    input wire eoc,         // fin de cuenta del temporizador
    output reg clear,       // puesta a cero del contador
    output reg enable,      // habilitación del temporizador
    output reg gate         // salida de control (0-cerrar, 1-abrir)
    );

    // estados
    localparam CLOSED  = 2'd0,
               OPEN    = 2'd1;

               /*** añade más estados si es necesario ***/

    // variables de estado y próximo estado
  	reg [1:0] state = CLOSED;   
    reg [1:0] next_state;

    // proceso de cambio de estado

    /*** añade tu código ***/
  	always @(posedge clk)
      begin
        if (reset==0)
          state <= next_state;
      end


    // proceso de cálculo de próximo estado y salida

    /*** añade tu código ***/
  always @(state, open, eoc)
    begin
      {gate, clear, enable} = 0;
      next_state = CLOSED;
      case (state)
        CLOSED:
          begin
             clear = 1;
             if (open==1)
                next_state = OPEN;
          end        
        OPEN:
          begin
            {enable, gate} = 2'b11;
            if (open==1)
                begin
                	clear = 1;
              		next_state = OPEN;
                end
              else if (eoc == 0)
                next_state = OPEN;
            end
      endcase
    end
endmodule // control
module system #(
    parameter SYS_FREQ = 50000000   // frecuencia de reloj del sistema (Hz)
    )(
    input wire clk,         // reloj del sistema
    input wire reset,       // puesta a cero del sistema
    input wire open,        // señal de apertura (activa en alto)
    output wire gate,       // salida de control (0-cerrar, 1-abrir)
    output wire servo       // salida de control del servo
    );

    wire eoc;       // fin de cuenta del temporizador
    wire clear;     // puesta a cero del contador
    wire enable;    // habilitación del temporizador

    /*** instancia y conecta tres módulos: servo_gate, timer, control ***/

    servo_gate #(
        .FS(SYS_FREQ)
        ) inst_servo_gate (
        .clk(clk),
        .gate(gate),
        .servo(servo)
        // .finished(finished) // no hay que conectar (todavía)
        );

	timer #(
        .SYS_FREQ(SYS_FREQ)
    	) inst_timer (.clk(clk),
                      .clear(clear),
                      .enable(enable),
                      .eoc(eoc));
	
  	control inst_control (.clk(clk),
                          .reset(reset),
                          .open(open),
                          .eoc(eoc),
                          .clear(clear),
                          .enable(enable),
                          .gate(gate));	

endmodule // system