Monografías
Publicar | Monografías por Categorías | Directorio de Sitios | Software Educativo | Juegos Educativos | Cursos On-Line Gratis

 

Diseño de Sistemas Electrónicos - Monografía



 
DESCARGA ESTA MONOGRAFÍA EN TU PC
Esta monografía en formato html para que puedas guardarla en tu pc e imprimirla.



Vínculo Patrocinado




Aquí te dejamos la descarga gratuita
Nota: para poder abrir archivos html solo necesitas tener instalado internet explorer u otro navegador web.




Electrónica. UART en VHDL. Transmisor. Registros. Decodificador. Simulaciones temporales. Scripts



1. - INTRODUCCIÓN.



Se desea comunicar dos ordenadores personales vía serie. Para ello se implementará sobre una FPGA XC4005 un puerto serie bidireccional. De cara al usuario este puerto serie aparecerá como un periférico externo que se conecta al puerto paralelo del PC. Cuando se desea transmitir un dato vía serie, se manda a la FPGA dicho dato a través del puerto paralelo. De igual forma cuando se recibe un dato vía serie, éste queda almacenado en un registro interno de la FPGA al cual se puede acceder a través del puerto paralelo. Para controlar ciertos aspectos de su funcionamiento, el puerto serie dispondrá de un registro de configuración. Las situaciones de error que pudieran ocurrir durante la comunicación quedan reflejadas en un registro de estado.

El formato de la comunicación es fijo tal y como muestra en la siguiente figura:

- Un bit de start.
- Ocho bits de datos.
- Un bit de paridad par.
- Un bit de stop.

104807.gif

Para hacer más fácil la implementación del sistema se ha dividido el mismo en varios bloques diferentes. Teniendo en cuenta que únicamente hemos implementado la parte del transmisor, el sistema esta dividido en cinco bloques: Interface, Generador de Baud-Rate, Decodificador, Registros y Transmisor. A continuación se explica la función de cada uno de los bloques y cómo se han implementado en VHDL.

2. - DISEÑO DEL SISTEMA.



2.1. - Bloque generador del Baud Rate.



Este bloque se encarga de la generación del reloj de comunicaciones serie SCICLK a partir del reloj del sistema (MCLK) de 10 MHz. Se trata de un divisor de frecuencia programable de 16 bits. El valor por el que hay que dividir la frecuencia del reloj del sistema viene dado por dos registros de 8 bits: BAUDL (byte bajo) y BAUDH (byte alto). Con este bloque se obtiene la nueva frecuencia SCICLK:

104808.gif

dónde BBR representa el valor de 16 bits obtenido de los registros BAUDL y BAUDH. La velocidad de transmisión del sistema viene dada cada 8 ciclos del reloj SCICLK.

La solución adoptada para la realización de este bloque ha sido la siguiente, se ha optado por crear un contador de 16 bits con carga en paralelo implementado todo ello directamente en VHDL. Posteriormente se realizará un examen más profundo del código, a continuación se va a exponer el código:

library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_unsigned.all;

entity BAUDGEN is
port (
BAUD: in STD_LOGIC_VECTOR (15 downto 0);
BAUDHWR: in STD_LOGIC;
MCLK: in STD_LOGIC;
Rst: in STD_LOGIC;
COUNT: out STD_LOGIC_VECTOR (15 downto 0);
SCICLK: out STD_LOGIC
);
end BAUDGEN;

architecture BAUDGEN_arch of BAUDGEN is
signal cuenta: STD_LOGIC_VECTOR (15 downto 0 );
signal fin_cuenta:STD_LOGIC;
signal Carga:STD_LOGIC;
signal aux1:STD_LOGIC;
signal aux2:STD_LOGIC;
begin
– << enter your statements here >>
PCarga:process (MCLK)
begin
if MCLK =’1′ and MCLK’event then
aux1 < = BAUDHWR;
aux2 < = aux1;
end if;
end process PCarga;
PCuenta:process (MCLK, Rst)
variable BAUDBUF:STD_LOGIC_VECTOR (15 downto 0 );
begin
if Rst ='0' then
cuenta < = "0000000000000000";
elsif MCLK ='1' and MCLK'event then
if Carga ='1' then
cuenta < = BAUD;
BAUDBUF :=BAUD + "0000000000000001";
else
if (fin_cuenta='1')then
cuenta < = BAUDBUF;
else
cuenta < = cuenta - "0000000000000001";
end if;
end if;
end if;
end process PCuenta;

