Electrónica digital
Práctica 2
Circuitos combinacionales básicos
Introducción
Los circuitos combinacionales se caracterizan porque entran señales a un circuito, se procesa
la información (“se combinan las señales”) y se generan las salidas, no se guarda información
que se realimente al circuito. Con esta información vemos que existen muchos circuitos
combinacionales, algunos ya bautizados como los comparadores, multiplexores,
decodificadores, etc., pero otros realizan funciones que tienen nombres de su aplicación
específica como un sistema detector de fase. A continuación se presenta información básica de
los distintos circuitos que se realizarán en esta práctica, y algunos se presentan con
aplicaciones.
Comparadores
La comparación es una situación cotidiana, comparamos precios cuando compramos algo,
comparamos autos para ver cuál es más eficiente, comparamos bancos para ver cuál cobra
menos intereses, etc. Se define a través de relaciones matemáticas con los operadores
relacionales “mayor que”, “menor que”, “mayor o igual a”, “menor o igual a”, “diferente de” e
“igual a”. Un comparador de magnitud compara dos números, A y B (de n bits) y determina sus
magnitudes relativas, dando como resultado hasta seis salidas binarias: A > B, A >= B; A < B, A
<= B, A = B y A ≠ B.
Una simple aplicación de un comparador se muestra en la figura 1, la cual indica un sistema de
acceso seleccionado por el usuario con un teclado y mostrado en un display (entrada A) y un
contador de personas por medio de un sensor o torniquete (entrada B). Cuando A ≥ B el acceso
debe de permanecer abierto, pero si A<B no debe de dejar pasar a más personas,
inmovilizando el torniquete, cerrando una puerta, sonando una alarma, etc.
Figura 1. Aplicación de un comparador en un sistema de acceso controlado.
A continuación se muestran los programas en VHDL y en Verilog para un comparador de 3 bits,
así como la simulación de estos en la figura 2.
--Comparador de 3 bits con VHDL
library IEEE;
use IEEE.std_logic_1164.all;
entity compara is
port (A, B: in STD_LOGIC_VECTOR (2 downto 0); --entradas de 3 bits
igual, mayor, menor: out STD_LOGIC); --3 salidas
end compara;
architecture compara_arch of compara is
begin
process (A, B)
begin
igual <= '0'; mayor <= '0'; menor <= '0'; --inicializar
if A = B then igual <= '1'; end if; --salida igual
if A > B then mayor <= '1'; end if; --salida mayor
if A < B then menor <= '1'; end if; --salida menor
end process;
end compara_arch;
Figura 2. Simulación del comparador de 3 bits con 3 salidas.
// Comparador de 3 bits con Verilog
module compara (menor, mayor, igual, A, B);
input [2:0] A, B;
output menor, mayor, igual;
reg menor, mayor, igual;
always @ (A or B)
begin
menor=0;
mayor = 0;
igual = 0;
if (A==B) igual=1;
else if (A > B) mayor = 1;
else menor = 1;
end
endmodule
//Comparador de 8-bit con tres salidas lógicas
//con may:a>b, men:a<b, igu:a=b
module comparador8 (
input [7:0] a,b,
output mayor, menor, igual);
//si la condición es verdadera se le asigna ‘1’, sino se le asigna ‘0’
assign mayor = (a > b) ? 1'b1 : 1'b0;
assign menor = (a < b) ? 1'b1 : 1'b0;
assign igual = (a == b) ? 1'b1 : 1'b0;
endmodule
//Comparador de 8-bit con tres salidas may, men, igu
module comparador8 (
input [7:0] A,B,
output [2:0] C); //C(2) mayor, C(1) igual, C(0) menor
//si la condición es verdadera se le asigna ‘1’, sino se le asigna ‘0’
assign C = (A>B)? 3'b100 :
(A==B)? 3'b010 :
(A<B)? 3'b001 : 3'b000;
endmodule
Multiplexores
Los multiplexores o MUX son circuitos combinacionales que se utilizan como los selectores
analógicos, es decir, como una perilla que tiene un polo (mínimo) y varios tiros o posiciones con
los que hace contacto, como se muestra en la figura 3.
Figura 3. Selectores analógicos de perilla.
Por ejemplo, un multiplexor de 2 líneas a una (2 X 1) puede conectar a la salida una de sus dos
posibles datos de entrada, uno de 4 X 1 puede conectar a la salida una de sus cuatro posibles
entradas, etc. aunque también es posible tener más salidas, como en un MUX 4 X 1 doble, es
decir 8 líneas de entrada y 2 salidas. Las salidas pueden ser afirmadas, negadas o ponerse en
alta impedancia (‘Z’).
Existen varias aplicaciones de los multiplexores, entre las cuales se pueden encontrar la
multiplexión (cambio) de los canales de los osciloscopios, sistemas de comunicación, vigilancia,
conversión de paralelo a serial, generación de formas de onda y de funciones lógicas,
enrutamiento de datos, el estéreo de una casa que puede cambiar la salida para escuchar un
CD, un casete o una entrada externa, por mencionar solo algunas. Esta última se muestra en la
figura 4 para una aplicación de una alarma que se encuentra a una distancia de 20 metros, en
donde los datos se envían por una sola línea (con buffer por la pérdida de la señal a esa
distancia) en vez de enviar los cuatro datos a sensar por diferentes líneas de transmisión.
Figura 4. Ejemplo de aplicación de un MUX en una alarma de muestreo automático.
A continuación se presentan las ecuaciones fundamentales de tres multiplexores, siendo “Sal”
la salida, “Sm” los bits del selector e “In” las entradas posibles.
Mux de 2 entradas: Sal = I0S’ + I1S
Mux de 4 entradas: Sal = I0S1’S0’ + I1S1’S0 + I2S1S0’ + I3S1S0
Mux de 8 entradas: Sal = I0S2’S1’S0’ + I1S2’S1’S0 + I2S2’S1S0’ + I3S2’S1S0 + I4S2S1’S0’ + I5S2S1’S0
+ I6S2S1S0’ + I7S2S1S0
En seguida se muestran los códigos básicos de VHDL y Verilog con la declaración de los
multiplexores y su simulación en la figura 5.
--multiplexor 4 a 1 con VHDL utilizando la sentencia case-when
entity mux4 is
port
( a,b,c,d: in bit; --entradas
sel: in bit_vector(1 downto 0); --selector
Y: out bit); --salida
end mux4;
architecture a_mux4 of mux4 is
begin
process (a, b, c, d, sel)
begin
case sel is
when "00" => Y <= a;
when "01" => Y <= b;
when "10" => Y <= c;
when others => Y <= d;
end case;
end process;
end a_mux4;
--multiplexor 4 a 1 con VHDL utilizando la sentencia if-then-else
entity mux4 is port( a,b,c,d:in bit; --entradas
sel:in bit_vector(1 downto 0); --selector
Y: out bit); --salida
end mux4;
architecture a_mux4 of mux4 is
begin
process (a, b, c, d, sel)
begin
if sel="00" => Y <= a;
elsif sel="01" => Y <= b;
elsif sel="10" => Y <= c;
else Y <= d;
end if;
end process;
end a_mux4;
//código de un multiplexor de 4 a 1 utilizando la sentencia case
//a, b, c, d son las entradas, Y es la salida y sel es el selector
module mux4_case(a, b, c, d, sel, Y); // multiplexor de cuatro canales
input a, b, c, d;
input [1:0] sel;
output Y;
reg Y;
always @(a or b or c or d or sel) // si cambian las entradas o el selector asigna la
// salida
begin
case (sel) // sentencia case utilizando sel
0: Y = a;
1: Y = b;
2: Y = c;
3: Y = d;
default Y = 1’bx;
endcase
end
endmodule
//código de un multiplexor de 4 a 1 utilizando la sentencia if
//a, b, c, d son las entradas, Y es la salida y sel es el selector
module mux4_if(a, b, c, d, sel, Y);
input wire a, b, c, d;
input wire [1:0] sel;
output reg Y;
always @(*)
if (sel==2'b00) Y = a;
else if (sel==2'b01) Y = b;
else if (sel==2'b10) Y = c;
else Y = d;
endmodule
Figura 5. Simulación del multiplexor de 4 a 1.
Demultiplexores
Un demultiplexor o DEMUX realiza la operación inversa del mux, es decir, toma una sola
entrada y la distribuye a cualquiera de las salidas según el código de un selector, como se
muestra en la figura 6.
Figura 6. Distribuidores analógicos de perilla.
La aplicación del demux es de distribuidor de datos, pero en conjunto con otros
componentes se puede utilizar en los sistemas de vigilancia y sistemas de seguridad,
sistemas síncronos de transmisión de datos, controlador de un motor a pasos, sistemas de
ahorro de energía, por mencionar algunos, como se muestra en la figura 7.
Figura 7. Sistema MUX y DEMUX.
Ahora se presentan los códigos de un demultiplexor en VHDL y en Verilog así como su
simulación en la figura 8.
--código de un demultiplexor 1 a 4 con VHDL
entity demux is port(
entrada: in bit;
sel: in bit_vector(1 downto 0); --selector
--abcd: out bit_vector (1 to 4);--otra forma de declarar las salidas
a,b,c,d: out bit); --salidas
end demux;
architecture a_demux of demux is
begin
process (entrada, sel)
begin
case sel is
when "00" => a <= entrada; b <= ‘0’; c <= ‘0’; d <= ‘0’;
when "01" => a <= ‘0’; b <= entrada; c <= ‘0’; d <= ‘0’;
when "10" => a <= ‘0’; b <= ‘0’; c <= entrada; d <= ‘0’;
when others => a <= ‘0’; b <= ‘0’; c <= ‘0’; d <= entrada;
-- otra forma de hacer el case empleando un vector “abcd” es como sigue:
-- when "00" => abcd <= entrada & “000”;
-- when "01" => abcd <= ‘0’ & entrada & “00”;
-- when "10" => abcd <= “00” & entrada & ‘0’;
-- when others => abcd <= “000” & entrada;
end case;
end process;
end a_demux;
// código de un demultiplexor 1 a 4 con Verilog//
//din entrada de un bit, dout salida de 4 bits, sel es el selector de 2 bits
module demultiplexer1_4 ( din ,sel ,dout );
output reg [3:0] dout ;
input wire din ;
input wire [1:0] sel ;
always @ (din or sel) begin
case (sel)
0 : dout = {din,3'b000}; // las {} son para concatenar din con 3 ceros
1 : dout = {1'b0,din,2'b00};
2 : dout = {2'b00,din,1'b0};
default : dout = {3'b000,din};
endcase
end
endmodule
Figura 8. Simulación del demultiplexor de 1 a 4.
Buffer triestado
Un buffer es un circuito seguidor, pero su esencia en circuitos lógicos es que mantiene la señal
de entrada y proporciona una cantidad de corriente mayor a la salida. La palabra triestado
implica que puede manejar tres niveles a la salida, el alto =’1’, el bajo =’0’ y el tercer estado es
la alta impedancia ‘Z’, que no permite el paso de señal lógica en cualquiera de los dos sentidos.
En la figura 9 se muestra el circuito de un buffer triestado y en seguida la forma de escribirlos
en HDL, así como su simulación en las figuras 10 y 11.
Figura 9. Buffer tri-estado
-- Primer forma de declarar un buffer tri-estado
library IEEE;
use IEEE.std_logic_1164.all;
entity triestado is port ( G,A : in std_logic;
Y : out std_logic);
end triestado;
architecture tri of triestado is
begin
process (g, a)
begin
if G = '1' then Y <= a;
else Y <= 'Z'; -- la letra Z mayúscula sirve para declarar alta impedancia
end if;
end process;
end tri;
Figura 10. Simulación del Buffer tri-estado.
// código de un buffer triestado
module buffer ( a, g, y);
output reg y;
input wire a,g;
always @ (g) begin
case (g)
0 : y = 1’bz;
1 : y = a;
default : y = 1’bz;
endcase
end
endmodule
-- Otra forma de declarar un buffer tri-estado
library IEEE;
use IEEE.std_logic_1164.all;
entity triestado is port (g, a : in std_logic;
y : out std_logic);
end triestado;
architecture tri of triestado is
begin
Y <= a when (g = '1') else 'Z';
end tri;
Figura 11. Simulación del Buffer tri-estado.
// otro código de un buffer triestado
module buffer ( a, g, y);
input g,a;
output y;
assign y = (g)? a : 1’bz;
endmodule
Desarrollo
Punto 1
Implementar usando Verilog un comparador de magnitud de 4 bits (4 bits para cada entrada
conectada a los interruptores y/o botones), con salida a leds testigos y a display, cuyas salidas
den la información si “A > B”, “A < B”, “A = B”, “A ≥ B”, “A ≤ B”, y “A ≠ B”. Notar que siempre
debe de haber 3 símbolos activados, los que deben de mostrarse con la activación de botones
o en display separados (por ejemplo si A=3 y B=4 debemos ver 3 < 4, 3 ≠ 4, 3 ≤ 4 ) (ver
figura 12). Llenar la tabla 1 con los datos solicitados. Reportar su simulación para 6 datos con
texto dentro de la imagen que explique lo que se presenta, así como el código utilizado e incluir
fotos con texto que muestren el resultado de por lo menos dos de sus pruebas. Poner
etiquetas (de papel u otro material) para entradas y salidas.
Figura 12. Diagrama de bloques del comparador y salida a display.
Tabla 1. Niveles lógicos a las salidas del comparador. Compara A vs B.
Entrada A Entrada B
A>B A<B A=B A≥B A≤B A≠B
A3 A2 A1 A0 B3 B2 B1 B0
0000 0000
0101 1011
1010 0101
1111 1111
0101 1010
0100 0001
Punto 2
Implementar con VHDL un multiplexor de 8 a 1 con habilitador, las entradas a interruptores y
botones, la salida a un led rojo (externo) y acoplando el selector al display para mostrar un
segmento encendido, como se muestra en la figura 13. Llenar la tabla 2 con los datos
solicitados. Reportar su simulación para 4 datos con texto dentro de la imagen que explique lo
que se presenta, además del código utilizado e incluir fotos con texto explicativo que muestren
el resultado de por lo menos dos de sus pruebas. Poner etiquetas (de papel u otro material)
para entradas y salidas.
Figura 13. Diagrama a bloques del multiplexor y codificador del selector.
Tabla 2. Niveles lógicos a las salidas de los multiplexores.
Selector Segmento encendido Salida del mux
Entradas Enable
S2 S1 S0 del display 8x1
I0 0 000 “a”
I1 1 001 “b”
I2 010 “c”
I3 011 “d”
I4 100 “e”
I5 101 “f”
I6 110 “g”
I7 111 “p”
Punto 3
Implementar con Verilog un demultiplexor de 1 a 8 con habilitador, las entradas a interruptores
y botones, las salidas a leds testigos verdes externos, acoplando el selector al display para
mostrar un segmento encendido (ver figura 14). Llenar la tabla 3 con los datos solicitados.
Reportar su simulación para 4 datos con texto dentro de la imagen que explique lo que se
presenta, además del código utilizado e incluir fotos con texto explicativo que muestren el
resultado de por lo menos dos de sus pruebas. Poner etiquetas (de papel u otro material)
para entradas y salidas.
Figura 14. Diagrama a bloques del demultiplexor y codificador del selector.
Tabla 3. Niveles lógicos a las salidas del demultiplexor de 1 x 8.
Segmento
Selector Salida del demux
Entrada I Enable encendido del
S2 S1 S0 S7 S6 S5 S4 S3 S2 S1 S0
display
I 000 “a”
I 001 “b”
I 010 “c”
I 011 “d”
I 100 “e”
I 101 “f”
I 110 “g”
I 111 “p”
Punto 4
Implementar en un dispositivo lógico programable con HDL, un circuito para activar un motor de
pasos con su etapa de potencia, empleando código Gray para los cambios en el selector
(interruptores). Conectar un soporte, base o mecanismo al eje del motor para mover una carga
mecánica (no se permiten cosas sencillas como hélices, clips, alambres, ligas, hojas de
papel, etc.). Reportar simulación, el código utilizado e incluir fotos con texto explicativo que
muestren el resultado de por lo menos dos de sus pruebas. Poner etiquetas (de papel u otro
material) para entradas y salidas.
Punto 5
Implementar un circuito lógico programable con HDL para controlar el encendido de tres pisos
de un edificio con 2 interruptores de la forma en que se enlista a continuación. Las luces
pueden ser focos o cargas de 120 Vca. Reportar simulación, el código utilizado y fotos de su
funcionamiento y su simulación, todo con comentarios y texto explicando lo que se muestra.
Poner etiquetas (de papel u otro material) para entradas y salidas.
• Encender solo las luces del primer piso.
• Encender solo las luces del segundo piso.
• Encender solo las luces del tercer piso.
• Apagar todas las luces.
Nota: Recuerda los lineamientos que se establecieron para el reporte de la práctica.
¡Éxito en tu práctica!
Referencias
Demultiplexor
[Link]
Video multiplexor, curso de FPGA & Verilog teórico-práctco Hackeando-Tec
[Link]
WRiaW8&index=8&list=PLIyIZGa1sAZqeQJ6Y02b7O8HV0gK25zc2
Video codificador, curso de FPGA & Verilog teórico-práctco Hackeando-Tec
[Link]
v=dNIC9FMIa8E&index=9&list=PLIyIZGa1sAZqeQJ6Y02b7O8HV0gK25zc2
Video comparador, curso de FPGA & Verilog teórico-práctco Hackeando-Tec
[Link]
v=kRnI2G27EeY&list=PLIyIZGa1sAZqeQJ6Y02b7O8HV0gK25zc2&index=10
Anexo
Programas de ayuda
--Comparador de 3 bits con VHDL con salida a display
library IEEE;
use IEEE.std_logic_1164.all;
---------------------------------------------------------------------------
entity compara is
port (A, B: in STD_LOGIC_VECTOR (2 downto 0); --entradas de 3 bits
igual, mayor: out STD_LOGIC; --3 salidas
AN: out STD_LOGIC_VECTOR (0 to 3);
CA: out STD_LOGIC_VECTOR (7 downto 0);
BTN: in STD_LOGIC_VECTOR (2 downto 1)
);
end compara;
---------------------------------------------------------------------------
architecture compara_arch of compara is
signal tempo: STD_LOGIC_VECTOR(1 TO 2); --igual,mayor ES UNA SENAL INTERNA
begin
igual <= tempo(1);
mayor <= tempo(2);
-- comparador con if anidado
process (A, B)
begin
if A = B then tempo <= "10"; --salida igual
elsif A > B then tempo <= "01"; --salida mayor
else tempo <= "00";
end if;
end process;
---------------------------------------------------
--asigna salidas a display
process (tempo,btn)
begin
if tempo = "10" and btn(2) = '1' then CA <= x"ED"; AN <= "1001"; --salida igual
elsif tempo = "01" and btn(1) = '1' then CA <= x"CD"; AN <= "1110"; --salida mayor
else
CA <= x"ff"; AN <= "1111";
end if;
end process;
end compara_arch;
#UCF comparador de 3 bits
#entradas
net "A(2)" loc = "r17" ; # sw7
net "A(1)" loc = "n17" ; # sw6
net "A(0)" loc = "l13" ; # sw5
net "B(2)" loc = "k18" ; # sw2
net "B(1)" loc = "h18" ; # sw1
net "B(0)" loc = "g18" ; # sw0
#entrada botones
net "btn(2)" loc = "h13" ;
net "btn(1)" loc = "e18" ;
#salidas
net "igual" loc = "j15" ; # ld2
net "mayor" loc = "j14" ; # ld1
#salida display
net "CA(7)" loc = "l18" ; # a
net "CA(6)" loc = "f18" ; # b
net "CA(5)" loc = "d17" ; # c
net "CA(4)" loc = "d16" ; # d
net "CA(3)" loc = "g14" ; # e
net "CA(2)" loc = "j17" ; # f
net "CA(1)" loc = "h14" ; # g
net "CA(0)" loc = "c17" ; # P
#salida anodos
net "AN(3)" loc = "f17" ; # AN0
net "AN(2)" loc = "h17" ; # AN1
net "AN(1)" loc = "c18" ; # AN2
net "AN(0)" loc = "f15" ; # AN3
--multiplexor de 4 a 1 con VHDL
library IEEE;
use IEEE.std_logic_1164.all;
entity mux is
port (I: in STD_LOGIC_VECTOR (3 downto 0); -- entradas de 8 bits
s: in STD_LOGIC_VECTOR (2 downto 0); -- selector
E: in STD_LOGIC; --enable
O: out STD_LOGIC;--salida
AN: out STD_LOGIC_VECTOR (0 to 3);
CA: out STD_LOGIC_VECTOR (7 downto 0) --aqui se mostrara mi opcion de
selector
);
end mux;
architecture mux of mux is
begin
AN <= "0111";
---------------------------------------------------
-- mux con case/when
process (I,S,E)
begin
if E = '0' then O <= 'Z'; CA <= "11111111";--salida alta impedancia
else
case s is -- abcdefgP
when o"0" => O <= I(0); CA <= "01111111"; -- I0
when o"1" => O <= I(1); CA <= "10111111"; -- I1
when o"2" => O <= I(2); CA <= "11011111"; -- I2
when o"3" => O <= I(3); CA <= "11101111"; -- I3
when others => O <= I(3); CA <= "11111111"; -- I7
end case;
end if;
end process;
end mux;
#UCF mux 4 a 1
#entradas
net "I(3)" loc = "K17" ; # sw3
net "I(2)" loc = "k18" ; # sw2
net "I(1)" loc = "h18" ; # sw1
net "I(0)" loc = "g18" ; # sw0
#ENTRADAS botones SELECTOR Y ENABLE
net "E" loc = "h13" ; # BTN3
net "E" clock_dedicated_route = false;
net "S(2)" loc = "e18" ; # BTN2
net "S(1)" loc = "d18" ; # BTN1
net "S(0)" loc = "B18" ; # BTN0
#salida
net "O" loc = "j14" ; # ld0
#salida display
net "CA(7)" loc = "l18" ; # a
net "CA(6)" loc = "f18" ; # b
net "CA(5)" loc = "d17" ; # c
net "CA(4)" loc = "d16" ; # d
net "CA(3)" loc = "g14" ; # e
net "CA(2)" loc = "j17" ; # f
net "CA(1)" loc = "h14" ; # g
net "CA(0)" loc = "c17" ; # P
#salida anodos
net "AN(3)" loc = "f17" ; # AN0
net "AN(2)" loc = "h17" ; # AN1
net "AN(1)" loc = "c18" ; # AN2
net "AN(0)" loc = "f15" ; # AN3
--Demultiplexor de 1 a 4 con VHDL
library IEEE;
use IEEE.std_logic_1164.all;
entity demux is
port (I: in STD_LOGIC; -- entrada
s: in STD_LOGIC_VECTOR (2 downto 0); -- selector
E: in STD_LOGIC; -- enable
O: out STD_LOGIC_VECTOR (3 downto 0); -- salidas de 4 bits
AN: out STD_LOGIC_VECTOR (0 to 3);
CA: out STD_LOGIC_VECTOR (7 downto 0)
);
end demux;
architecture demux of demux is
begin
AN <= "0111";
---------------------------------------------------
-- demux con case/when
process (I,S,E)
begin
if E = '0' then O <= "ZZZZ"; CA <= "11111111";--salida alta impedancia
else
case s is
-- abcdefgP
when o"0" => O <= "000" & I; CA <= "01111111"; -- O0
when o"1" => O <= "00" & I & '0'; CA <= "10111111"; -- O1
when o"2" => O <= "0" & I & "00"; CA <= "11011111"; -- O2
when o"3" => O <= I & "000"; CA <= "11101111"; -- O3
when others => O <= "0000"; CA <= "11111111";
end case;
end if;
end process;
end demux;
#UCF demux 1 a 4
#entrada
net "I" loc = "g18" ; # sw0
#ENTRADAS botones SELECTOR Y ENABLE
net "E" loc = "h13" ; # BTN3
net "E" clock_dedicated_route = false;
net "S(2)" loc = "e18" ; # BTN2
net "S(1)" loc = "d18" ; # BTN1
net "S(0)" loc = "B18" ; # BTN0
#salida
net "O(3)" loc = "k14" ; # ld3
net "O(2)" loc = "k15" ; # ld2
net "O(1)" loc = "j15" ; # ld1
net "O(0)" loc = "j14" ; # ld0
#salida display
net "CA(7)" loc = "l18" ; # a
net "CA(6)" loc = "f18" ; # b
net "CA(5)" loc = "d17" ; # c
net "CA(4)" loc = "d16" ; # d
net "CA(3)" loc = "g14" ; # e
net "CA(2)" loc = "j17" ; # f
net "CA(1)" loc = "h14" ; # g
net "CA(0)" loc = "c17" ; # P
#salida anodos
net "AN(3)" loc = "f17" ; # AN0
net "AN(2)" loc = "h17" ; # AN1
net "AN(1)" loc = "c18" ; # AN2
net "AN(0)" loc = "f15" ; # AN3
