Here's the latest project I've been working on;
it's a Digital IC Tester, designed to identify and test and allow the manual manipulation
of digital ICs such as 4000 and 7400 series. The unit has a 24 pin zero insertion force socket
and the device supports testing chips between 14 and 24 pins, and that shows you how to orient
the chip in the socket. It can be used in Identify mode, where you just tell it how many pins there
are on the chip and it will go and try to identify by manipulating its inputs and controls and
then evaluating the outputs to see whether they match a known chip type. Alternatively,
you can run the Test function where you tell it what chip number you've got in there
and it then will exercise the chip and test it and then you can manually
manipulate the chip as well if you wish. The IC Tester is based on an item I found on
instructables.com and it's called Smart IC Tester and it's by a guy called Akshay Baweja.
I'm not sure how to pronounce that, so apologies if I get it wrong. I've added lots of additional
functionality to the software and I've expanded the ZIF socket from 16 to 24 pins and I've also
added quite a few things to the database and at the moment there are 182 chips supported, 61 of
which have got full definitions for their pins, numbering, and that sort of thing,
and I've expanded various test cases, so it's quite a bit updated. I'll put a link to
Akshay's instructables site down in the text. I've placed a 7400 chip in the socket so I'm going
to use Identify mode to try to see what that is, even though we know. How many
pins has it got? It's got 14. so it's now running through its database
and it's found a 7400, a 7403, 74132, 7426 and a 7437 and in total it found six
different matches, so this chip behaves like six different chips but as you can see
all of them are quad two input NAND gates. So, if we pick this one, it goes and
looks up the definition of the 7400, retests it and tells us that it's good,
and for the 7400 there are four test cases. This is showing case one of four,
where these are the values that have either been applied to the chip or are expected in
terms of outputs / responses from the chip. So, this is pin one which is here, this is pin
14, which is there, so in this case we've got Ground on pin seven, we've got Vcc on pin 14.
The test applies a zero and a zero to the inputs of the NAND gate and expect a high and it does
that for all four gates that are on this chip, so if we're run the next test that applies one to
each of the inputs on each of the NAND gates and again we get a high output, which is what you
what you would expect it's then swapped over the inputs and made a different one high and
the other one low and again we've got a high, and the final test to prove that all the gates
are behaving is that both inputs on each gate are set high and the outputs are low which is
what you would expect, so this IC 7400 is good. If we want to look at a more
detailed version of the chip and potentially manually manipulate it, we
can go into the Detail option. Right, so here we've got the chip in the center with
pin one up here, pin 14, pin 7 and pin 8. Inputs and outputs to the chip and different control
signals are identified by different symbols, so inward pointing arrows are inputs, that's these
ones here, outputs are outward pointing arrows, Vcc is a red square, Ground is a black square and
for things like clock signals and other Enable, Clear, Reset, all those sorts of things there
are other symbols that will be used on the chip. On the outside we've got the current
way that the input is being driven, where the downward pointing arrow being low and
an upward pointing arrow will be high, and we've got the current state of the outputs, with a filled in
circle being high and an outline circle being low. Each of the inputs and outputs to the chip and the
pin symbols is shown in a different color for each element on the chip, so this is a four element
chip with four NAND gates. So, if we would have a dual counter then we would have some pins outlined
say in magenta and some outlined in yellow, and that allows us to see which pins
relate to which element of the chip. So, if we actually step through the test cases,
now this is showing we're on test case one of four which we saw previously, again with both inputs
being low and the output being high for each gate. Step through the test cases, we now
get a more graphical view of things and there we've got both inputs being
high and all the outputs being low. So, as well as doing that we can actually
manipulate the inputs and observe the outputs, so if I, let's say, wanted to put this output
low, then what I can do is I can tap on it on the diagram and it will
then switch to Manual Mode, and, because in Manual Mode we'll be manipulating
inputs and controls, then the state of the outputs is irrelevant until we apply those changes. So,
there we go, we've moved to Manual Mode. That input has now gone low and all the outputs
have been hidden so we don't get confused. So, we'll leave that one low, we'll put
these two low, and we'll put this one low and the Test button is now lit
up, so we can hit the Test button and it applies those inputs and controls to the
chip and then shows us the state of the outputs. To switch back to Normal mode, we just hit the
Init button and we're back to showing the first of the four test cases, and in this case all of
the inputs on each of the gates are manipulated in the same way for each set of four test cases,
so, all low, one low one high, one high one low, all high and all low outputs, so that partially
checks the chip, but it doesn't potentially check for any interconnecting issues between the
different lines. So, the Manual Mode allows us to do whatever we want with the chip; so I can do
that and I can do that and we've now got different inputs and outputs on the various gates and we can
prove that the chip does what we expect it to do. Now inserted a 74241 into the ZIF socket, so
I'll do an Identify; it's a 20 pin chip and it's found it, 74241 Octal Buffer and
Line Driver, Tri-state. Select that, it says it's Good! So, let's go look at the details of this chip. Right we've got two different colors on here,
which shows us that even though it's an octal buffer, there are actually two four bit parts to
this chip. We've got an Enable line here, that is active low, as indicated by the overscore and also
by the circle on the chip pin. The controls are always shown as squares and can be manipulated,
unless it's a Clock, which we'll come to shortly. So, in this case this Enable line is low,
which is active, and for the other gates, their Enable signal is active high, and that's high, so
they're active. At the moment we've got input one, input two, input three, and input four in magenta;
output four, three, two, one also in magenta, and then the inputs for the yellow element are
on this side, with the outputs on this side. So, if we go and manipulate, let's
say, this input and this input, this input, then we would expect output one, output three and output four to go high, so hit
the Test button and that's what we get. And if we go and manipulate some of the other elements of
the chip, so we'll do one and four, right, and do the Test and those outputs go high and the outputs
for two and three stay low. Now, as this is a tri-state chip, and the tester applies a pull-up
resistor to the output lines if, let's say, we just clear all of the inputs down to zero, and
apply the Test, all the outputs have gone to zero. So, if we set the Enable pin on this element of
the chip, which is active low, and we set it high, that then will put the outputs all into
tri-state mode, so they should all go high, so, all the outputs in the purple element should all go high; that's this one, this
one, this one and this one, and there they are! Likewise, if we actually put the
Enable 2 line low and hit the Test key, then all the outputs on the yellow element also
go high so this chip seems to be working just fine I've now put a 7442 in the
Tester, so we can do a Test; it goes and finds the chip
definition in the database. Oh, it says this one is bad! It's a one
of 10 Inverting Decoder De-multiplexer, and here's the first test case. So, it's a 16 pin chip, Vcc and Ground,
now we'll go into the detail view straight away which gives us a better overview of
what the chip does and what pins do what. So in this case we've got four input
pins, one, two, four and eight. We've got ten output pins, from zero to nine,
and with this Decoder De-multiplexer the binary number presented on the inputs selects
which output is sent low, so here we've got 0 0 0 0 which gives output 0, and if we walk
through the test cases then test case two shows us with input one high, therefore
output one goes high. Next test case, input two goes high so output two goes high. Next
one, input one and two are high, which is a binary binary representation of three, so output three
goes high, right, and everything seems to be fine So, there we go, output seven is high
because inputs one, two, and four are high but when we get test case ten, we've got input
eight high with inputs four and two and one low, and output eight would be expected to
be high, but it's highlighted. Sorry, output eight would be expected to be low, but it's
highlighted because it's high, and output zero has gone low even though it's expected to be high. So
this IC is actually faulty. If we go to the next, final, test case, where we've got an input
on eight, a high input on eight and one, and output nine would be expected to be low,
it's high and output one is low ,so this shows us this is a faulty 7442 chip. Not sure
how I blew it up, but it's obviously broken. So, let's now put a good 7442
in and have a look at that. I've now swapped the 7442 for a good
one. I could go back to the main menu and choose the chip number again, but because it's
already on a 7442 I can just hit the Init button, that goes back to test one of ten. We can
then step through the defined test cases, so, we're expecting the inputs to climb from zero
to nine and we're expecting the outputs to go low, each one in turn, from zero to nine. So, we'll
do that this time with this different 7442, and that's how the thing should
behave, so one good 7442, one duff one. I have now put a 74595 chip in the ZIF
socket, so if we do a Test on that, 7 4 5 9 5, ooh oops, I'll just show you that the
Backspace key works, and the Clear key, 7 4 5 9 5. I really must speed this up! It's a good one! Okay, so
it's an 8-bit Tri-state Serial in Parallel Out Shift Register, and
just to explain a couple of things here, in this case some of the outputs are set to 'Don't
Care', which is why they've got no status on them. We've got a standard input here, which is a
serial input, we've got an Enable which is shown as a square on the chip, and it's active low,
so it's got the circle on it and the overscore. We've got a Reset, which is also active low,
so it's also got a circle and an overscore and for things like Reset and Clear we've got
a semicircle as the indicator on the chip. We've also got two Clocks here, and both these
clocks at the moment are in a low state. Now, if for each step on a test case, or for a manual
test, I want to actually just pulse that Clock, all I do is select it, like that, and
we've now moved back into Manual Mode, and we've got a positive pulse
which will be applied to that pin when we press the Test key. Now, if I press
it again, it goes to a high level. Press it again, it goes to a low level, or I can press
it again and it goes back to a pulse. So, that's an explanation of how the clocks work. Right, that's a quick overview
of the modified IC Tester; let me know if you have any
suggestions or other comments. Bye :-)
