PRÁCTICAS DE COMPUTADORES I

SOLUCIÓN AL EJERCICIO

Enunciado
Basándose en la celda SRAM recién construida, realícese un módulo de memoria SRAM con las siguientes características:
1. Tamaño de la palabra: 4 bits
2. Tamaño de la memoria: 16 palabras
3. Señales de control: CS (selección de chip), R_W (lectura=1, escritura=0), OE (salida permitida)
4. Bus de datos y bus de direcciones independientes
5. Dibújese un cronograma en un ciclo de lectura y de escritura. Diseñad los tiempos de activación entre señales según os parezca oportuno

Solución

En un proyecto de cierta complejidad, conviene aproximarse paulatinamente a la solución. Dividiremos el proyecto en etapas. Concluida cada una de las etapas, verificamos su funcionamiento antes de emprender la etapa siguiente.

Primera etapa: celda elemental

Basándonos en las indicaciones del guion de la sesión, construimos la primera aproximación a la celda elemental SRAM: Celda elemental SRAM con nombres


module Celda(inout tri bl, inout tri nbl, input wire sel);
  tri wA, wB;
  supply1 vdd;
  supply0 gnd;

  nmos #1 n0(wA,gnd,wB);
  nmos #1 n1(wB,gnd,wA);
  rnmos n2(wA,vdd,vdd);
  rnmos n3(wB,vdd,vdd);
  tranif1 n4(wA,nbl,wl);
  tranif1 n5(wB,bl,wl);
endmodule

El módulo de prueba únicamente tiene de particular el uso de una combinación de cable y registro para conectarse a las líneas de entrada/salida de la celda. Mediante una orden assign, conectamos el registro al cable. Realizamos la conexión con fuerza supply para que el valor del registro se imponga al del cable en escritura: cuando queremos verter un valor en la línea, lo ponemos en el registro. Cuando queremos leer un valor de la línea, dejamos el registro en alta impedancia. Prueba de celda elemental SRAM con nombres

Prueba de celda elemental SRAM con nombres


module TestSram;
  reg sel; // Entradas
  tri bl,nbl;
  reg bit,nbit;

  assign (supply0, supply1) bl=bit;
  assign (supply0, supply1) nbl=nbit;
  Celda pepe(bl,nbl,sel);

  // Bloque de comportamiento
  initial
  begin
    $monitor($time," bit=%b nbit=%b, sel=%b, bl=%v, nbl=%v, wA=%v, wB=%v",
                     bit, nbit, sel, bl, nbl, pepe.wA, pepe.wB);
      // OperaciOn de escritura de un 1
      $display("OperaciOn de escritura de un 1:");
      bit=1; nbit=0; sel=0; #2 sel=1; #2 sel=0;
      // OperaciOn de lectura
      $display("OperaciOn de lectura:");
      #6 bit=1'bz; nbit=1'bz; #2 sel=1; #2 sel=0;
      // OperaciOn de escritura de un 0
      $display("OperaciOn de escritura de un 0:");
      #6 bit=0; nbit=1; sel=0; #2 sel=1; #2 sel=0;
      // OperaciOn de lectura
      $display("OperaciOn de lectura:");
      #6 bit=1'bz; nbit=1'bz; #2 sel=1; #2 sel=0;
      #6 $finish;
  end
endmodule

Hacemos seguimiento de los registros y cables e incluso de los dos cables internos wA y wB internos de la celda (observad el uso del operador punto). El resultado de su ejecución con cver es:


OperaciOn de escritura de un 1:
                   0 bit=1 nbit=0, sel=0, bl=Su1, nbl=Su0, wA=65X, wB=65X
                   2 bit=1 nbit=0, sel=1, bl=Su1, nbl=Su0, wA=St0, wB=StX
                   3 bit=1 nbit=0, sel=1, bl=Su1, nbl=Su0, wA=St0, wB=St1
OperaciOn de lectura:
                   4 bit=1 nbit=0, sel=0, bl=Su1, nbl=Su0, wA=St0, wB=Pu1
                  10 bit=z nbit=z, sel=0, bl=Su1, nbl=Su0, wA=St0, wB=Pu1
                  12 bit=z nbit=z, sel=1, bl=Su1, nbl=Su0, wA=StX, wB=St1
                  13 bit=z nbit=z, sel=1, bl=Su1, nbl=Su0, wA=StX, wB=StX