COUNT < = cuenta;
Carga < = '1' when ( (aux1='1') and (aux2='0') ) else '0';

PFinCuenta:process(cuenta )
begin
if ((cuenta = "0000000000000000") ) then
SCICLK < = '1';
fin_cuenta < = '1';

else
SCICLK < = '0';
fin_cuenta < = '0';
end if;
end process PFinCuenta;
end BAUDGEN_arch;

Comentar lo siguiente, se realizó una carga síncrona por parte de los dos registros externos que están en el modulo de los registros, BAUDL Y BAUDH, cuando en realidad está carga debería de ser asíncrona puesto que podría existir ciertos problemas. Para realizar está carga se ha supuesto que primero se carga la parte baja de los registros y posteriormente la parte alta, aprovechando esto para que cuando se pone una nueva velocidad se cargue está con la señal BAUDHWR.

Segundo decir que se creyó en un principio que cuando se pusiera un valor de velocidad cero en ambos registros debería salir la mitad de la frecuencia de reloj (MCLK), para ello siempre le sumamos un 1 al valor de cuenta, con lo que se tiene que tener en cuenta a la hora de saber por cuanto estamos dividiendo la señal de reloj. Después de presentar la práctica se nos comunicó que esto no era necesario, ya que si se pone un valor cero en los registros, la señal SCICLK siempre estará habilitada, con lo que la frecuencia de salida será entonces la señal MCLK. Entonces para solucionar esto solo hay que deshacer la suma de un 1.

Además se incluye una salida COUNT que indica por donde va la cuenta que realiza el contador, permitiendo la comprobación del correcto funcionamiento del bloque.

Si se realiza un reset del sistema la salida del generador del Baud Rate será siempre cero.

A continuación se muestra el bloque resultante:

104809.gif

2.2. - Bloque Transmisor.



La etapa de transmisión esta formada por un registro de desplazamiento, oculto al programador llamado TXSHF. Cuando se reciba un dato a transmitir en el registro TXBUF, si la etapa de transmisión ha finalizado la transferencia del dato anterior el contenido de TXBUF pasa a TXSHF donde se va desplazando hacia el exterior por el terminal TXD, según el formato de la figura anterior.

Una vez que el registro TXSHF ha almacenado el valor de TXBUF, la señal TXRDY se activa indicando que se puede aceptar un nuevo dato en TXBUF. La señal TXRDY forma parte del registro de estado que se puede leer desde el PC. Cuando finaliza una transmisión se activará la señal TXEMPTY del registro de estado.

El bloque de transmisión esta habilitado por medio de la señal TXENA del registro de control. Si este bit no está activo la salida de la etapa de transmisión TXD estará constantemente a nivel alto. Si este bit se desactiva en medio de una transmisión, dicha transferencia finalizará normalmente, pasando TXD a nivel alto cuando se haya completado.
El funcionamiento del transmisor se muestra resumido en el siguiente cronograma:
104810.gif

La solución adoptada para la etapa de transmisión consiste en la implementación de una máquina de estados finitos. Esta máquina está sincronizada con el reloj del sistema MCLK y con el reloj SCICLK. Aunque SCICLK sea un reloj derivado de MCLK, en los sistemas con dos relojes es conveniente sincronizarlos con ambos evitando posibles variaciones de SCICLK con respecto al reloj del sistema. Como ya se comentó en el bloque generador del reloj, cada uno de los bits del dato se transmite tras 8 ciclos del reloj SCICLK. Por lo tanto, el transmisor incorpora un contador que permite realizar esta operación. Además deberá tener otro contador para el número de bits enviados
En la implementación que se ha realizado, el registro TXBUF es externo al bloque de transmisión. El transmisor recibe un pulso a nivel bajo de la señal TXBUFWR, procedente del decodificador, que le indica que se ha escrito un nuevo dato en el registro externo y que esta disponible a través del bus de entrada TXBUF.

Para detectar el flanco de la señal WRTXBUF, para desactivar la señal TXRDY, se ha optado por una estructura de la siguiente forma:

104811.gif
Como vemos la detección se sincroniza con el reloj MCLK, ya que la señal buf_empty obtenida es asíncrona.

La máquina de estados a implementar tiene el siguiente diagrama:
104812.gif

Los estados corresponden con las siguientes fases del proceso de transmisión:

