nedoPC.org

    TYPE std_ulogic IS ( 'U',  -- Uninitialized
                         'X',  -- Forcing  Unknown
                         '0',  -- Forcing  0
                         '1',  -- Forcing  1
                         'Z',  -- High Impedance   
                         'W',  -- Weak     Unknown
                         'L',  -- Weak     0       
                         'H',  -- Weak     1       
                         '-'   -- Don't care
                       );

use ternary.all;

entity main is
    Port ( a : in FakeTrit;
           b : in FakeTrit;
           c : in FakeTrit;
           s : out FakeTrit;
           c2 : out FakeTrit
          );
end main;

architecture Behavioral of main is
signal r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14 : FakeTrit;
signal a1,b1,c1,s1,cc1 : FakeTrit;
begin
process (a,b,c)

FUNCTION io_invert(T: FakeTrit) RETURN FakeTrit IS
begin
                case T is
                when N =>
                        return P;
                when O =>
                        return X;
                when P =>
                        return N;
                when others =>
                        return O;
                end case;
end;

begin

   a1 <= io_invert(a);
   b1 <= io_invert(b);
   c1 <= io_invert(c);
   
   r1 <= mux(a1,O,P,N);
   r2 <= mux(a1,P,N,O);
   r3 <= mux(b1,r1,r2,a1);
   r4 <= mux(b1,r2,a1,r1);
   r5 <= mux(b1,a1,r1,r2);
   r6 <= mux(c1,r3,r4,r5);
   r7 <= e21(a1,N,O);
   r8 <= e12(a1,N,O);
   r9 <= e21(a1,O,P);
   r10 <= e12(a1,O,P);
   r11 <= mux(b1,r7,r8,O);
   r12 <= mux(b1,r8,O,r9);
   r13 <= mux(b1,O,r9,r10);
   r14 <= mux(c1,r11,r12,r13);
   s1 <= r6;
   cc1 <= r14;
   
   s <= io_invert(s1);
   c2 <= io_invert(cc1);

end process;

end Behavioral;

entity main is
    Port ( a : in FakeTrit;
           b : in FakeTrit;
           c : in FakeTrit;
           s1 : out FakeTrit;
           s2 : out FakeTrit;
           s3 : out FakeTrit);
end main;

architecture Behavioral of main is
signal a1,b1,c1,ss1,ss2,ss3 : FakeTrit;
begin
process (a,b,c)
begin

   a1 <= io_invert(a);
   b1 <= io_invert(b);
   c1 <= io_invert(c);
   
   ss1 <= a1;
   ss2 <= b1;
   ss3 <= c1;
   
   s1 <= io_invert(ss1);
   s2 <= io_invert(ss2);
   s3 <= io_invert(ss3);

end process;
end Behavioral;

NET "a<0>"  LOC = "P140" | IOSTANDARD = LVTTL ;
NET "a<1>"  LOC = "P142" | IOSTANDARD = LVTTL ;
NET "b<0>"  LOC = "P138" | IOSTANDARD = LVTTL ;
NET "b<1>"  LOC = "P139" | IOSTANDARD = LVTTL ;
NET "c<0>"  LOC = "P136" | IOSTANDARD = LVTTL ;
NET "c<1>"  LOC = "P137" | IOSTANDARD = LVTTL ;
NET "s3<0>"  LOC = "P82" | IOSTANDARD = LVTTL ;
NET "s3<1>"  LOC = "P83" | IOSTANDARD = LVTTL ;
NET "s2<0>"  LOC = "P85" | IOSTANDARD = LVTTL ;
NET "s2<1>"  LOC = "P86" | IOSTANDARD = LVTTL ;
NET "s1<0>"  LOC = "P87" | IOSTANDARD = LVTTL ;
NET "s1<1>"  LOC = "P88" | IOSTANDARD = LVTTL ;

********** Mapped Logic **********
s1(0) <= a(0);
s1(1) <= a(1);
s2(0) <= b(0);
s2(1) <= b(1);
s3(0) <= c(0);
s3(1) <= c(1);

        PROCEDURE dmux(signal T_C: IN FakeTrit;
                       signal T_I: IN FakeTrit;
                       signal T_N: OUT FakeTrit;
                       signal T_O: OUT FakeTrit;
                       signal T_P: OUT FakeTrit) IS
        begin
                case T_C is
                when N =>
                        T_N <= T_I;
                        T_O <= O;
                        T_P <= O;
                when O =>
                        T_N <= O;
                        T_O <= T_I;
                        T_P <= O;
                when P =>
                        T_N <= O;
                        T_O <= O;
                        T_P <= T_I;
                when others =>
                        T_N <= X;
                        T_O <= X;
                        T_P <= X;
                end case;    
        end;

