Implementación de circuito (combinacional y secuencial) usando Prolog

Requisito previo – Prólogo | Una introducción

Descripción general:
los circuitos digitales o la electrónica digital son una rama de la electrónica que se ocupa de las señales digitales para realizar las diversas tareas para cumplir con los diversos requisitos. La señal de entrada aplicada a estos circuitos es de forma digital, que se representa en formato de lenguaje binario de 0 y 1. Estos circuitos están diseñados mediante el uso de puertas lógicas como las puertas AND, OR, NOT, NANAD, NOR, XOR que realizan operaciones lógicas. Esta representación ayuda al circuito a cambiar de un estado a otro para proporcionar una salida precisa. Los sistemas de circuitos digitales están diseñados principalmente para superar la desventaja de los sistemas analógicos que son más lentos y los datos de salida que se obtienen pueden contener un error. Hay dos tipos de circuitos digitales Circuito Combinacional y Circuito Secuencial.

Implementación usando Prolog:
Prolog es un lenguaje de programación lógico y declarativo. El nombre en sí, Prolog, es la abreviatura de Programación en lógica.

Ejemplo:
aquí surge la pregunta, ¿cómo representamos un circuito en un código de prólogo? Considere el siguiente diagrama de circuito.

Hay 3 entradas en el diagrama de circuito, A, B y C. Consideraremos y pasaremos el diagrama de circuito anterior como un código de prólogo en la siguiente línea de código de la siguiente manera.

circuit1(A,B,C,Q,R):-
    not(A,T1),
    and(A,B,T2),
    nand(T1,T2,T3),
    xnor(T3,C,T4),
    dff(T4,Q,R).

Descripción:
Aquí Q y R son las variables de salida. T1-T4 son los valores de instancia o salidas de las puertas intermedias. Las compuertas lógicas que se han utilizado son: – NOT, AND, NAND y XNOR gate. Hay un D-FLIP FLOP y 2 salidas Q y Q’. Consideraremos las tablas de verdad como hechos y el diagrama de circuito como reglas en prólogo, como está escrito en el siguiente código.

Nota:
en el siguiente código, las tablas de verdad están escritas para g-prolog. En swi-prolog, las tablas de verdad están predefinidas.

Implementación de código:
Aquí, implementaremos la lógica y escribiremos el código en prolog.

Paso 1: 
Aquí, implementaremos las tablas de verdad de todas las puertas lógicas para 2 entradas A y B. 

% Made by - Maninder kaur 
% Following are the truth tables of all logic gates for 2 inputs A and B.

and(0,0,0).
and(0,1,0).
and(1,0,0).
and(1,1,1).

or(0,0,0).
or(0,1,1).
or(1,0,1).
or(1,1,1).

not(0,1).
not(1,0).

nand(0,0,1).
nand(0,1,1).
nand(1,0,1).
nand(1,1,0).

nor(0,0,1).
nor(0,1,0).
nor(1,0,0).
nor(1,1,0).

xor(0,0,0).
xor(0,1,1).
xor(1,0,1).
xor(1,1,0).

xnor(0,0,1).
xnor(0,1,0).
xnor(1,0,0).
xnor(1,1,1).

Paso 2:
Aquí, implementaremos las tablas de verdad de OR GATE para 4 entradas A, B, C y D.

% Following is the truth tables of OR GATE for 4 inputs A ,B ,C and D.
% (Used in 8X3 Encoder)

or4(0,0,0,0,0).
or4(0,0,0,1,1).
or4(0,0,1,0,1).
or4(0,0,1,1,1).
or4(0,1,0,0,1).
or4(0,1,0,1,1).
or4(0,1,1,0,1).
or4(0,1,1,1,1).
or4(1,0,0,0,1).
or4(1,0,0,1,1).
or4(1,0,1,0,1).
or4(1,0,1,1,1).
or4(1,1,0,0,1).
or4(1,1,0,1,1).
or4(1,1,1,0,1).
or4(1,1,1,1,1).

Paso 3:
aquí, implementaremos el medio sumador.

% HALF ADDER :-
% INPUT VARIABLES - A,B,C
% OUTPUT VARIABLES - S ,Ca(Sum and Carry)

