PARTE I. TÉCNICAS DE DISEÑO ELECTRÓNICO …tamarisco.datsi.fi.upm.es/ASIGNATURAS/TC/apuntes/P_Tema3._VHD_… · 3.3 Sistemas secuenciales 3.3.1 Modelos para máquinas de estados

© Departamento de Arquitectura y Tecnología de Sistemas Informáticos - Facultad de Informática -Universidad Politécnica de Madrid - V. Rodellar

1

PARTE I. TÉCNICAS DE DISEÑO ELECTRÓNICO MEDIANTE LENGUAJES DE DESCRIPCIÓN HARDWARE

TEMA 3. Modelos de sistemas con VHDL

Curso 05/06

TEMA 3. Modelos de sistemas digitales3.1 Sistemas combinacionales

3.1.1 Modelado de retardos en funciones lógicas y estilos de descripción de arquitecturas.

3.1.2 Modelado de multiplexores en los estilos: algorítmico, flujo y estructural

3.1.3 Modelado de decodificadores en los estilos: algorítmico, flujo y estructural

3.2 Sistemas de memoria

3.2.1 Realización de biestables y latches en estilos: comportamiento, flujo y estructural. Entradas de control asíncronas y asíncronas. Relojes.

3.2.2 Realización de registros en estilo estructural. Reusabilidad. Bucles hardware.

3.2.3 Otros ejemplos.


2

3.3 Sistemas secuenciales

3.3.1 Modelos para máquinas de estados finitos

3.3.2 Realización de una máquina de Moore

3.3.3 Realización de una máquina de Mealy

Resumen

NOTA:

Los apartados 3.1 y 3.2 han sido desarrollados en las clases de teoría de temas anteriores y en las clases de laboratorio.


3

3.3.1 Modelos para máquinas de estados finitos (FSM)

- Modelos de Moore y Mealy

- Metodología de diseño de FSM

-Modelo algorítmico

- Un mal modelo

- Un modelo mejorado (Moore)

- Señales de Reset

- Varios PROCESS

- Modelo Data flow

- Modelo estructural

- Comparación entre los modelos de Mealy y Moore


4


5

Esquemas de Moore y Mealy (FSMs)Estructura de Moore Estructura de Mealy

Estado actual

Registro (Secuencial)

Estado futuro

(Combinacional)

Salidas

(combinacional)

inputs

inputs

clock

O(t)

S(t+1)

Estado actual


Estado futuro

(Combinacional)

Salidas

(combinacional)

O(t)

S(t+1)

S(t)S(t)

I(t)

I(t)

O(t) = F1( S(t))

S(t+1) = F2 (I(t), S(t))O(t) = F1( S(t), I(t))

S(t+1) = F2 (I(t), S(t))

clock

Metodología de diseño de FSMEtapas básicas

1) Diagrama-Tabla de estados, ASM

Niveles de Descripciónasociados con los HDLs

} Comportamiento o algorítmico

estado

salida

estado

salida

estado estado

entrada/salida

entrada Moore

Mealy

6

Metodología de diseño de FSMEtapas básicas Niveles de Descripción

asociados con los HDLs2) Ecuaciones del estado futuro y salidas

Estado actual Entradas Estado futuro Salidas

C1(t) C0(t) A(t) B(t) C1(t+1) C0(t+1) X(t) Y(t)

0 0 0 0 0 1 1 0

0 0 0 1 0 0 1 1

0 0 1 0 0 0 1 1

....... ........... ........... ..........

D1(t+1) = C1(t) A(t) + C0(t) A(t)’+ ......

D0(t+1) = C1(t) B(t) + C0(t) B(t)’+ ......

X(t) = ........ Y(t) = ................}

Flujo de datos o transferencia entre

registros

7

Metodología de diseño de FSMEtapas básicas Niveles de Descripción

asociados con los HDLs

3) Implementación del circuito

Componentes: Dispositivos lógicos

(puertas: NOT, AND ... MUX, DECODERS, .....)

Elementos de memoria ( Flip-Flops)

Conexionado

} Estructural

8

Modelado Algorítmico de FSM• Consideraciones Generales:

– El estilo del código tiene que ser independiente de la máquina de estados que se diseñe.

– Diferentes formas de modelar la misma máquina:• ¿Cuantos procesos PROCESS?• ¿Señales o variables?• ¿Sentencias IF o CASE?• El uso de la sentencia WAIT

