Hi. In the previous video in this Digital Logic Design series, we took a look at Boolean Algebra and Demorgan's Theorum X' and the various laws, community of laws, associative laws, distributive laws, and though all that horrible like boolean algebra type stuff and it was quite theoretical but important stuff. But we didn't really look at how do we actually create a practical digital logic circuit based on the truth table. So that's what we're going to take a look at today, designing combinatorial logic circuits, or how to convert basically a truth table into a digital logic or complex digital logic to perform the function that you intend.

Because when you design in a system, you want something, you've got various inputs. So let's go a B and we'll have an output X And you've no doubt seen the truth tables in before in the previous videos, you most certainly have. We've got all the various combinations of the inputs in this case, there's only four of them because only got two inputs. And let's say we wanted our outputs like this right? How do we convert that into a digital logic? Well, we're going to use what's called the sum of Products method to do this.

So what we do is we look at which of the outputs here are 1 and then we're going to create that using an gates. So any expression like that, we just go one by one through the truth table. In this case, it's a real easy Truth tables. There's only four rows in our truth table and only one of them has a 1 on the output.

It's really easy. So we're going to create the sum of products. So what we need to do is look for the first one here that contains a 1 and we're going to create that using n gates. so let's do that.

So we've got our inputs A and B here so we'll actually go up here like this. So this particular line here: A and B inputs. Now we want the output to be a 1 when A is 0 and B is 1. and we need to do this using an end gate like this.

So this is X on our output. So how do we do that? Well, it's easy. A needs to have an inverter like that. We've got to convert the zero of the A here into a one and B's already a one.

so we can feed be just straight into Ln Gate And believe it or not, that's it. X equals or not A because we've inverted it and B And believe it or not, that is the entire expertise. the entire circuit for this truth table. Why? Because we've gone through and looked at all of all of these.

this one, this one, this one, and this one here and only one of them has a one on the output. And because this is digital logic, it's either a 1 or a 0. The output here X can either be a 1 or a 0 and we've done the case here where it's a 1 So in all other cases, it doesn't matter what A and B are doing here. this output X will always be a 0.

So it doesn't matter if they're both is 0, they'll give a 0 there, 1 and 0. It'll give a 0. 1 on 1. It'll give a 0 because we've designed it around this case here and all the others are just going to come out in the wash.

So bingo, we've done it. So let's see where this expression sum of products comes from. So what we'll do now is just arrays that and we will put a 1 in there. So we've changed it so this one's already the same here so we don't have to change that.

This circuit here is going to remain exactly the same. But because we've got another expression in our truth table here that is a 1 on the output, we have to once again create, use another and gate here like this to actually generate that input. So we're going to have the input. In this case, A is a 1 so we don't need that.

But you guessed it, B is gonna need the inverter so it's opposite to what we had before. In this case, X equals A and not B like that. But of course we're not done yet. We've done the product part of this, so each one of these is essentially the product aspect of it.

But now we have to do the sum part of it. And we do that using an or gate like this, and we just take each expression that we got from each one of these terms in our truth table here. and then we just all them together. Always sum them together with an or gate to give us a final expression like that.

Bingo! Now we have the complete circuit which represents this complete truth table here in the sum of products form. Beautiful. That's it. We've designed a combinatorial logic circuit based on our desired truth table here, because in system design, you have a bunch of inputs that you wanna that you have from very whatever it is and then you want to actually do some logic on that and produce a particular output and this is how you do it.

It's that simple. Now, in practice, this might not be the easiest circuit to implement if you've got your 74 series, our logic, or whatever, then because look, we've got an Or gate over here. We've got two angles, we've got two inverters, three different types of logic gate there, so it would be nice if we actually consolidated this circuit into just one particular type of gate. And probably the best way to do this and most versatile as we'll see is with the NAND gate.

So let's actually take this circuit and convert it into just using NAND gates. Now we can do this over here like this and our our or we can convert in turn and by inverting or not in the inputs like that. So we could have our circuit just like this. But we've still got our inverters over here and we've got an gates here.

But look, we've got our Nots here. What if we just moved this? Not from here to here and here to here? You guessed it. we've got. let's get rid of that.

That and we use NAND gates there. Bingo. Then we can simply arrays our inverters there and we can put in a NAND gate like that. just both inputs like that and Bob's your uncle.

That is the equivalent circuit to that up there. but it's or it's using basically the same number of gates. It's using five gates, but they're all NAND gates, so that can be advantageous if you're using discrete logic or whatnot. It can be just very handy to use the one particular type of gate.

And we actually forgot to look at our final expression here. X equals actually not A and B or A and not B like that. You can put brackets around those if you want to keep it nice and tidy. And that's our boolean logic expression.

That's our boolean algebra expression for this particular circuit. And of course, we've seen in the previous video how we can actually use Demorgan's Theorum and the various laws to actually simplify boolean algebra like this. so this would really come into play if you had A A B C D E F inputs like this and if you even, well, just those alone would produce a massive truth table. You know you have to go through 1, 0 like and imagine if you had a whole bunch of those, it the expression would be can end up being absolutely enormous, not excluding the fact that you can have multiple outputs if you really wanted as well and this one could be a one.

or you know, it's something like that. Whatever. You can have various outputs for various purposes, so you can combine lots of input slots of outputs and you'd end up with a massive expression. This one is about as simple as it gets, and yes, we can use those laws and theorems in the previous video to do that.

But I Think in the next video we'll show you a graphical technique for doing circuit simplification called Carnot mapping and it just uses a visual. It's a visual way to do it and it is quite neat and you might well. nobody uses this sort of stuff anymore. it's just all theoretical stuff.

You're learning your Digital Logic 101 class. Well, no, all this sort of stuff is still valid whether you're designing the latest Intel you know, I seven whatever processor because just reducing the number of gates Circuit digital circuit simplification is very important. Not only use less gates, use less silicon area, which makes your chip smaller, it makes it faster as well and all sorts of stuff. So this sort of stuff is still done today even though you know there's not many people designing with you know, big systems with discrete 7-4 series our logic anymore.

This would of course a big thing back in the day to save X number of chips on your board was very handy, but it is still very important to know this from a digital logic point of view. So look at digit Kanto map simplification next time. So I hope you enjoyed this and if you did, please give it a big thumb. Oh well.

Thumbs up. That's not that's like a inductor isn't it? Give it a big inductive thumbs up if you liked it. And as always, discuss down below in the comments or on the Eevblog forum. Catch you next time you.