Palabras clave: tarea
Diferencias entre tareas y funciones
Al igual que las funciones, las tareas (task) se pueden usar para describir segmentos de código comunes y se pueden invocar en cualquier lugar dentro del módulo, haciendo que el código sea más intuitivo y legible. Las funciones generalmente se usan para varias conversiones y cálculos de lógica combinacional, mientras que las tareas son más como un procedimiento; no solo pueden completar la funcionalidad de las funciones, sino que también pueden incluir lógica de control temporal. A continuación se resumen las diferencias entre tareas y funciones:
| Punto de comparación | Función | Tarea |
|---|---|---|
| Entrada | Una función tiene al menos una entrada; la declaración de puertos no puede incluir el tipo inout | Una tarea puede no tener o tener múltiples entradas, y la declaración de puertos puede ser de tipo inout |
| Salida | Una función no tiene salidas | Una tarea puede no tener o tener múltiples salidas |
| Valor de retorno | Una función tiene al menos un valor de retorno | Una tarea no tiene valor de retorno |
| Momento de simulación | Una función siempre comienza a ejecutarse en el tiempo cero | Una tarea puede ejecutarse en un tiempo distinto de cero |
| Lógica secuencial | Una función no puede contener ninguna lógica de control secuencial | Una tarea no puede contener sentencias always, pero puede incluir otros controles de temporización, como sentencias de retardo |
| Llamada | Una función solo puede llamar a funciones, no puede llamar a tareas | Una tarea puede llamar a funciones y a tareas |
| Regla de escritura | Una función no puede aparecer como una sentencia independiente; solo puede colocarse en el lado derecho de una sentencia de asignación | Una tarea puede aparecer como una sentencia independiente dentro de un bloque de sentencias |
Tarea
Declaración de tarea
Una tarea se define en cualquier lugar del módulo y se puede referenciar en cualquier lugar dentro del módulo; su ámbito también se limita a este módulo.
Cuando un subprograma dentro del módulo cumpla cualquiera de las siguientes condiciones, se debe usar una tarea en lugar de una función.
- 1) El subprograma contiene lógica de control de temporización, por ejemplo retardos, control de eventos, etc.
- 2) No tiene variables de entrada
- 3) No tiene salidas o el número de salidas es mayor que 1
El formato de declaración de una tarea en Verilog es el siguiente:
task task_id ; port_declaration ; procedural_statement ; endtask
En una tarea, se utilizan las palabras clave input, output e inout para declarar los puertos. Los puertos de tipo input e inout pasan variables desde el exterior de la tarea al interior; los puertos de tipo output e inout devuelven al exterior los resultados cuando la tarea ha terminado de ejecutarse.
Al diseñar la lógica de la tarea, las variables de puerto declaradas como input pueden considerarse de tipo wire, y las variables de puerto declaradas como output pueden considerarse de tipo reg. Sin embargo, no es necesario volver a declarar los puertos de salida con reg.
Tampoco se debe usar la palabra clave assign al asignar señales de salida. Para evitar problemas de temporización, se recomienda usar asignación bloqueante para las señales de salida.
Por ejemplo, una tarea con función XOR con retardo se describe de la siguiente manera:
Ejemplo
input [N-1:0] numa;
input [N-1:0] numb;
output [N-1:0] numco ;
//output reg [N-1:0] numco ; //no es necesario volver a indicar el tipo reg, aunque indicarlo tampoco sería incorrecto
#3 numco = numa ^ numb ;
//assign #3 numco = numa ^ numb ; //no usar assign, porque la salida es reg por defecto
endtask
Al declarar una tarea, también se puede agregar un paréntesis después del nombre de la tarea para encerrar la declaración de puertos.
El diseño anterior se puede cambiar a:
Ejemplo
input [N-1:0] numa,
input [N-1:0] numb,
output [N-1:0] numco ) ;
#3 numco = numa ^ numb ;
endtask
Llamada de tarea
Una tarea puede aparecer como una sentencia independiente en un bloque initial o always; el formato de llamada es el siguiente:
task_id(input1, input2, …,outpu1, output2, …);
Al llamar a una tarea, los puertos deben corresponder en orden.
Las señales dentro del módulo conectadas a los puertos de entrada pueden ser de tipo wire o reg. Las señales dentro del módulo conectadas a los puertos de salida deben ser de tipo reg; esto es algo a tener en cuenta.
Realice una llamada a la tarea XOR anterior para almacenar en búfer el resultado XOR.
Ejemplo
#(parameter N = 4)
(
input clk ,
input rstn ,
input [N-1:0] a ,
input [N-1:0] b ,
output [N-1:0] co );
reg [N-1:0] co_t ;
always @(*) begin //llamada de tarea
xor_oper_iner(a, b, co_t);
end
reg [N-1:0] co_r ;
always @(posedge clk or negedge rstn) begin
if (!rstn) begin
co_r <= 'b0 ;
end
else begin
co_r <= co_t ; //almacenamiento en búfer de datos
end
end
assign co = co_r ;
/*------------ task -------*/
task xor_oper_iner;
input [N-1:0] numa;
input [N-1:0] numb;
output [N-1:0] numco ;
#3 numco = numa ^ numb ; //asignación bloqueante, fácil de controlar la temporización
endtask
endmodule
Para simular de forma sencilla el diseño XOR anterior, el testbench se describe a continuación.
Para la parte de estímulos usamos una tarea simple para describirla, lo que hace que los estímulos se vean más claros y concisos.
En realidad, el escenario de aplicación más común de las tareas es usarlas en testbenchs para simulación. Las tareas tampoco son compatibles con la síntesis en algunos compiladores.
Ejemplo
module test ;
reg clk, rstn ;
initial begin
rstn = 0 ;
#8 rstn = 1 ;
forever begin
clk = 0 ; # 5;
clk = 1 ; # 5;
end
end
reg [3:0] a, b;
wire [3:0] co ;
initial begin
a = 0 ;
b = 0 ;
sig_input(4'b1111, 4'b1001, a, b);
sig_input(4'b0110, 4'b1001, a, b);
sig_input(4'b1000, 4'b1001, a, b);
end
task sig_input ;
input [3:0] a ;
input [3:0] b ;
output [3:0] ao ;
output [3:0] bo ;
@(posedge clk) ;
ao = a ;
bo = b ;
endtask ; // sig_input
xor_oper u_xor_oper
(
.clk (clk ),
.rstn (rstn ),
.a (a ),
.b (b ),
.co (co ));
initial begin
forever begin
#100;
if ($time >= 1000) $finish ;
end
end
endmodule // test
El resultado de la simulación es el siguiente.
Como se muestra en la figura, el resultado lógico de la salida XOR es correcto, con un retardo de 3ns con respecto a la entrada.
Además, las señales conectadas a, b, co_t mantienen el mismo estado que las señales internas de la tarea numa, numb, numco.