– ¿Debe ser inicializada la máquina en un estado válido? ¿Hay que utilizar señal de reset?

– Portabilidad del código


9

Modelado algorítmico de una FSM - Un mal modeloMáquina de Moore

Retardo en la operación de lectura en una memoria RAM

Slow (S)Slow (S) Read (R)Read (R)

Write (W)Write (W)

ClockClock

LIBRARY IEEE;USE IEEE.STD_LOGIC_1164.all;

ENTITY fsm_bad ISPORT (

clock: IN STD_LOGIC; -- flanco subidaslow: IN STD_LOGIC; -- entrada controlread, write: OUT STD_LOGIC -- salidas

);END fsm_bad;

ST_READST_READ

R=1 W=0R=1 W=0

ST_WRITEST_WRITE

R=0 W=1R=0 W=1

ST_DELAYST_DELAY

R=0 W=0R=0 W=0

S = 0S = 0

S = 1S = 1


10

Modelado algorítmico de una FSM - Un mal modeloARCHITECTURE bad OF fsm_bad ISBEGINPROCESSTYPE state_type IS (ST_read, ST_write, ST_delay);VARIABLE state :state_type := ST_read;BEGINWAIT UNTIL rising_edge(clock);CASE state ISWHEN ST_read => read <= '1';

write <= '0';state := ST_write;

WHEN ST_write => read <= '0';write <= '1';IF (slow = '1') THEN state := ST_delay;

ELSEstate := ST_read;

END IF;WHEN ST_delay => read <= '0';

write <= '0';state := ST_read;

END CASE;END PROCESS;

END bad;

Retardo en la operación de lectura en una memoria RAM

ST_READST_READ

R=1 W=0R=1 W=0

ST_WRITEST_WRITE

R=0 W=1R=0 W=1

ST_DELAYST_DELAY

R=0 W=0R=0 W=0

S = 0S = 0

S = 1S = 1

Máquina de Moore

11

Resultados de simulación del modelo malo

12

ST_READST_READ

R=1 W=0R=1 W=0

ST_WRITEST_WRITE

R=0 W=1R=0 W=1

ST_DELAYST_DELAY

R=0 W=0R=0 W=0

S = 0S = 0

S = 1S = 1

CASE state ISWHEN ST_read => read <= '1';

write <= '0';state := ST_write;

WHEN ST_write => read <= '0';write <= '1';IF (slow = '1') THEN state := ST_delay;

ELSEstate := ST_read;

END IF;WHEN ST_delay => read <= '0';

write <= '0';state := ST_read;

END CASE;Máquina de Moore

¿Por qué este modelo es malo?1) El estado actual (state) está definido como una variable, no puede ser directamente monitorizado durante la simulación No puede activar un PROCESS.

2) Tres estados requieren dos FF, hay un estado sin utilizar. Ha de incluirse una señal de reset para poder salir del estado sin usar en el caso de que entrar en él.

3) El estado futuro y el estado actual no deben ser definidos en el mismo PROCESS. El estado futuro es combinacional, el estado actual es memoria

Pueden usarse:

- dos PROCESS uno para salidas y estado futuro y otro para la memoria - MEALY

- tres PROCESS uno para las salidas, otro estado futuro, otro memoria - MOORE

No deben mezclarse las partes No deben mezclarse las partes combinacionalescombinacionales y memoriay memoria


13

Moore Mealy

clock

clock

S(t+1)

Estado actual


Estado futuro

(Combinacional)

Salidas

(combinacional)

inputs

O(t)

S(t)

I(t)

O(t) = F1( S(t), I(t))

S(t+1) = F2 (I(t), S(t))

S(t+1)

inputs

Estado actual


Estado futuro y salidas

(Combinacional)

O(t)

S(t)

I(t)

Las salidas y el estado futurodependen de las mismas entradas, pueden agruparse en el mismoproceso


14

Mejorando el modelo – 3 PROCESS, RESET síncrono

Estado actual (secuencial)

Estado futuro (combinacional)

Salida ( combinacional)

LIBRARY IEEE;USE IEEE.STD_LOGIC_1164.all;

ENTITY fsm_good ISPORT (

clock : IN STD_LOGIC ; -- activo por flanco de subidaslow : IN STD_LOGIC ; -- entrada de control del sistemareset : IN STD_LOGIC ; -- activo a nivel altoread, write : OUT STD_LOGIC

);END fsm_good;