OperaciOn de escritura de un 0:
                  14 bit=z nbit=z, sel=0, bl=Su1, nbl=Su0, wA=65X, wB=65X
                  20 bit=0 nbit=1, sel=0, bl=Su0, nbl=Su1, wA=65X, wB=65X
                  22 bit=0 nbit=1, sel=1, bl=Su0, nbl=Su1, wA=StX, wB=St0
                  23 bit=0 nbit=1, sel=1, bl=Su0, nbl=Su1, wA=St1, wB=St0
OperaciOn de lectura:
                  24 bit=0 nbit=1, sel=0, bl=Su0, nbl=Su1, wA=Pu1, wB=St0
                  30 bit=z nbit=z, sel=0, bl=Su0, nbl=Su1, wA=Pu1, wB=St0
                  32 bit=z nbit=z, sel=1, bl=Su0, nbl=Su1, wA=St1, wB=StX
                  33 bit=z nbit=z, sel=1, bl=Su0, nbl=Su1, wA=StX, wB=StX
                  34 bit=z nbit=z, sel=0, bl=Su0, nbl=Su1, wA=65X, wB=65X

A primera vista, la celda parece funcionar. Cuando se escribe se fuerza al biestable a pasar la configuración deseada (fijaos en wA y wB). Cuando se lee se recupera el valor en los cables bl y nbl.

Sin embargo, una inspección más cuidadosa nos revela un problema. Por ejemplo, en el instante t=30, el registro bit está en alta impedancia, la celda no está seleccionada (sel=0) y, por consiguiente, n5 no debiera conducir. El estado esperado del cable bl debería ser, por consiguiente, alta impedancia. Sin embargo, al menos en la versión 2.12a de cver, el cable externo parece seguir al interno a pesar del corte. Esto no nos supone ahora ningún problema pero nos lo puede dar en el futuro cuando construyamos más celdas compartiendo el mismo bus de datos. Debemos corregirlo.

Segunda etapa: celda elemental arreglada

Planteemos la interconexión de la celda con el bus de datos mediante búferes para remediar la deficiencia de cver: Celda elemental SRAM con nombres arreglada

Celda elemental SRAM con nombres arreglada


module Celda(inout tri bl, inout tri nbl, input wire sel);
  tri wA, wB;
  supply1 vdd;
  supply0 gnd;

  nmos #1 n0(wA,gnd,wB);
  nmos #1 n1(wB,gnd,wA);
  rnmos n2(wA,vdd,vdd);
  rnmos n3(wB,vdd,vdd);
  bufif1 (strong0,strong1) n40(wA,nbl,sel);
  bufif1 (strong0,strong1) n41(nbl,wA,sel);
  bufif1 (strong0,strong1) n50(wB,bl,sel);
  bufif1 (strong0,strong1) n51(bl,wB,sel);
endmodule

Como se ve, hemos aprovechado los búferes para reforzar la señal. El resultado de ejecutar la prueba anterior con esta nueva celda es:

OperaciOn de escritura de un 1:
                   0 bit=1 nbit=0, sel=0, bl=Su1, nbl=Su0, wA=65X, wB=65X
                   2 bit=1 nbit=0, sel=1, bl=Su1, nbl=Su0, wA=St0, wB=StX
                   3 bit=1 nbit=0, sel=1, bl=Su1, nbl=Su0, wA=St0, wB=St1
OperaciOn de lectura:
                   4 bit=1 nbit=0, sel=0, bl=Su1, nbl=Su0, wA=St0, wB=Pu1
                  10 bit=z nbit=z, sel=0, bl=HiZ, nbl=HiZ, wA=St0, wB=Pu1
                  12 bit=z nbit=z, sel=1, bl=St1, nbl=St0, wA=St0, wB=St1
OperaciOn de escritura de un 0:
                  14 bit=z nbit=z, sel=0, bl=HiZ, nbl=HiZ, wA=St0, wB=Pu1
                  20 bit=0 nbit=1, sel=0, bl=Su0, nbl=Su1, wA=St0, wB=Pu1
                  22 bit=0 nbit=1, sel=1, bl=Su0, nbl=Su1, wA=StX, wB=St0
                  23 bit=0 nbit=1, sel=1, bl=Su0, nbl=Su1, wA=St1, wB=St0
