Introduction to Binary Logic Circuits - by Nick Fletcher (2006)

We can cheat a little bit if we want. We could just use the '^' operator instead of the code we wrote for the XOR GATE. But let's not. Let's wrap up the code and place it in the 'guts' of a new class called XOR. Once we have this class, we will continue on and arrange the XOR and the other GATES into an adding machine and test it. Here is where the generalised command line argument handling will save us a little bit of work. It can accept any number of inputs and present their values to us for reference.
I have just decided that instead of 'hard coding' our GATEs into some construct within main(), I will build a new class called "ADDER" that contains the gates as members. ADDER can accept an array as an argument and work with any number of inputs we like. In actual fact, we present adder with both binary numbers from the command line. ADDER can split the array in half to find the two operands.
To keep ADDER's code a little bit cleaner, it will have a more powerful constructor that initialises the 'machinery'. We want to hide all the mess of constructing the machine so we can test our GATES clearly. Here is the code to implement the XOR GATE as a seperate class:

#include<iostream>
#include<string>
#include
#include
using namespace std;

typedef unsigned short int USI;

//class declarations
class OR{
        public:
        OR(){};
        OR(string nme);                           //OR's default constructor
        ~OR(){};                        //Nothing to release - empty destructor

        USI Do(USI in1, USI in2);

        private:
        string m_name;
};

class AND{
        public:
        AND(){};
        AND(string nme);                          //AND's default constructor
        ~AND(){};                        //Nothing to release - empty destructor

        USI Do(USI in1, USI in2);

        private:
        string m_name;
};

class NOT{
        public:
        NOT(){};
        NOT(string name);
        ~NOT(){};

        USI Do(USI in1){
            //cout << endl << this->m_name << " performing NOT on " << in1 << " = ";
            return !(in1);
        }
        private:
        string m_name;
};
class XOR{
        public:
        XOR(){}
        XOR(string nme);
        ~XOR(){};

        USI OP(USI in1, USI in2);

        private:

        AND        m_and;
        OR         m_or;
        NOT        m_not;
        string     m_name;
};
//main
int main(int argc, char* argv[]){
    int i;
    cout << "\n\nThe inputs given are: ";
    for(i = 0; i < argc -1; i++){
            cout << atoi(argv[i+1]) << " ";
    }
    XOR x1("Nick");
    USI res = 0;
    res = x1.OP((USI)atoi(argv[1]),(USI)atoi(argv[2])) ;
    cout << "\n\nthe results of XORing them are " << res << "\n\n\n\n";
    return 0;
}
//class definitions
OR::OR(string nme){
                m_name = nme;
}
USI OR::Do(USI in1, USI in2){
        //cout << endl << this->m_name << " performing " << in1 << " OR " << in2 << " = ";
        return in1|in2;
}
USI AND::Do(USI in1, USI in2){
        //cout << endl << this->m_name << " performing " << in1 << " AND " << in2 << " = ";
        return in1 & in2;
}
AND::AND(string nme){
                m_name = nme;
}
NOT::NOT(string nme){
                m_name = nme;
}
XOR::XOR(string nme){
                m_name = nme;
}
USI XOR::OP(USI in1, USI in2){
    USI output = 0;

    output = this->m_or.Do(this->m_and.Do(in1, this->m_not.Do(in2) ),//first input
                            this->m_and.Do(in2, this->m_not.Do(in1)));//second input!
    return output;
}

PROGRAM OUTPUT:

C:\???>adder1 1 0 <ENTER>

The inputs given are: 1 0

the results of XORing them are 1


C:\???>adder1 1 1 <ENTER>

The inputs given are: 1 1

the results of XORing them are 0


C:\???>adder1 0 0 <ENTER>

The inputs given are: 0 0

the results of XORing them are 0

10100010
          +
11100011
          =
10000101 with the MSB discarded.

Each ADDER object in the line of eight has two possible outputs from two operands that are given to it. The XOR GATE of the ADDER object reflects an addition of the two operands and the AND GATE reflects a carry to be sent to the next most significant bit in the bank of 8. An important fact to realise here is that there can only ever be one carry passed from any addition of single bit values. We will never have the problem of carry bits building up as we move from right to left. It's actually the same for decimal. The most that is ever passed to the left in an addition operation is a 1 numeral of the next power! 999 + 999 still only makes one unit of carry.
Knowing this, we can start to think about what must happen, gate wise, when carries are encountered. We know that we must add any carries to the current sum. So, to do a binary addition, we use an XOR GATE. We don't want two carries, so we send the first XOR output that does the initial addition to an OR along with the output from the AND that tests for a carry. This covers us, and the output from that OR becomes the new carry! Also, we need to XOR the carry in with the output of the initial addition XOR. I'll now run through what needs to be done, then we can code it.

• LSB(No CarryIn) - XOR both operands and place result in output
• AND Both operands and send this to BIT1's CarryIn.