reset clock

read

writeMáquina de Moore slow


15


ST_READST_READ

R=1 W=0R=1 W=0

ST_WRITEST_WRITE

R=0 W=1R=0 W=1

ST_DELAYST_DELAY

R=0 W=0R=0 W=0

S = 0S = 0

S = 1S = 1

RESET

ARCHITECTURE good OF fsm_good ISTYPE state_type IS (ST_read, ST_write, ST_delay);SIGNAL current_state, next_state :state_type;

BEGIN output: PROCESS (current_state)BEGIN CASE current_state IS

WHEN ST_read => Read <= '1‘ ; Write <= '0';WHEN ST_write => Read <= '0‘ ; Write <= '1';WHEN ST_delay => Read <= '0‘ ; Write <= '0';

-- seria necesario poner la siguiente sentencia?WHEN OTHERS => Read <= '1 ; Write <= '0’;

END CASE;END PROCESS output;




reset clock

slow


16


ST_READST_READ

R=1 W=0R=1 W=0

ST_WRITEST_WRITE

R=0 W=1R=0 W=1

ST_DELAYST_DELAY

R=0 W=0R=0 W=0

S = 0S = 0

S = 1S = 1

RESET

future: PROCESS (current_state,slow)BEGIN CASE current_state IS

WHEN ST_read => next_state <= ST_write;WHEN ST_write => IF (slow = '1')

THEN next_state <= ST_delay;

ELSEnext_state <= ST_read;

END IF;WHEN ST_delay => next_state <= ST_read;WHEN OTHERS => next_state <= ST_read;

END CASE;END PROCESS future;

slow




clockreset


17


actual: PROCESSBEGINWAIT UNTIL rising_edge(clock);

-- reset síncronoIF (reset = '1') THEN

current_state <= ST_read;ELSE

current_state <= next_state;END IF;

END PROCESS actual;

END good;




reset


18

Resultados de simulación – 3 PROCESS, RESET síncrono I

ST_READST_READ

R=1 W=0R=1 W=0

ST_WRITEST_WRITE

R=0 W=1R=0 W=1

ST_DELAYST_DELAY

R=0 W=0R=0 W=0

S = 0S = 0

S = 1S = 1

RESET


19

Resultados de simulación – 3 PROCESS, RESET síncrono II

ST_READST_READ

R=1 W=0R=1 W=0

ST_WRITEST_WRITE

R=0 W=1R=0 W=1

ST_DELAYST_DELAY

R=0 W=0R=0 W=0

S = 0S = 0

S = 1S = 1

RESET


20

Resultados de simulación – 3 PROCESS, RESET síncrono III

ST_READST_READ

R=1 W=0R=1 W=0

ST_WRITEST_WRITE

R=0 W=1R=0 W=1

ST_DELAYST_DELAY

R=0 W=0R=0 W=0

S = 0S = 0

S = 1S = 1

RESET


21

Resultados de simulación – 3 PROCESS, RESET síncrono IV

ST_READST_READ

R=1 W=0R=1 W=0

ST_WRITEST_WRITE

R=0 W=1R=0 W=1

ST_DELAYST_DELAY

R=0 W=0R=0 W=0

S = 0S = 0

S = 1S = 1

RESET


22

Modelo utilizando la sentencia SELECT y RESET asíncrono

--Generación de las salidasWITH current_state SELECT

read <= '1' WHEN ST_read, '0' WHEN ST_write,'0' WHEN ST_delay,'1' WHEN OTHERS; --?

WITH current_state SELECTwrite <= '0' WHEN ST_read,

'1' WHEN ST_write,'0' WHEN ST_delay,'0' WHEN OTHERS; - -?




reset

El estado futuro lo dejamos igual que en la arquitectura con reset sincrono


23

Modelo utilizando la sentencia SELECT y RESET asíncrono

-- Generación del estado actual con reset asincrono-- Observese que ahora reset forma parte de la lista de

sensibilidad del process

actual: PROCESS (reset, clock)BEGIN

IF (reset = '1') THENcurrent_state <= ST_read;

ELSIF rising_edge (clock) THENcurrent_state <= next_state;

END IF;END PROCESS actual;

END good1;




reset


24

Resultados de simulación – Select, RESET asíncrono I

ST_READST_READ

R=1 W=0R=1 W=0

ST_WRITEST_WRITE