OperaciOn de lectura:
                  24 bit=0 nbit=1, sel=0, bl=Su0, nbl=Su1, wA=Pu1, wB=St0
                  30 bit=z nbit=z, sel=0, bl=HiZ, nbl=HiZ, wA=Pu1, wB=St0
                  32 bit=z nbit=z, sel=1, bl=St0, nbl=St1, wA=St1, wB=St0
                  34 bit=z nbit=z, sel=0, bl=HiZ, nbl=HiZ, wA=Pu1, wB=St0

En t=30, ahora las líneas bl y nbl están en alta impedancia, como debe ser.

Tercera etapa: celda revestida, o sea, memoria de 1 bit

La celda básica es perfectamente capaz de almacenar un bit de información. Sin embargo, las líneas y el procedimiento que se emplean para leerla y escribirla no se adecúa al modo habitual de acceso. Revistamos, pues, nuestra celda SRAM elemental para que responda a las líneas CS, RnW y OE. La adaptación es sencilla:

En lectura, están activas OE, CS y RnW. Se ha de extraer el dato leído de la línea BL de la celda
En escritura, está a 1 CS y a 0 RnW. Se tiene que depositar el dato en BL y el dato negado en nBL

El resultado de aplicar estas condiciones puede ser este: Memoria SRAM de un bit con nombres