• BIT1 - XOR both inputs and send output to XOR2 along with the CarryIn. Send result from XOR2 to ouput and to OR1.
• Send the output of AND also to OR1.
• The output of OR1 is the new CarryOut value going to the next bit's CarryIn.

• BIT2 - XOR both operands send output to XOR2 along with the CarryIn. Send result from XOR2 to ouput and to OR1.
• Send the output of AND also to OR1.
• The output of OR1 is the new CarryOut value going to the next bit's CarryIn.

You can design yours any way you wish of course, but I have chosen to build mine as a hard coded 8bit adder. This is a simpler way of doing it. Working with logic gates is, really, a waste of time. It's not a waste of time learning about them and seeing how they work, but we now know these things, and we can move on to the next stage of my tutorial that will focus on computer hardware and how it works. My point is, you would never get anything done if you had to worry about the gates inside the CPU! But it's nice to know that they are there. Anyway, we should think about the design for the 8bit adder.

I will use a class of adder that works with one bit at a time. Then, I can arrange them to send relative inputs/outputs to the next bit in line. The class should have a method that accepts three inputs(A, B and Carry). There should also be a method for providing output so we can send any carryOuts to the next column/bit. Finally, each one bit adder should be able to display it's own output value.

The inputs will be provided from the command line and using a helper function, converted into USI (Usigned Short Int. A typedef)arrays. Just to re-cap, I'll make a class that does the 8 bit adding using eight 1bit adders.

#include<iostream>
#include<string>
using namespace std;

typedef unsigned short int USI;

void Addend_Init(int args, char** theAddend, USI arr[]);

//class declarations
class OR{
      public:
      OR(){};
      OR(string nme); // OR's default constructor
      ~OR(){}; // Nothing to release - empty destructor

      USI Do(USI in1, USI in2);

      private:
      string m_name;
};

class AND{
      public:
      AND(){};
      AND(string nme); //AND's default constructor
      ~AND(){}; //Nothing to release - empty destructor

      USI Do(USI in1, USI in2);

      private:
      string m_name;
};

class NOT{
      public:
      NOT(){};
      NOT(string name);
      ~NOT(){};

      USI Do(USI in1){
          //cout << endl << this->m_name << " performing NOT on " << in1 << " = ";
          return !(in1);
      }
      private:
      string m_name;
};
class XOR{
      public:
      XOR(){}
      XOR(string nme);
      ~XOR(){};

      USI OP(USI in1, USI in2);

      private:

      AND        m_and;
      OR         m_or;
      NOT        m_not;
      string     m_name;
};
class ADDER{
      public:
      ADDER(){}
      ADDER(string nme);

      void         DoAdder(USI in1, USI in2);
      USI          GetAnd();
      USI          GetXor();

      private:
      USI     m_and_output;
      USI     m_xor_output;
      AND     m_and;
      XOR     m_xor;
      string  m_name;
};
class ADDER8{
      public:

      void DoBitAdd(USI A, USI B, USI CarryIn = 0); //note the default value to cover the LSB.
      void SetOutput(USI a){ m_output = a; }
      void SetCarryOut(USI a){ m_carry_out = a; }

      USI GetOutput(){ return m_output; }
      USI GetCarryOut(){ return m_carry_out; };