R=0 W=1R=0 W=1

ST_DELAYST_DELAY

R=0 W=0R=0 W=0

S = 0S = 0

S = 1S = 1

RESET


25

Resultados de simulación – Select, RESET asíncrono II

ST_READST_READ

R=1 W=0R=1 W=0

ST_WRITEST_WRITE

R=0 W=1R=0 W=1

ST_DELAYST_DELAY

R=0 W=0R=0 W=0

S = 0S = 0

S = 1S = 1

RESET


26

Resultados de simulación – Select, RESET asíncrono III

ST_READST_READ

R=1 W=0R=1 W=0

ST_WRITEST_WRITE

R=0 W=1R=0 W=1

ST_DELAYST_DELAY

R=0 W=0R=0 W=0

S = 0S = 0

S = 1S = 1

RESET


27

Resultados de simulación – Select, RESET asíncrono IV

ST_READST_READ

R=1 W=0R=1 W=0

ST_WRITEST_WRITE

R=0 W=1R=0 W=1

ST_DELAYST_DELAY

R=0 W=0R=0 W=0

S = 0S = 0

S = 1S = 1

RESET


28

Modelo en flujo de datosReset asíncrono

Tabla de transiciones

ST_READST_READ

R=1 W=0R=1 W=0

ST_WRITEST_WRITE

R=0 W=1R=0 W=1

ST_DELAYST_DELAY

R=0 W=0R=0 W=0

S = 0S = 0

S = 1S = 1

RESET

Entradas estado actual estado futuro salidas

slow q1 q0 d1 d0 read write

- 0 0 0 1 1 0

0 0 1 0 0 0 1

1 0 1 1 0 0 1

- 1 0 0 0 0 0

- 1 1 - (0) - (0) 0 0

Codificación de estados

ST_READ 00

ST_WRITE 01

ST_DELAY 10

d1 = slow q1’ q0 (reset’)

d0 = q1’ q0’ (reset’)

read = q1’ q0’

write = q1’ q0 29

ARCHITECTURE data_flow OF fsm_good IS

SIGNAL d1, d0, q1,q0: STD_LOGIC;

BEGIN

--generacion del estado futuro

d1 <= ((slow) AND (NOT q1) AND (q0));

d0 <= ((NOT q1) AND (NOT q0));

--generación de las salidas

read <= ((NOT q1) AND (NOT q0));

write <= ((NOT q1) AND (q0));

--generación del estado actual, reset asincrono

q1 <= '0' WHEN (reset= '1') ELSE d1 WHEN rising_edge(clock);

q0 <= '0' WHEN (reset= '1') ELSE d0 WHEN rising_edge(clock);

END data_flow;

Modelo en flujo de datosUtilizando asignación condicional de

señal solamente y función para la detección de flancos

d1 = slow q1’ q0 (reset’) d0 = q1’ q0’ (reset’)

read = q1’ q0’write = q1’ q0


30

Resultados de simulación del modelo en flujo de datos


31

1

Obsérvese el comportamiento asincrono de la señal de reset y como con el flanco de subida del reloj se actualizan los valores de la memoria

Modelo estructuralslow

d1 = slow q1’ q0 (reset’)

d0 = q1’ q0’(reset’)

read = q1’ q0’ = d0

write = q1’ q0

q0

Nq0

q1

Nq1

d0

d1

clock

clock

FF

FF

read

Aux1=write

Componentes necesarios:•Inversores

•Puertas AND

•Biestables con entrada de reset activa a nivel alto y reloj activo por flanco de subida

32reset

33

Modelo estructural

slowq0

Nq0q1

Nq1

d0

d1

clock

clock

FF

FF

read

Aux1=write

ARCHITECTURE structural OF fsm_good IS

COMPONENT inversor PORT (e:IN STD_LOGIC; s: OUT STD_LOGIC);END COMPONENT;COMPONENT and_2 PORT (e1,e2:IN STD_LOGIC; s: OUT STD_LOGIC);END COMPONENT;COMPONENT or_2 PORT (e1,e2:IN STD_LOGIC; s: OUT STD_LOGIC);END COMPONENT;COMPONENT biestable_D

PORT (clock, reset, d: IN STD_LOGIC; q: OUT STD_LOGIC);END COMPONENT;SIGNAL q1,Nq1,q0,Nq0,d1,d0, aux1: STD_LOGIC;

BEGIN