ESTADO IDLE: En este estado la máquina esta en reposo, y espera que se escriba un dato en TXBUF, para comenzar la transmisión.
ESTADO START: En este estado se envía el bit de Start. Este bit de comienzo son 8 ciclos de SCICLK a nivel bajo.
ESTADO TXDATA: En este estado se transmiten los 8 bits del dato, empezando por el bit de menor peso. Cada bit se transmite durante 8 ciclos de SCICLK.
ESTADO TXPARITY: En este estado se calcula la paridad de los bits enviados y se transmite por la línea.
ESTADO TXSTOP: Es el último estado de la transmisión, y se envía un bit a nivel alto para indicarlo.

A continuación se muestra el código del programa de VHDL que implementa el transmisor. Se ha descrito una máquina de estados finita con el estilo explícito e2.

– PROGRAMA DE TRANSMISIÓN

library IEEE;
use IEEE.std_logic_1164.all;
entity Tx is
port (
MCLK:in STD_LOGIC;
SCICLK:in STD_LOGIC;
RESET: in STD_LOGIC;
TXENA: in STD_LOGIC;
WRTXBUFF: in STD_LOGIC;
TXBUF: in STD_LOGIC_VECTOR (7 downto 0);
TXRDY: out STD_LOGIC;
TXD: out STD_LOGIC;
TXEMPTY: out STD_LOGIC;
STATUS: out STD_LOGIC_VECTOR (0 to 2)
);
end Tx;

architecture tx_arch of tx is

– Se definen las sennales auxiliares:

signal buf_empty:STD_LOGIC;
signal buf_empty_sinc:STD_LOGIC;
signal TXSHF:STD_LOGIC_VECTOR(7 downto 0);
signal preset:STD_LOGIC;

begin

–Proceso que detecta un flanco de WRTXBUFF:

