Estructura Case en Verilog
La estructura case en Verilog es una sentencia que evalúa una expresión numérica y en función de su valor ejecutará la sentencia o grupo de sentencias agrupadas en el primer caso que coincida. Si existen varias sentencias se deben agrupar en un bloque begin-end. Si no se cubren todos los posibles valores se debe hacer uso del caso por defecto, denominado default, el cual se ejecutará cuando ninguno de los casos anteriores se cumplan. La sintaxis de esta estructura es la siguiente:
[code language=»cpp»]
case (expresion)
caso 1:
begin
Sentencias 1;
end
caso 2:
begin
Sentencias 2;
end
…..
default:
begin
Sentencias D;
end
endcase
[/code]
Consideraciones de la Estructura Case en Verilog
- Esta estructura permite clasificar las acciones que se realizaran a partir de una variable digital.
- Toda estructura Case deberá de estar contenida en un bloque always @ (Array).
- Begin y end solo son necesarios en caso de realizar mas de una instrucción.
- Todas las combinatorias de las entradas deberán ser evaluadas en el bloque case.
Otras ejemplos de Verilog
Ejemplo de case en Verilog:
En este ejemplo se explicara el funcionamiento de la estructura case (casos).
Teniendo en cuenta 4 entradas y asignándole a una salida el valor de una de las entradas dependiendo la elección entre los cases en binario.
Código en Verilog para el case:
[code language=»cpp»]
module casos (A,B,C,D,S,Y);
input A, B, C, D;
input [1:0] S;
output reg Y;
always @ (A, B, C, D, S)
begin
case (S)
0: Y = A;
1: Y = B;
2: Y = C;
3: Y = D;
endcase
end
end module
[/code]
«Esta es la forma de declarar una variable con un tamaño superior a un bit:»
[code language=»cpp»]
input [1:0] S;
[/code]
En este ejemplo tenemos dos interruptores S0 y S1 dependiendo el valor en binario que estos dos formen (00b = 0, 01b = 1, 10b = 2, 11b = 3) asignara a la salida Y el valor de la entrada correspondiente a la misma (10b = 2 = C).
Practica Decodificador de BCD a 7 Segmentos en Verilog
Para la practica del decodificador BCD en Verilog, se utilizarán un tipo de interrupciones.
Practica DecoderBS
Desarrollaremos una aplicación en Verilog que permita hacer una decodificación de BCD a 7 segmentos. Utilizaremos 4 Switches, ya que sus estados son del 0 al 15 (4 bits = 16 estados) cada estado en binario asignará a la salida que enciendan diferentes LEDs dentro del 7 Segmentos asciendo un decodificador BCD a Decimal.
Código en Verilog con Compuertas Lógicas:
[code language=»cpp»]
module DecoderBS (A,B,C,D,a,b,c,d,e,f,g,com,test);
input A; //43
input B; //48
input C; //40
input D; //45
output a; //93
output b; //92
output c; //87
output d; //86
output e; //55
output f; //58
output g; //79
output com; //94
output test;
assign a = !( (~B & ~D) | (~A & C) | (~A & B & D) | (B & C) | (A & ~D) | (A & ~B & ~C));
assign b = !( (A & ~C & D) | (~B) | (~A & ~C & ~D) | (~A & C & D));
assign c = !( (~C & D) | (~A & B) | (A & ~B) | (~A & ~C) | (~A & D));
assign d = !( (B & ~C & D) | (~B & C & D) | (B & C & ~D) | (A & ~C & ~D) | (~A & ~B & ~D));
assign e = !( (~B & ~D) | (C & ~D) | (A & C) | (A & B));
assign f = !( (~C & ~D) | (B & ~D) | (~A & B & ~C) | (A & ~B) | (A & C));
assign g = !( (~A & C) | (~A & B) | (B & D) | (C & ~D) | (A & ~B & ~C));
assign com = 0;
assign test = 0;
endmodule
[/code]
Código 2 de la Estructura Case en Verilog
[code language=»cpp»]
module DecoderBS (Z, SEG, com);
input [3:0] Z;
output com;
output reg [6:0] SEG;
parameter [6:0] cero = 7’b0000001;
parameter [6:0] uno = 7’b1001111;
parameter [6:0] dos = 7’b0010010;
parameter [6:0] tres = 7’b0000110;
parameter [6:0] cuatro = 7’b1001100;
parameter [6:0] cinco = 7’b0100100;
parameter [6:0] seis = 7’b0100000;
parameter [6:0] siete = 7’b0001111;
parameter [6:0] ocho = 7’b0000000;
parameter [6:0] nueve = 7’b0000100;
parameter [6:0] A = 7’b0001000;
parameter [6:0] B = 7’b1100000;
parameter [6:0] C = 7’b0110001;
parameter [6:0] D = 7’b1000010;
parameter [6:0] E = 7’b0110000;
parameter [6:0] F = 7’b0111000;
parameter [6:0] guion = 7’b1111110;
always @ (Z)
begin
case(Z)
15: SEG = cero;
14: SEG = uno;
13: SEG = dos;
12: SEG = tres;
11: SEG = cuatro;
10: SEG = cinco;
9: SEG = seis;
8: SEG = siete;
7: SEG = ocho;
6: SEG = nueve;
5: SEG = A;
4: SEG = B;
3: SEG = C;
2: SEG = D;
1: SEG = E;
0: SEG = F;
default: SEG = guion;
endcase
end
assign com = 0;
endmodule
[/code]
Después de escribir el código lo compilaremos y nos aseguramos de haber cumplido los pasos de los anteriores tutoriales, lo siguiente será asignar los pines de entrada y salida de nuestro FPGA.
Nota: Los Display de 7 segmentos del FPGA se activan con Pull-Down.
Ya asignados los pines de entrada y salida compilaremos nuestro proyecto e instalaremos el dispositivo «USB Blaster» para hacer la interconección y programar el FPGA, seleccionamos el archivo .sof del proyecto y daremos «Start».
Nota: «Si es la primera vez que usas Quartus II y USB Blaster, es explicado más a detalle en el tutorial anterior».
Probaremos nuestro programa en físico con los display de 7 segmentos como salida en codificación decimal y los switches como entrada en codificación binaria.
muy bonita pagina