inv_q1 : inversor PORT MAP (e => q1, s => Nq1);inv_q0 : inversor PORT MAP (e => q0, s => Nq0);and_write: and_2 PORT MAP (e1 => Nq1, e2 => q0, s => aux1);and_d1 : and_2 PORT MAP (e1 => slow, e2 => aux1, s => d1);and_read : and_2 PORT MAP (e1 => Nq1, e2 => Nq0, s => d0);ff_d1 : biestable_D PORT MAP (clock => clock, reset => reset, d => d1, q =>q1);ff_d0 : biestable_D PORT MAP (clock => clock, reset => reset, d => d0, q =>q0);

read <= d0;write <= aux1;END structural;

Comparación entre los modelos de Mealy y Moore

clock

clock

S(t+1)

Estado actual


Estado futuro

(Combinacional)

Salidas

(combinacional)

inputs

O(t)

S(t)

I(t)

O(t) = F1( S(t), I(t))

S(t+1) = F2 (I(t), S(t))

S(t+1)

inputs

Estado actual


Estado futuro y salidas

(Combinacional)

O(t)

S(t)

I(t)

Las salidas y el estado futurodependen de las mismas entradas, pueden agruparse en el mismoproceso


34

3.3.2 Realización de un modelo de Mealy Ejemplo de un detector de la secuencia 010

ninguno uno dos tres

1/00/0 1/0 0/1

0/0

0/0

1/0 1/0

0/0


35

---------------------------------------------------------------------------------- © Universidad Politécnica de Madrid-- Se permite copia para fines de estudio---------------------------------------------------------------------------------- Proyecto : Maquinas de estados finitos-- Diseño : Detector de secuencia 010-- Nombre del fichero : Detector010_mealy_B.vhd-- Autor : Profesores de Tecnologia-- Fecha : 30/5/2005-- Versión : 1.0-- Resumen : Este fichero contiene la entidad y arquitectura de-- una una FSM que implementa un dectector de la -- secuencia 010 como una máquina de Mealy. Se han utilizado-- datos tipo bit. No tiene reset.---- Modificaciones:---- Fecha Autor Versión Descripción del cambio------------------------------------------------------------------------------------------------------------------------------------------------------------------ENTITY detector_secuencia_010 ISPORT (

clock : IN BIT; -- activo por flanco de subidaentrada: IN BIT; salida : OUT BIT

);END detector_secuencia_010;


36

37

ARCHITECTURE comportamiento OF detector_secuencia_010 IS--Parte declarativaTYPE estado IS (ninguno, uno, dos, tres);SIGNAL estado_actual: estado := ninguno;SIGNAL estado_futuro: estado;

--Comienzo de la arquitecturaBEGIN --Proceso para generar el estado futuro y salida--combinacional:PROCESS (entrada, estado_actual)BEGINCASE estado_actual ISWHEN ninguno => IF entrada = '0' THEN

estado_futuro <= uno;salida <= '0';

ELSEestado_futuro <= ninguno;salida <= '0';

END IF;WHEN uno =>

IF entrada = '1' THENestado_futuro <= dos;salida <= '0';

ELSEestado_futuro <= uno;

salida <= '0';END IF;

WHEN dos =>IF entrada = '0' THEN

estado_futuro <= tres;salida <= '1';

ELSEestado_futuro <= ninguno;salida <= '0';

END IF;WHEN tres => IF entrada = '1' THEN

estado_futuro <= ninguno;salida <= '0';

ELSEestado_futuro <= uno;salida <= '0';

END IF; END CASE;END PROCESS combinacional;

ninguno uno dos tres

1/00/0 1/0 0/1

0/0

0/0

1/0 1/0

0/0

--Proceso para actualizar la memoria

memoria:PROCESS (clock)BEGIN