half_adder(A,B,S,Ca):-
    xor(A,B,S),
    and(A,B,Ca).

Paso 4:
aquí, implementaremos el sumador completo.

%FULL ADDER :-
%INPUT VARIABLES - A,B,C
%OUTPUT VARIABLES - S ,Ca (Sum and Carry)

full_adder(A,B,C,S,Ca):-
     xor(A,B,T1),
    xor(C,T1,S),
    and(T1,C,T2),
    and(A,B,T3),
    or(T3,T2,Ca).

Paso 5:
aquí, implementaremos el medio sustractor.

%    HALF SUBTRACTOR :-
%    INPUT VARIABLES - A,B
%    OUTPUT VARIABLES - D ,BO (Difference and borrow)

half_sub(A,B,D,BO):-
    xor(A,B,D),
    not(A,T1),
    and(B,T1,BO).

Paso 6:
Aquí, implementaremos el restador completo.

% FULL SUBTRACTOR :-
% INPUT VARIABLES - A,B
% OUTPUT VARIABLES - D ,BO (Difference and borrow)

full_sub(A,B,BI,D,BO) :-
    xor(A,B,T1),
    xor(T1,BI,D),
    not(T1,T2),
    not(A,T3),
    nand(T2,BI,T4),
    nand(T3,B,T5),
    nand(T4,T5,BO).

Paso 7:
Ahora, implementaremos el DECODIFICADOR 2 × 4.

% 2 X 4 DECODER
% INPUT VARIABLES - A,B
% OUTPUT VARIABLES - D0,D1,D2,D3

decoder_2x4(A,B,D0,D1,D2,D3):-
    not(A,A_0),
    not(B,B_0),
    and(A_0,B_0,D0),
    and(A_0,B,D1),
    and(A,B_0,D2),
    and(A,B,D3).

Paso 8:
Ahora, implementaremos el DECODIFICADOR 3 × 8.

% 3 X 8 ENCODER
% OUTPUT VARIABLES - A,B
% INPUT VARIABLES - D0,D1,D2,D3,D4,D5,D6,D7

encoder_8x3(_,D1,D2,D3,D4,D5,D6,D7,A,B,C):-
    or4(D1,D3,D5,D7,A),
    or4(D2,D3,D6,D7,B),
    or4(D4,D5,D6,D7,C).

Paso 9:
Ahora, implementaremos el MULTIPLEXOR 2 X 1.

% 2 X 1 MULTIPLEXER
% INPUT VARIABLES - A,B,S (Selector)
% OUTPUT VARIABLES - Z

mux_2x1(A,B,S,Z):-
    not(S,S1),
    and(A,S1,I0),
    and(B,S,I1),
    or(I0,I1,Z).

Paso-10:
Ahora, implementaremos el DEMULTIPLEXOR 1 × 2.

% 1 X 2 DEMULTIPLEXER
% INPUT VARIABLES - I (Input) ,S (Selector)
% OUTPUT VARIABLES - A,B

demux_1x2(I,S,A,B):-
    not(S,S_0),
    and(I,S_0,A),
    and(I,S,B).

Paso-11:
Ahora, implementaremos el DEMULTIPLEXOR 1 × 4.

% 1 X 4 DEMULTIPLEXER
% INPUT VARIABLES - I (Input) ,S0 and S1(Selectors)
% OUTPUT VARIABLES - A,B,C,D

demux_1x4(I,S0,S1,A,B,C,D):-
    decoder_2x4(S0,S1,T0,T1,T2,T3),
    and(I,T0,A),
    and(I,T1,B),
    and(I,T2,C),
    and(I,T3,D).

Paso 12:
Ahora, implementaremos el D FLIP FLOP.

% D FLIP FLOP TRUTH TABLE

dff(0,0,1).
dff(1,1,0).

Paso 13:
Ahora, implementaremos el código del circuito.

% CIRCUITS

circuit1(A,B,C,Q,R):-
    not(A,T1),
    and(A,B,T2),
    nand(T1,T2,T3),
    xnor(T3,C,T4),
    dff(T4,Q,R).

Producción :