      private:
      USI     m_output;
      USI     m_carry_out;
      ADDER   m_adder;
      OR      m_or;
      XOR     m_xor;
      AND     m_and;
};
//main
int main(int argc, char* argv[]){
    int i;
    cout << "\n\nThe inputs given are: ";
    for(i = 0; i < argc -1; i++){
          cout << atoi(argv[i+1]) << " ";
    }

    int args = argc/2;
    USI addend1[8];
    USI addend2[8];
    Addend_Init(args, argv, addend1);
    Addend_Init(args, argv+8, addend2);

    cout << "\n\nThe two addends are:\n\nAddend1: ";
    for(i = 0; i < args; i++){
          cout << addend1[i];
    }
    cout << "\nAddend2: ";
    for(i = 0; i < args; i++){
          cout << addend2[i];
    }
    //make eight ADDER8 objects and put 'em through their paces!
    ADDER8 add0, add1, add2, add3, add4, add5, add6, add7;

    //it's now a simple case of presenting each ADDER8 object with
    //the two input addends, and the carryin from the last adder8 object
    //which is actually that object's m_carry out.

    add0.DoBitAdd(addend1[7], addend2[7], 0);
    add1.DoBitAdd(addend1[6], addend2[6], add0.GetCarryOut());
    add2.DoBitAdd(addend1[5], addend2[5], add1.GetCarryOut());
    add3.DoBitAdd(addend1[4], addend2[4], add2.GetCarryOut());
    add4.DoBitAdd(addend1[3], addend2[3], add3.GetCarryOut());
    add5.DoBitAdd(addend1[2], addend2[2], add4.GetCarryOut());
    add6.DoBitAdd(addend1[1], addend2[1], add5.GetCarryOut());
    add7.DoBitAdd(addend1[0], addend2[0], add6.GetCarryOut());

    cout << "\n\nOutput : ";
    cout << add7.GetOutput();
    cout << add6.GetOutput();
    cout << add5.GetOutput();
    cout << add4.GetOutput();
    cout << add3.GetOutput();
    cout << add2.GetOutput();
    cout << add1.GetOutput();
    cout << add0.GetOutput() << "\n\n\n\n\n";


    return 0;
}
void Addend_Init(int args, char* theAddend[], USI addend[]){
                int i;

                for(i = 0; i < args; i++){
                      addend[i] = (USI)atoi(theAddend[i+1]);
                }
}
//class definitions
OR::OR(string nme){
              m_name = nme;
}
USI OR::Do(USI in1, USI in2){
      //cout << endl << this->m_name << " performing " << in1 << " OR " << in2 << " = ";
      return in1|in2;
}
USI AND::Do(USI in1, USI in2){
      //cout << endl << this->m_name << " performing " << in1 << " AND " << in2 << " = ";
      return in1 & in2;
}
AND::AND(string nme){
                m_name = nme;
}
NOT::NOT(string nme){
                m_name = nme;
}
XOR::XOR(string nme){
                m_name = nme;
}
USI XOR::OP(USI in1, USI in2){
    USI output = 0;

    output = this->m_or.Do(this->m_and.Do(in1, this->m_not.Do(in2) ),//first input
                           this->m_and.Do(in2, this->m_not.Do(in1)));//second input!
    return output;
}
ADDER::ADDER(string nme){
                    m_name = nme;
}
void ADDER::DoAdder(USI in1, USI in2){
            this->m_and_output = this->m_and.Do(in1, in2);
            this->m_xor_output = this->m_xor.OP(in1, in2);
}
USI ADDER::GetAnd(){
    return m_and_output;
}
USI ADDER::GetXor(){
    return m_xor_output;
}
void ADDER8::DoBitAdd(USI A, USI B, USI CarryIn){
//after this, the next bit can get it's inputs from this object and from the addends array.
//we have to take care of this bit's output(including the carry in) and the carry out.
    USI tmp1 = 0, tmp2 = 0;

    this->m_adder.DoAdder(A,B); //set the addends results. m_adder holds this data
    this->SetOutput(this->m_xor.OP(this->m_adder.GetXor(),CarryIn)); //catch the overflow from adding the carryin to the output

    //The carry out is thus...

    tmp2 = this->m_or.Do(this->m_adder.GetAnd(), //the carry_out produced by this 'bit'
    this->m_and.Do(this->m_adder.GetXor(),CarryIn)); //the carry in, ANDed with the output and the CarryIn!
    this->SetCarryOut(tmp2);
    cout << "\n\n-- Carry out:" << this->GetCarryOut();
    cout << "\n-- Carry in :" << CarryIn;
    cout << "\n-- Output   :" << this->GetOutput();


}

PROGRAM OUTPUT:

The inputs given are: 1 1 0 0 1 0 1 0 1 1 0 1 1 1 0 1

The two addends are:

Addend1: 11001010
Addend2: 11011101

-- Carry out:0
-- Carry in :0
-- Output   :1

-- Carry out:0
-- Carry in :0
-- Output   :1

-- Carry out:0
-- Carry in :0
-- Output   :1

-- Carry out:1
-- Carry in :0
-- Output   :0

-- Carry out:1
-- Carry in :1
-- Output   :0

-- Carry out:0
-- Carry in :1
-- Output   :1

-- Carry out:1
-- Carry in :0
-- Output   :0

-- Carry out:1
-- Carry in :1
-- Output   :1

Output : 10100111

To wrap up this first installment, I'd just like to make a few points about this exercise. Firstly, you may think this is just a program, and it is rather useless. Well, as a program it is! But let me assure you, if you got out some light switches and wired them up the same way we have in our code here, you would achieve the same results. You would, of course, need to flick each switch manually to input your individual bits! If you wanted to get a little bit more into this side of things, you could go and buy some real logic gates from your local electronics store. They come on a chip called an IC (intergrated circuit) and allow you to play around with what we have been discussing here. You can get these ICs with AND OR XOR and other flavours of switch, with between 4 and 12 switches on each IC. Anyway, that's for another discussion!

My second point is that what you have seen here is not the way a real, modern computer CPU would do things. That also, is another topic. What we made would work as far as allowing a simple computer to compute the sum of two numbers, but it would be slow if you wanted to process millions on numbers one after the other. And all our machine can do is ADD. A real CPU can subtract, divide and multiply. Don't worry though. What you have learnt is certainly valid! The same switches are used. They just use more of them and wire them up much more cleverly.

So I hope this was an enjoyable and informative read. I will now start work on the next section, and it will be ready ASAP. The next section will be a look at computer hardware and how to emulate our own computer with software. Yes... It'll be quite involving, but fun!