IF (clock = '1' AND clock'EVENT) THENestado_actual <= estado_futuro;

ELSEestado_actual <= estado_actual;

END IF;

END PROCESS memoria;

END comportamiento;


38

ENTITY test_detsec_010 ISEND test_detsec_010;

ARCHITECTURE test OF test_detsec_010 IS--Parte declarativaCOMPONENT detector_secuencia_010 PORT (


);END COMPONENT;FOR U1: detector_secuencia_010 USE ENTITY WORK.detector_secuencia_010(comportamiento);CONSTANT ciclo: TIME := 10 ns;SIGNAL clock: BIT := '0';SIGNAL entrada, salida: BIT;--Descripcion de la arquitecturaBEGINclock <= NOT clock AFTER ciclo/2;U1: detector_secuencia_010 PORT MAP(clock => clock, entrada => entrada, salida => salida);entrada <= '0' AFTER 0 ns,

'1' AFTER 11 ns,'0' AFTER 19 ns,'1' AFTER 32 ns,'0' AFTER 46 ns,'1' AFTER 56 ns;

END test;


39

Mealy: la salida cambia con la generacióndel estado futuro a los 19 ns


40

3.3.3 Realización de un modelos de Moore Ejemplo de un detector de la secuencia 010

ninguno

/0

uno

/0

dos

/0

Tres

/1

10 1 0

0

0

1 1

0


41


42

---------------------------------------------------------------------------------- © Universidad Politécnica de Madrid-- Se permite copia para fines de estudio---------------------------------------------------------------------------------- Proyecto : Maquinas de estados finitos-- Diseño : Detector de secuencia 010-- Nombre del fichero : Detector010_moore_B.vhd-- Autor : Profesores Tecnología-- Fecha : 30/5/2005-- Versión : 1.0-- Resumen : Este fichero contiene la entidad y arquitectura de una una FSM que implementa un dectector de la -- secuencia 010 como una máquina de Moore. Se han utilizado datos tipo bit. No tiene reset. Se ha-- realizado mediante tres procesos---- Modificaciones:---- Fecha Autor Versión Descripción del cambio------------------------------------------------------------------------------------------------------------------------------------------------------------------ENTITY detector_secuencia_010 ISPORT (


);END detector_secuencia_010;


43

ARCHITECTURE comportamiento_moore OF detector_secuencia_010 IS--Parte declarativaTYPE estado IS (ninguno, uno, dos, tres);SIGNAL estado_actual: estado := ninguno;SIGNAL estado_futuro: estado;--Comienzo de la arquitecturaBEGIN --Proceso para generar la salidaresultado:

PROCESS (estado_actual)BEGINCASE estado_actual IS

WHEN ninguno => salida <= '0';

WHEN uno =>salida <= '0';

WHEN dos =>salida <= '0';

WHEN tres => salida <= '1';

END CASE;

END PROCESS resultado;

-- Proceso para generar el estado futurofuturo:PROCESS (entrada, estado_actual)

BEGINCASE estado_actual ISWHEN ninguno =>

IF entrada = '0' THENestado_futuro <= uno;

ELSEestado_futuro <= ninguno;

END IF; WHEN uno =>

IF entrada = '1' THENestado_futuro <= dos;


END IF;WHEN dos =>

IF entrada = '0' THENestado_futuro <= tres;

ELSEestado_futuro <= ninguno;

END IF;WHEN tres =>

IF entrada = '1' THENestado_futuro <= ninguno;


END IF; END CASE;END PROCESS futuro;


44


45

memoria:PROCESS (clock)BEGIN

IF (clock = '1' AND clock'EVENT) THENestado_actual <= estado_futuro;

ELSEestado_actual <= estado_actual;

END IF;

END PROCESS memoria;

END comportamiento_moore;

Moore: La salida cambia con el estado actual a los 25 ns


46

Ejercicio para los alumnos:1) Modificar el código anterior para utilizar datos

STD_LOGIC.

2) Realizar el diseño del detector en estilo de flujo de datos.

3) Realizar el diseño del detector en estilo estructural.

4) Realizar el test de los diseños anteriores con el test de la transparecia 39.

5) Analizar los resultados de simulación.


47

RESUMEN:

-Se han de utilizar datos de tipo enumerado para definir los estados de la máquina

-Han de definirse dos señales para llevar el control del estado actual y el futuro

-Si la máquina es de Moore se han de utilizar tres procesos

-Si la máquina es de Mealy es suficiente con utilizar dos procesos

-Si la maquina tiene reset síncrono no es necesario que reset aparezca en la lista de sensibilidad

- Si el reset es asíncrono necesariamente ha de aparecer en la lista de sensiblidad


48

Documents

PARTE I. TÉCNICAS DE DISEÑO ELECTRÓNICO …tamarisco.datsi.fi.upm.es/ASIGNATURAS/TC/apuntes/P_Tema3._VHD_… · 3.3 Sistemas secuenciales 3.3.1 Modelos para máquinas de estados