process (WRTXBUFF,preset)
begin
if (preset=’1′) then
buf_empty < ='1';
elsif (WRTXBUFF='1' and WRTXBUFF'EVENT) then
buf_empty < ='0';
end if;
end process;

--Proceso que actualiza la sennal TXRDY:

process (MCLK)
begin
if (MCLK='1' and MCLK'EVENT) then
TXRDY < =buf_empty;
buf_empty_sinc < =buf_empty;
end if;
end process;

-- Proceso principal que implementa la máquina de estados finita:

process (MCLK,RESET,SCICLK)
type estados is (IDLE,START,TXDATA,TXPARITY,TXSTOP);
variable estado:estados;
variable contadortx,bittx:integer range 0 to 7;
begin

-- Condición de reset asíncrono:

if RESET='0' then
STATUS< ="000";
preset< ='1';
TXEMPTY< ='1';
TXD< ='1';
estado:=IDLE;
bittx:=0;
contadortx:=0;

-- Se sincroniza con el reloj del sistema:

elsif (MCLK'EVENT and MCLK='1') then
if (SCICLK='1') then
case estado is

when IDLE=>
STATUS< ="001";
preset< ='0';
TXD< ='1';
TXEMPTY< ='1';
if (TXENA='1'and buf_empty_sinc='0') then
TXSHF< =TXBUF;
TXEMPTY< ='0';
estado:=START;
contadortx:=0;
preset< ='1';
end if;

when START= >
STATUS< ="010";
TXD < ='0';
preset < ='0';
if contadortx=7 then
estado:=TXDATA;
contadortx:=0;
else contadortx:=contadortx+1;
end if;

when TXDATA=>
STATUS< ="011";
TXD< =TXSHF(bittx);

if contadortx=7 then
contadortx:=0;
if bittx=7 then
estado:=TXPARITY;
contadortx:=0;
bittx:=0;
else bittx:=bittx+1;
end if;
else contadortx:=contadortx+1;
end if;

when TXPARITY=>
STATUS< ="100";
TXD< =(TXSHF(0) xor TXSHF(1) xor TXSHF(2) xor TXSHF(3) xor TXSHF(4) xor TXSHF(5) xor TXSHF(6) xor TXSHF(7));
if contadortx=7 then
contadortx:=0;
estado:=TXSTOP;
else contadortx:=contadortx+1;
end if;

when TXSTOP =>
STATUS< ="101";
TXD< ='1';
if contadortx=7 then
estado:=IDLE;
contadortx:=0;
else contadortx:=contadortx+1;
end if;
when others => estado:=IDLE;
end case;
end if;
end if;
end process;
end tx_arch;

A partir de este código se ha generado el bloque transmisor, que presenta el aspecto siguiente:

104813.gif

2.3. - Bloque de los Registros.

El bloque decodificador es el encargado de gestionar la comunicación con el PC a través de un interface, que estaba previamente implementado. Este bloque contiene todos los registros integrados en el puerto serie y permite el acceso a cada uno de ellos decodificando la información proveniente del interface.

A continuación se describen los registros implementados en este bloque, así como las direcciones que debe utilizar el programador para acceder a cada uno de ellos:

104814.gif

A continuación se muestra el contenido de los registros de CONTROL y STATUS:

Registro Control:

104815.gif
Registro Status:
104816.gif

La comunicación con el interface se realiza a través de las siguientes señales:

BUS PDI[7:0]/PDO[7:0]: Bus de datos/direcciones bidireccional.

WRITE: Indica el sentido de la transferencia. Si vale ‘0′ se trata de un proceso de escritura en los registros y si vale ‘1′ se trata de un proceso de lectura.

ASTRB: Indica que se está haciendo un acceso a una dirección.

DSTRB: Indica que se está haciendo un acceso a un dato.

POE: Selecciona la dirección del bus de datos PDI/PDO. Si POE vale ‘1′ se habilita el bus PDI (Bus de entrada) y en caso contrario se activa PDO (Bus de salida). Se saca con la inversa de la señal WRITE.

PWAIT: Controla el protocolo (Handshake) de lectura y escritura de los registros de la UART por parte del PC. El dispositivo tiene tres posibles estados de funcionamiento:

- ESCRITURA DE DIRECCIÓN (ADDRESS WRITE)
- ESCRITURA DE DATOS (DATA WRITE)
- LECTURA DE DATOS (DATA READ)

En las siguientes figuras se muestra como actúa el protocolo en cada caso:

104817.gif

A continuación se muestra el código implementado para realizar este modulo:

library IEEE;
use IEEE.std_logic_1164.all;

entity MOD_REG is
port (
BAUDLWR: in STD_LOGIC;
BAUDHWR: in STD_LOGIC;
TXBUFWR: in STD_LOGIC;
CTRLWR: in STD_LOGIC;
RXBUFRD: in STD_LOGIC;
STATUSRD: in STD_LOGIC;
RXBUF: in STD_LOGIC_VECTOR (7 downto 0);
STATUS: in STD_LOGIC_VECTOR (7 downto 0);
PDI: in STD_LOGIC_VECTOR (7 downto 0);
TXBUF: out STD_LOGIC_VECTOR (7 downto 0);
CTRL: out STD_LOGIC_VECTOR (7 downto 0);
PDO: out STD_LOGIC_VECTOR (7 downto 0);
BAUDH: out STD_LOGIC_VECTOR (7 downto 0);
BAUDL: out STD_LOGIC_VECTOR (7 downto 0)
);
end MOD_REG;

architecture MOD_REG_arch of MOD_REG is
type DecArray is array (0 to 1) of STD_LOGIC;
begin

process(BAUDLWR)
begin
if (BAUDLWR’event and BAUDLWR = ‘1′) then
BAUDL < = PDI;
end if;
end process;

process(BAUDHWR)
begin
if (BAUDHWR'event and BAUDHWR = '1') then
BAUDH < = PDI;
end if;
end process;

process(TXBUFWR)
begin
if (TXBUFWR'event and TXBUFWR = '1') then
TXBUF < = PDI;
end if;
end process;

process(CTRLWR)
begin
if (CTRLWR'event and CTRLWR = '1') then
CTRL < = PDI;
end if;
end process;

process(RXBUFRD, STATUSRD)

begin
case DecArray(RXBUFRD & STATUSRD) is
when b"01" => PDO < = RXBUF;
when b"10" => PDO < = STATUS;
when others => PDO < = "00000000";
end case;
end process;

end MOD_REG_arch;

Seguidamente se muestra el esquema del modulo de los registros creado:

104818.gif

2.4. - Bloque del decodificador.



El bloque del decodificador es el mismo que nos proporcionaron al igual que el interface, por lo que únicamente se mostrará aquí el código VHDL del mismo.

library IEEE;
use IEEE.std_logic_1164.all;

entity Decod is
port (
PDI: in bit_vector (2 downto 0);

ASTRB: in bit;
DSTRB: in bit;
WRITE: in bit;

PWAIT: out bit;
POE: out bit;

BaudlWR: out bit;
BaudhWR: out bit;
TXBUFWR: out bit;
CTRLWR: out bit;

StatusRD: buffer bit;
RXBUFRD: buffer bit
);
end Decod;

architecture DecodArc of Decod is

signal AdrsWr: bit;
signal Adrs: bit_vector (2 downto 0);

type DecArray is array (0 to 4) of bit;

begin
– Senial de captura del dato de direccion.

AdrsWr < = '0' when (WRITE = '0' and ASTRB = '0') else
'1';

-- Proceso captura de la direccion.

process(AdrsWr, PDI)
begin
if (AdrsWr'event and AdrsWr = '1') then
Adrs < = PDI(2 downto 0);
end if;
end process;

-- Decodificacion de seniales de seleccion

process(DSTRB, WRITE, Adrs)
variable aux: bit_vector(5 downto 0);
begin
case DecArray(DSTRB & WRITE & Adrs) is
when b"00100" => aux := “111110″;
when b”00101″ => aux := “111101″;
when b”00001″ => aux := “111011″;
when b”00010″ => aux := “110111″;
when b”01000″ => aux := “101111″;
when b”01011″ => aux := “011111″;
when others => aux := “111111″;
end case;

BaudlWr < = aux(0);
BaudhWr < = aux(1);
TxBufWr < = aux(2);
CtrlWr < = aux(3);
RXBUFRD < = aux(4);
StatusRD < = aux(5);
end process;

-- Proceso de generacion de PEO.

process(StatusRD, RXBUFRD)
begin
if(StatusRD='0' or RXBUFRD='0') then
POE < = '0';
else
POE < = '1';
end if;
end process;

process(ASTRB, DSTRB)
begin
if(ASTRB='0' or DSTRB='0') then
PWAIT < = '1';
else
PWAIT < = '0';
end if;
end process;
end DecodArc;

El esquema es:

104819.gif

El esquema final de nuestro sistema es el siguiente:

104820.gif

3. - SIMULACIONES TEMPORALES Y SCRIPTS.



Init.cmd:

|Iniciacion

|delete_signals
restart

|DEFINICION DE VECTORES.

| **********************************************
| ***** INTERFACE CON EL PUERTO PARALELO ******
| **********************************************
vector SCICLK SCICLK
vector XPD H1/PDI[7:0] | Bus de datos del puerto paralelo.

vector XASTRB H1/XASTRB | Linea de STRB de direcciones.
vector XDSTRB H1/XDSTRB | Linea de STRB de datos.

vector XWRITE H1/XWRITE | Linea de WRITE.
vector XWAIT H1/XWAIT | Linea de WAIT.
vector XINIT H1/XINIT | Linea de INIT.
vector XTXD H1/XTXD | Linea de TXD.
|vector XACK H1/XACK | Linea de ACK.

|vector XTxD H1/XTxD | Linea de transmision de datos
|vector XRxD H1/XRxD | Linea de transmision de datos

vector XMCLK H1/XMCLK | Señal de reloj maestra.

|vector CNT CNT[15:0]
vector RXBUF RXBUF[7:0]
vector TXBUF TXBUF[7:0]
|vector TXSTATE TXSTATE[3:0]

|vector RXSTATE RXSTATE[3:0]
|vector SLOTCNT SLOTCNT[2:0]
|vector BITCNT BITCNT[2:0]

|vector BITSLOT BITSLOT[7:0]
|vector PREDVALUE PREDVALUE

vector BAUD BAUD[15:0]

| *********************************
| ***** REGISTROS INTERNOS. ******
| *********************************

| SELECCION DE BASE PARA LOS VECTORES.

|radix dec CNT

| DEFINION DEL ENLACE CON VIEWWAVE (CRONOGRAMAS)

watch XPD XASTRB XDSTRB XWRITE XWAIT POE +
BAUDLWR BAUDHWR TXBUFWR CTRLWR RXBUFRD STATUSRD
|+ SCICLK XCLKOUT
| TXENA TXEMPTY TxRDY +
| RXENA RXRDY PARITYERR OVERRUNERR FRAMEERR BREAKERR

step 50ns |DEFINICION DE CICLO DE RELOJ.
clock XMCLK 0 1 |DEFINICION DE CICLO DE TRABAJO.
|clock SCICLK 0 1 1 0|******QUITAR******
| ****************************************
| *** ASIGNACION DE VALORES INICIALES. ***
| ****************************************

h XASTRB
h XDSTRB
h XWRITE

|h XRxD

l XINIT
RUN 10

h XINIT
RUN 10

Setbaudl.cmd:

| ******* ESCRITURA DE REGISTROS DE LA FPGA ******

run 5

l XWRITE | Fijo el sentido de la transferencia.
run 1

l XASTRB | Activo el la señal de ASTRB.
run 1
assign XPD 04\h | Saco la direccion en el bus.
run 4

h XASTRB | Desactivo la señal de ASTRB.
run 1
r XPD | Dejo indefinido el bus de datos.
h XWRITE

run 1

|********************************

run 5

l XWRITE | Fijo el sentido de la transferencia.
run 4

l XDSTRB | Activo el la señal de DSTRB.
run 1
| *********ESCRIBO EL DATO A METER EN EL REGISTRO********
assign XPD 02i\h | Saco el dato por en el bus.
run 4

h XDSTRB | Desactivo la señal de DSTRB.
run 1
r XPD | Dejo indefinido el bus de datos.
h XWRITE

run 1

Setbaudh.cmd:

| ******* ESCRITURA DE REGISTROS DE LA FPGA ******

run 5

l XWRITE | Fijo el sentido de la transferencia.
run 1

l XASTRB | Activo el la señal de ASTRB.
run 1
assign XPD 05\h | Saco la direccion en el bus.
run 4

h XASTRB | Desactivo la señal de ASTRB.
run 1
r XPD | Dejo indefinido el bus de datos.
h XWRITE

run 1

|********************************

run 5

l XWRITE | Fijo el sentido de la transferencia.
run 4

l XDSTRB | Activo el la señal de DSTRB.
run 1
| *********ESCRIBO EL DATO A METER EN EL REGISTRO********
assign XPD 00\h | Saco el dato por en el bus.
run 4

h XDSTRB | Desactivo la señal de DSTRB.
run 1
r XPD | Dejo indefinido el bus de datos.
h XWRITE

run 1

SetCtrl.cmd:

| ******* ESCRITURA DE REGISTROS DE LA FPGA ******

run 5

l XWRITE | Fijo el sentido de la transferencia.
run 1

l XASTRB | Activo el la señal de ASTRB.
run 1
assign XPD 02\h | Saco la direccion en el bus(CTRL).
run 4

h XASTRB | Desactivo la señal de ASTRB.
run 1
r XPD | Dejo indefinido el bus de datos.
h XWRITE

run 1

|********************************

run 5

l XWRITE | Fijo el sentido de la transferencia.
run 4

l XDSTRB | Activo el la señal de DSTRB.
run 1
| *********ESCRIBO EL DATO A METER EN EL REGISTRO********
assign XPD FF\h | Saco el dato por en el bus.
run 4

h XDSTRB | Desactivo la señal de DSTRB.
run 1
r XPD | Dejo indefinido el bus de datos.
h XWRITE

run 100

Settxbuf.cmd:

| ******* ESCRITURA DE REGISTROS DE LA FPGA ******

run 5

l XWRITE | Fijo el sentido de la transferencia.
run 1

assign XPD 01\h | Saco la direccion en el bus.
run 4
l XASTRB | Activo el la señal de ASTRB.
run 1

run 4

h XASTRB | Desactivo la señal de ASTRB.
run 4
r XPD | Dejo indefinido el bus de datos.
h XWRITE

run 1

|********************************

run 5

l XWRITE | Fijo el sentido de la transferencia.
run 4

l XDSTRB | Activo el la señal de DSTRB.
run 1
| *********ESCRIBO EL DATO A METER EN EL REGISTRO********
assign XPD AA\h | Saco el dato por en el bus.
run 4

h XDSTRB | Desactivo la señal de DSTRB.
run 4
r XPD | Dejo indefinido el bus de datos.
h XWRITE

run 100

Simulaciones:



104821.gif

104822.gif

104823.gif

104824.gif
104825.gif

104828.gif
1048281.gif

104829.gif

Autor:

Ángel Labrador





Creative Commons License
Estos contenidos son Copyleft bajo una Licencia de Creative Commons.
Pueden ser distribuidos o reproducidos, mencionando su autor.
Siempre que no sea para un uso económico o comercial.
No se pueden alterar o transformar, para generar unos nuevos.

 
TodoMonografías.com © 2006 - Términos y Condiciones - Esta obra está bajo una licencia de Creative Commons. Creative Commons License