Tareas que operan sobre variables globales
Debido a que una tarea puede considerarse como una asignación procedural, el tiempo en que la señal del puerto de salida de la tarea se devuelve es después de que se hayan ejecutado todas las sentencias de la tarea.
Las variables internas de una tarea solo son visibles dentro de la tarea. Si se desea observar en detalle el proceso de operación sobre las variables dentro de la tarea, es necesario declarar las variables a observar dentro del módulo y fuera de la tarea; se les puede llamar "variables globales".
Por ejemplo, existen las siguientes dos formas de intentar generar un reloj usando una tarea.
Ejemplo
task clk_rvs_iner ;
output clk_no_rvs ;
# 5 ; clk_no_rvs = 0 ;
# 5 ; clk_no_rvs = 1 ;
endtask
reg clk_test1 ;
always clk_rvs_iner(clk_test1);
//way2: use task to operate global varialbes to generating clk
reg clk_test2 ;
task clk_rvs_global ;
# 5 ; clk_test2 = 0 ;
# 5 ; clk_test2 = 1 ;
endtask // clk_rvs_iner
always clk_rvs_global;
El resultado de la simulación es el siguiente.
En la primera forma de descripción, aunque las variables internas de la tarea tienen operaciones de asignación de 0 y asignación de 1, el proceso de cambio intermedio no es visible; el resultado final solo puede ser el valor final de la señal de salida después de que se ejecuten todas las sentencias dentro de la tarea. Por lo tanto, la señal clk_test1 es constantemente 1, y esta forma no puede generar un reloj.
En la segunda forma de descripción, aunque no hay señales de puerto, se realizan operaciones procedurales directamente sobre la "variable global"; como esta variable global es visible para el módulo, el proceso de conmutación de la señal dentro de la tarea se reflejará en la señal clk_test2.
Tareas automáticas
Al igual que las funciones, en Verilog las variables locales de una tarea son estáticas cuando se invoca. Se puede usar la palabra clave automatic para declarar la tarea; de esta manera, los espacios de almacenamiento se pueden asignar dinámicamente en cada invocación, y cada tarea invocada opera de forma independiente sobre su propio espacio de direcciones exclusivo, sin afectar la ejecución concurrente de múltiples invocaciones de la misma tarea.
Si un segmento de código de una tarea se invoca en 2 o más lugares, debe declararse con la palabra clave automatic.
Cuando una tarea no se declara con automatic, y la tarea se invoca 2 veces, puede ocurrir interferencia entre señales, como se describe en el siguiente código:
Ejemplo
input [3:0] cnti ;
input en ;
output [3:0] cnto ;
if (en) cnto = cnti ;
endtask
reg en_cnt ;
reg [3:0] cnt_temp ;
initial begin
en_cnt = 1 ;
cnt_temp = 0 ;
#25 ; en_cnt = 0 ;
end
always #10 cnt_temp = cnt_temp + 1 ;
reg [3:0] cnt1, cnt2 ;
always @(posedge clk) test_flag(2, en_cnt, cnt1); //task(1)
always @(posedge clk) test_flag(cnt_temp, !en_cnt, cnt2);//task(2)
El resultado de la simulación es el siguiente.
Cuando en_cnt está en alto, la señal en en la tarea (1) está activa, y cnt1 puede generar el valor lógico correcto;
En este momento, la señal en en la tarea (2) no está habilitada, por lo que el valor de cnt2 es sobrescrito por la variable compartida cnt_temp impulsada por la tarea (1).
Cuando en_cnt está en bajo, la señal en en la tarea (2) está activa, por lo que la señal cnt2 en la tarea (2) puede generar el valor lógico correcto; mientras tanto, el valor de la señal cnt1 es sobrescrito una y otra vez, impulsado por el reloj, por la variable compartida cnt_temp impulsada por la tarea (2).
Se puede ver que, en dos invocaciones concurrentes, la tarea comparte espacio de almacenamiento, lo que hace que las señales se afecten entre sí.
Las demás descripciones permanecen igual; solo se agrega la palabra clave automatic en la declaración de la tarea anterior, como se muestra a continuación.
task automatic test_flag ;
El resultado de la simulación en este caso es el siguiente.
- Cuando en_cnt está en alto, la señal cnt1 en la tarea (1) puede generar el valor lógico correcto, y el valor de la señal cnt2 en la tarea (2) es X;
- Cuando en_cnt está en bajo, la señal cnt2 en la tarea (2) puede generar el valor lógico correcto, y el valor de la señal cnt1 en la tarea (1) es X;
Se puede ver que, en dos invocaciones concurrentes, debido a que los espacios de almacenamiento son independientes entre sí, no hay influencia entre las señales.

Descarga del código fuente
Download