module Sram(inout tri D, input wire CS, input wire RnW, input wire OE);
  tri wbl,wnbl;
  wire waR,waW,wnRnW;
  Celda c(wbl,wnbl,1'b1);
  and aR(waR,OE,CS,RnW);
  not n2(wnRnW,RnW);
  and aW(waW,CS,wnRnW);
  bufif1 bR(D,wbl,waR);
  bufif1 (supply0,supply1) bW (wbl,D,waW);
  notif1 (supply0,supply1) nW (wnbl,D,waW);
endmodule

A las salidas del búfer bW y la puerta NOT nW, usados en la escritura, se les ha dotado de fuerza supply para que sean capaces de hacer cambiar de estado al biestable interno de la celda.

Para comprobar el módulo usamos registros para las entradas y pares registro-cable triestado para las entradas/salidas como hicimos más arriba. Este es el módulo de comprobación:


module TestSram;
  reg D,CS,RnW,OE;
  tri wD;
  Sram chip(wD,CS,RnW,OE);
  assign wD=D;

  // Bloque de comportamiento
  initial
    begin
      $monitor($time," CS=%b, RnW=%b, OE=%b, D=%b, wD=%v", CS, RnW, OE, D, wD);
      // OperaciOn de escritura de un 1
      $display("OperaciOn de escritura de un 1");
      OE=0; D=1; #2 RnW=0; CS=1; #1 CS=0;
      // OperaciOn de lectura
      #5 $display("OperaciOn de lectura");
      RnW=1; D=1'bz; #1 CS=1; OE=1; #1 OE=0; CS=0;
      // OperaciOn de escritura de un 0
      #3 $display("OperaciOn de escritura de un 0");
      D=0; #2 RnW=0; CS=1; #1 CS=0;
      // OperaciOn de lectura
      #5 $display("OperaciOn de lectura");
      RnW=1; D=1'bz; #1 CS=1; OE=1; #1 OE=0; CS=0;
      #5 $finish;
    end
endmodule

Y la salida correspondiente:

OperaciOn de escritura de un 1
                   0 CS=x, RnW=x, OE=0, D=1, wD=St1
                   2 CS=1, RnW=0, OE=0, D=1, wD=St1
                   3 CS=0, RnW=0, OE=0, D=1, wD=St1
OperaciOn de lectura
                   8 CS=0, RnW=1, OE=0, D=z, wD=HiZ
                   9 CS=1, RnW=1, OE=1, D=z, wD=St1
                  10 CS=0, RnW=1, OE=0, D=z, wD=HiZ
OperaciOn de escritura de un 0
                  13 CS=0, RnW=1, OE=0, D=0, wD=St0
                  15 CS=1, RnW=0, OE=0, D=0, wD=St0
                  16 CS=0, RnW=0, OE=0, D=0, wD=St0
OperaciOn de lectura
                  21 CS=0, RnW=1, OE=0, D=z, wD=HiZ
                  22 CS=1, RnW=1, OE=1, D=z, wD=St0
                  23 CS=0, RnW=1, OE=0, D=z, wD=HiZ

Cuarta etapa: aumento de los bits por palabra

El diseño de la etapa anterior es plenamente funcional. Su problema es que la capacidad es de solamente un bit. El ejercicio pide una memoria de 16 palabras de 4 bits. En esta etapa ampliaremos el bus de datos a cuatro bits. Necesitamos, pues, cuatro celdas.

Estas cuatro celdas formarán una fila de celdas. Cada celda de la fila debe tener sus búferes independientes aunque el resto de señales son compartidas. En lugar de generar waR y waW para cada celda, aprovechamos la misma señal para todas ellas, tal y como se muestra en la figura: Memoria SRAM de cuatro bits con nombres

El diseño, previendo la siguiente etapa, lo vamos a hacer modular por filas, con lo que la figura anterior, una vez introducido el módulo FilaSram queda: Memoria SRAM de cuatro bits con nombres y filas

Memoria SRAM de cuatro bits con nombres y filas


module FilaSram(inout tri [3:0]D, input wire RE, input wire WE, input wire SEL);
  tri [3:0]wbl; tri [3:0] wnbl;
  Celda c0(wbl[0],wnbl[0],SEL);
  Celda c1(wbl[1],wnbl[1],SEL);
  Celda c2(wbl[2],wnbl[2],SEL);
  Celda c3(wbl[3],wnbl[3],SEL);
  bufif1 bR0(D[0],wbl[0],RE);
  bufif1 bR1(D[1],wbl[1],RE);
  bufif1 bR2(D[2],wbl[2],RE);
  bufif1 bR3(D[3],wbl[3],RE);
  bufif1 (supply0,supply1) bW0 (wbl[0], D[0],WE);
  bufif1 (supply0,supply1) bW1 (wbl[1], D[1],WE);
  bufif1 (supply0,supply1) bW2 (wbl[2], D[2],WE);
  bufif1 (supply0,supply1) bW3 (wbl[3], D[3],WE);
  notif1 (supply0,supply1) nW0 (wnbl[0],D[0],WE);
  notif1 (supply0,supply1) nW1 (wnbl[1],D[1],WE);
  notif1 (supply0,supply1) nW2 (wnbl[2],D[2],WE);
  notif1 (supply0,supply1) nW3 (wnbl[3],D[3],WE);
endmodule

module Sram(inout tri [3:0]D, input wire CS, input wire RnW, input wire OE);
  wire waR,waW,wnRnW;
  and aR(waR,OE,CS,RnW);
  not n2(wnRnW,RnW);
  and aW(waW,CS,wnRnW);
  FilaSram  f(D,waR,waW,1'b1);
endmodule

Lo vamos a probar de un modo muy parecido al caso anterior, solo que ahora tenemos 4 bits de memoria, por lo que podemos almacenar números mayores:


module TestSram;
  reg [3:0]D;
  reg CS,RnW,OE;
  tri [3:0]wD;
  Sram chip(wD,CS,RnW,OE);
  assign wD=D;

  // Bloque de comportamiento
  initial
    begin
      $monitor($time," CS=%b, RnW=%b, OE=%b, D=%b, wD=%b(%d)", CS, RnW, OE, D, wD, wD);
      // OperaciOn de escritura de un 3
      $display("OperaciOn de escritura de un 3");
      OE=0; D=3; #2 RnW=0; CS=1; #1 CS=0;
      // OperaciOn de lectura
      #5 $display("OperaciOn de lectura");
      RnW=1; D=4'bz; #1 CS=1; OE=1; #1 OE=0; CS=0;
      // OperaciOn de escritura de un 13
      #3 $display("OperaciOn de escritura de un 13");
      D=13; #2 RnW=0; CS=1; #1 CS=0;
      // OperaciOn de lectura
      #5 $display("OperaciOn de lectura");
      RnW=1; D=4'bz; #1 CS=1; OE=1; #1 OE=0; CS=0;
      #5 $finish;
    end
endmodule

El resultado es el esperado:

OperaciOn de escritura de un 3
                   0 CS=x, RnW=x, OE=0, D=0011, wD=0011( 3)
                   2 CS=1, RnW=0, OE=0, D=0011, wD=0011( 3)
                   3 CS=0, RnW=0, OE=0, D=0011, wD=0011( 3)
OperaciOn de lectura
                   8 CS=0, RnW=1, OE=0, D=zzzz, wD=zzzz( z)
                   9 CS=1, RnW=1, OE=1, D=zzzz, wD=0011( 3)
                  10 CS=0, RnW=1, OE=0, D=zzzz, wD=zzzz( z)
OperaciOn de escritura de un 13
                  13 CS=0, RnW=1, OE=0, D=1101, wD=1101(13)
                  15 CS=1, RnW=0, OE=0, D=1101, wD=1101(13)
                  16 CS=0, RnW=0, OE=0, D=1101, wD=1101(13)
OperaciOn de lectura
                  21 CS=0, RnW=1, OE=0, D=zzzz, wD=zzzz( z)
                  22 CS=1, RnW=1, OE=1, D=zzzz, wD=1101(13)
                  23 CS=0, RnW=1, OE=0, D=zzzz, wD=zzzz( z)

Etapa final: varias palabras direccionables

En la etapa anterior disponíamos ya de una palabra de memoria en perfecto funcionamiento. La memoria que nos piden tiene 16 de estas palabras. Necesitamos, por consiguiente, 16 filas como las del apartado anterior. El bus de datos es común para todas ellas y, al contrario que ocurría antes cuando la única celda siempre estaba direccionada (SEL=1), ahora solo debe direccionarse una de ellas, la que posea la dirección de memoria pedida. El bus de direcciones para 16 posiciones debe ser de cuatro bits. Mediante un decodificador 4x16, logramos seleccionar la fila adecuada: Memoria SRAM de 64 bits con nombres

Y este es el código necesario:


module Sram(inout tri [3:0]D, input wire [3:0]A, input wire CS, input wire RnW, input wire OE);
  wire [15:0] S;
  wire waR,waW,wnRnW;
  Dec4x16 dec(S,A);
  and aR(waR,OE,CS,RnW);
  not n2(wnRnW,RnW);
  and aW(waW,CS,wnRnW);
  FilaSram  f0(D,waR,waW,S[0]);
  FilaSram  f1(D,waR,waW,S[1]);
  FilaSram  f2(D,waR,waW,S[2]);
  FilaSram  f3(D,waR,waW,S[3]);
  FilaSram  f4(D,waR,waW,S[4]);
  FilaSram  f5(D,waR,waW,S[5]);
  FilaSram  f6(D,waR,waW,S[6]);
  FilaSram  f7(D,waR,waW,S[7]);
  FilaSram  f8(D,waR,waW,S[8]);
  FilaSram  f9(D,waR,waW,S[9]);
  FilaSram f10(D,waR,waW,S[10]);
  FilaSram f11(D,waR,waW,S[11]);
  FilaSram f12(D,waR,waW,S[12]);
  FilaSram f13(D,waR,waW,S[13]);
  FilaSram f14(D,waR,waW,S[14]);
  FilaSram f15(D,waR,waW,S[15]);
endmodule

Para que el código funcione, necesitamos un decodificador 4x16. Lo hacemos mediante un módulo de comportamiento para no complicarnos...


module Dec4x16(output reg [15:0] S, input wire [3:0] A);
  always @(A)
  begin
    S=16'b1 << A;
  end
endmodule

Se acerca el momento cumbre. El éxtasis final apoteósico. Vamos a probar nuestro chip SRAM recientito, recientito con este módulo de prueba:


module TestSram;
  reg [3:0]D;
  reg [3:0]A;
  reg CS,RnW,OE;
  tri [3:0]wD;
  Sram chip(wD,A,CS,RnW,OE);
  assign wD=D;

  // Bloque de comportamiento
  initial
    begin
      $monitor($time," CS=%b, RnW=%b, OE=%b, A=%d, D=%d, wD=%b", CS, RnW, OE, A, D, wD);
      // OperaciOn de escritura de un 3 en la direcciOn 7
      $display("OperaciOn de escritura de un 3 en la direcciOn 7");
      CS=0; OE=0; A=7; D=3; RnW=0; #2 CS=1; #2 CS=0;
      // OperaciOn de lectura de la direcciOn 7
      #3 $display("OperaciOn de lectura en la direcciOn 7");
      RnW=1; D=4'bz; #2 CS=1; OE=1; #2 OE=0; CS=0;
      // OperaciOn de escritura de un 13 en la direcciOn 5
      #3 $display("OperaciOn de escritura de un 13 en la direcciOn 5");
      A=5; D=13; RnW=0; #2 CS=1; #2 CS=0;
      // OperaciOn de lectura en la direcciOn 5
      #3 $display("OperaciOn de lectura en la direcciOn 5");
      RnW=1; D=4'bz; #2 CS=1; OE=1; #2 OE=0; CS=0;
      // OperaciOn de lectura de la direcciOn 7
      #3 $display("OperaciOn de lectura en la direcciOn 7");
      RnW=1; A=7; D=4'bz; #2 CS=1; OE=1; #2 OE=0; CS=0;
      #3 $finish;
    end
endmodule

Viene, viene...

OperaciOn de escritura de un 3 en la direcciOn 7
                   0 CS=0, RnW=0, OE=0, A= 7, D= 3, wD=0011
                   2 CS=1, RnW=0, OE=0, A= 7, D= 3, wD=0011
                   4 CS=0, RnW=0, OE=0, A= 7, D= 3, wD=0011
OperaciOn de lectura en la direcciOn 7
                   7 CS=0, RnW=1, OE=0, A= 7, D= z, wD=zzzz
                   9 CS=1, RnW=1, OE=1, A= 7, D= z, wD=xxxx
                  11 CS=0, RnW=1, OE=0, A= 7, D= z, wD=zzzz
OperaciOn de escritura de un 13 en la direcciOn 5
                  14 CS=0, RnW=0, OE=0, A= 5, D=13, wD=1101
                  16 CS=1, RnW=0, OE=0, A= 5, D=13, wD=1101
                  18 CS=0, RnW=0, OE=0, A= 5, D=13, wD=1101
OperaciOn de lectura en la direcciOn 5
                  21 CS=0, RnW=1, OE=0, A= 5, D= z, wD=zzzz
                  23 CS=1, RnW=1, OE=1, A= 5, D= z, wD=xxxx
                  25 CS=0, RnW=1, OE=0, A= 5, D= z, wD=zzzz
OperaciOn de lectura en la direcciOn 7
                  28 CS=0, RnW=1, OE=0, A= 7, D= z, wD=zzzz
                  30 CS=1, RnW=1, OE=1, A= 7, D= z, wD=xxxx
                  32 CS=0, RnW=1, OE=0, A= 7, D= z, wD=zzzz

¡Gatillazo! La operación de lectura nos da xxxx...

Etapa que viene después de la etapa final: no hay palabras...

¿Pero no era la etapa anterior la etapa final? Bueno, ya se sabe... esto... es una cuestión de marketing...

El problema ocurre en la lectura de memoria, pero bien puede venir porque los datos no se hubieran escrito como es debido. Después de investigar un poco, descubrimos que no, que los datos se han escrito bien. Lo que ocurre es que no salen bien por el bus. Repasemos, paso a paso lo que ocurre en una lectura. Miremos el diagrama de una celda de nuevo: Celda elemental SRAM con nombres arreglada

Cuando queremos leer una posición de memoria, solo una de las celdas está seleccionada por el decodificador (SEL=1). Para el resto, SEL=0. La celda seleccionada transfiere su valor interno a través de n51 hasta la línea BL. Supongamos que es un 1. Las celdas no seleccionadas, SEL=0, dejan BL en alta impedancia (z).

Fijémonos (izquierda) lo que ocurre fuera de la celda seleccionada, descartando las partes del esquema de arriba innecesarias para nuestro razonamiento:

Se ha marcado en rojo aquellas líneas que están a 1 y en negro las que están a 0. Como la celda contiene un 1, el búffer bR3 vierte ese 1 al bus de datos. Hasta ahí todo perfecto.

Sin embargo, fijémonos (derecha) en lo que ocurre con el resto de celdas no seleccionadas. En ellas, n41 y n51 dejan a bl y nbl en alta impedancia (señalado en verde). El búfer bR3 está permitido, pero ¿qué ofrece a la salida cuando la entrada es alta impedancia? Observemos su tabla de verdad en Verilog:

`bufif1`	0	1	x	z	← Entrada
0	z	z	z	z
1	0	1	x	x

Si la entrada es z y la línea de control es 1, la salida es x. Esta x se mezcla con el 1 de la celda seleccionada y nos da x.

Afortunadamente, hay otro elemento en Verilog que, en las circunstancias arriba señaladas, nos produce z (alta impedancia). Sabemos que el 1 de la celda seleccionada siempre gana a la z. Con ese elemento, la lectura se va a realizar de modo correcto. El elemento misterioso no es otro que el nmos que hemos visto al inicio de la sesión. Observemos su tabla de verdad:

`nmos`	0	1	x	z	← Entrada
0	z	z	z	z
1	0	1	x	z

Sustituimos, en consecuencia, las bRs en la definición de las filas de SRAM:


module FilaSram(inout tri [3:0]D, input wire RE, input wire WE, input wire SEL);
  tri [3:0]wbl; tri [3:0] wnbl;
  Celda c0(wbl[0],wnbl[0],SEL);
  Celda c1(wbl[1],wnbl[1],SEL);
  Celda c2(wbl[2],wnbl[2],SEL);
  Celda c3(wbl[3],wnbl[3],SEL);
  nmos bR0(D[0],wbl[0],RE);
  nmos bR1(D[1],wbl[1],RE);
  nmos bR2(D[2],wbl[2],RE);
  nmos bR3(D[3],wbl[3],RE);
  bufif1 (supply0,supply1) bW0 (wbl[0], D[0],WE);
  bufif1 (supply0,supply1) bW1 (wbl[1], D[1],WE);
  bufif1 (supply0,supply1) bW2 (wbl[2], D[2],WE);
  bufif1 (supply0,supply1) bW3 (wbl[3], D[3],WE);
  notif1 (supply0,supply1) nW0 (wnbl[0],D[0],WE);
  notif1 (supply0,supply1) nW1 (wnbl[1],D[1],WE);
  notif1 (supply0,supply1) nW2 (wnbl[2],D[2],WE);
  notif1 (supply0,supply1) nW3 (wnbl[3],D[3],WE);
endmodule

Y el resultado de la ejecución es finalmente el esperado:

OperaciOn de escritura de un 3 en la direcciOn 7
                   0 CS=0, RnW=0, OE=0, A= 7, D= 3, wD=0011
                   2 CS=1, RnW=0, OE=0, A= 7, D= 3, wD=0011
                   4 CS=0, RnW=0, OE=0, A= 7, D= 3, wD=0011
OperaciOn de lectura en la direcciOn 7
                   7 CS=0, RnW=1, OE=0, A= 7, D= z, wD=zzzz
                   9 CS=1, RnW=1, OE=1, A= 7, D= z, wD=0011
                  11 CS=0, RnW=1, OE=0, A= 7, D= z, wD=zzzz
OperaciOn de escritura de un 13 en la direcciOn 5
                  14 CS=0, RnW=0, OE=0, A= 5, D=13, wD=1101
                  16 CS=1, RnW=0, OE=0, A= 5, D=13, wD=1101
                  18 CS=0, RnW=0, OE=0, A= 5, D=13, wD=1101
OperaciOn de lectura en la direcciOn 5
                  21 CS=0, RnW=1, OE=0, A= 5, D= z, wD=zzzz
                  23 CS=1, RnW=1, OE=1, A= 5, D= z, wD=1101
                  25 CS=0, RnW=1, OE=0, A= 5, D= z, wD=zzzz
OperaciOn de lectura en la direcciOn 7
                  28 CS=0, RnW=1, OE=0, A= 7, D= z, wD=zzzz
                  30 CS=1, RnW=1, OE=1, A= 7, D= z, wD=0011
                  32 CS=0, RnW=1, OE=0, A= 7, D= z, wD=zzzz