********** Mapped Logic **********
s1(0) <= ((a(1))
      OR (b(0) AND a(0)));
s1(1) <= ((a(1))
      OR (a(0) AND b(1)));
s2(0) <= NOT (((NOT a(0) AND NOT a(1))
      OR (NOT b(0) AND a(0) AND a(1))));
s2(1) <= NOT (((NOT a(0) AND NOT a(1))
      OR (a(0) AND a(1) AND NOT b(1))));
s3(0) <= ((a(0))
      OR (b(0) AND a(1)));
s3(1) <= ((a(0))
      OR (a(1) AND b(1)));

use ternary.all;

entity main is
    Port ( a : in FakeTrit;
           b : in FakeTrit;
           c : in FakeTrit;
           s1 : out FakeTrit;
           s2 : out FakeTrit;
           s3 : out FakeTrit );
end main;

architecture Behavioral of main is
signal a1,b1,c1,ss1,ss2,ss3 : FakeTrit;
begin

mem1: ternary_mem port map( T_C => a1, T_N => b1, T_P => c1, T_Q => ss1);

process (a,b,c)

FUNCTION io_invert(T: FakeTrit) RETURN FakeTrit IS
begin
                case T is
                when N =>
                        return P;
                when O =>
                        return X;
                when P =>
                        return N;
                when others =>
                        return O;
                end case;
end;

begin

   a1 <= io_invert(a);
   b1 <= io_invert(b);
   c1 <= io_invert(c);

   ss2 <= O;
   ss3 <= O;   
   
   s1 <= io_invert(ss1);
   s2 <= io_invert(ss2);
   s3 <= io_invert(ss3);

end process;

end Behavioral;

********** Mapped Logic **********
LDCP_s10: LDCP port map (s1(0),s1_D(0),NOT a(1),s1_CLR(0),s1_PRE(0));
     s1_D(0) <= NOT (((a(0) AND NOT b(0))
      OR (NOT a(0) AND NOT c(0))));
     s1_CLR(0) <= (NOT a(0) AND NOT c(0));
     s1_PRE(0) <= (NOT a(0) AND c(0));
LDCP_s11: LDCP port map (s1(1),s1_D(1),NOT a(1),s1_CLR(1),s1_PRE(1));
     s1_D(1) <= NOT (((a(0) AND NOT b(1))
      OR (NOT a(0) AND NOT c(1))));
     s1_CLR(1) <= (NOT a(0) AND NOT c(1));
     s1_PRE(1) <= (NOT a(0) AND c(1));
s2(0) <= NOT ('0');
s2(1) <= NOT ('0');
s3(0) <= NOT ('0');
s3(1) <= NOT ('0');
Register Legend:
      FDCPE (Q,D,C,CLR,PRE,CE);
      FDDCPE (Q,D,C,CLR,PRE,CE);
      FTCPE (Q,D,C,CLR,PRE,CE);
      FTDCPE (Q,D,C,CLR,PRE,CE);
      LDCP (Q,D,G,CLR,PRE);

-- Entity ternary_clock

USE ternary.ALL;

ENTITY ternary_clock IS
        PORT (
              B_C : IN BIT;
              T_C : OUT FakeTrit
        );
END ternary_clock;

ARCHITECTURE Behavioral OF ternary_clock IS
signal flag : bit;
BEGIN
    PROCESS (B_C)
    BEGIN
        IF (B_C'event AND B_C = '1') THEN
            IF (flag = '0') THEN
                flag <= '1';
            ELSE
                flag <= '0';
            END IF;
        END IF;
        IF (B_C = '1' AND flag = '0') THEN
            T_C(0) <= '1';
        ELSE
            T_C(0) <= '0';
        END IF;
        IF (B_C = '1' AND flag = '1') THEN
            T_C(1) <= '1';
        ELSE
            T_C(1) <= '0';
        END IF;
    END PROCESS;
END Behavioral;