74/54 series test device using Arduino

[cowasaki]

I have 500+ mainly 74 series chips mostly from pulls.  I thought that it would be a good idea to test them so connected my USB programmer which is supposed to do just that but it doesn't work correctly so I thought that it would be a reasonably simple matter to build a device to do it.  I have a nice case and thought it would be an interesting project.  So I'm currently about to start by using a shield with a ZIF in it and take it from there.  I've had a thought about the software and for flexibility I've decided to call a function for each IC using other functions to do the work.

After removing the quotes this would be the call for a single device:

Code: [Select]

if (menu=='7400')
begin
  testIC_QuadSameGate(inNormal, outNormal, gateNAND, 0b0010000000000000, b0000000001000000, 0b0000000000000011, 0b0000000000000100, 0b0000000000011000, 0b0000000000100000, 0b0000001100000000, 0b0000000010000000, 0b0001100000000000, 0b0000010000000000
 end;

This is basically a function with 13 values with all gate types being unsigned binary ints:

input gate type
output gate type
gate type (there will be alternative functions for any ICs with multiple gate types if I come across them)
input power pins
output power pins
gate 1 input pin(s)
gate 1 output pin(s)
gate 2 input pin(s)
gate 2 output pin(s)
gate 3 input pin(s)
gate 3 output pin(s)
gate 4 input pin(s)
gate 4 output pin(s)

This will allow each gate to be tested individually and fully.

I will obviously have to test different device output etc but I'm working on that idea.  Here are the first few ICs including the remarks.  A lot of devices can just be copied from others.  There is enough memory in a 664 and enough I/O pins to do it this way rather than use a complicated data structure.

I just wrote this in text input and will move it to the IDE when I've built the shield this afternoon.

Code: [Select]

Chip test

//
// outPUTS
//
// outNormal
// outOpenCollector   - require external pull up resistor for proper logical operation
// out15VOpenCollector
// out30VOpenCollector
// out39VOpenCollector

//
// inPUTS
//
// inNormal
// inSchmitt

//
// gateS
//
// gateNAND
// gateNOR
// gateNOT
// gateAND
// gateOR
// gateBuffer




if (menu=='7400')
begin
  //                  Input     Output     Gate        POWER INPUT         GROUND INPUT         
  //                                                   6543210987654321    6543210987654321   
  testIC_QuadSameGate(inNormal, outNormal, gateNAND, 0b0010000000000000, 0b0000000001000000,
    0b0000000000000011, 0b0000000000000100, 0b0000000000011000, 0b0000000000100000, 0b0000001100000000, 0b0000000010000000, 0b0001100000000000, 0b0000010000000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output       Gate 4 input        Gate 4 output             
end;

if (menu=='7401')
begin
  //                  Input     Output             Gate       POWER INPUT         GROUND INPUT         
  //                                                          6543210987654321    6543210987654321
  testIC_QuadSameGate(inNormal, outOpenCollector, gateNAND, 0b0010000000000000, 0b0000000001000000,
    0b0000000000000110, 0b0000000000000001, 0b0000000000110000, 0b0000000000001000, 0b0000000110000000, 0b0000001000000000, 0b0000110000000000, 0b0001000000000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output       Gate 4 input        Gate 4 output             
end;

if (menu=='7402')
begin
  //                  Input     Output     Gate       POWER INPUT         GROUND INPUT         
  //                                                  6543210987654321    6543210987654321   
  testIC_QuadSameGate(inNormal, outNormal, gateNOR ,0b0010000000000000, 0b0000000001000000,
    0b0000000000000110, 0b0000000000000001, 0b0000000000110000, 0b0000000000001000, 0b0000000110000000, 0b0000001000000000, 0b0000110000000000, 0b0001000000000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output       Gate 4 input        Gate 4 output             
end;

if (menu=='7403')
begin
  //                  Input     Output            Gate       POWER INPUT         GROUND INPUT         
  //                                                         6543210987654321    6543210987654321   
  testIC_QuadSameGate(inNormal, outOpenCollector, gateNOR ,0b0010000000000000, 0b0000000001000000,
    0b0000000000000110, 0b0000000000000001, 0b0000000000110000, 0b0000000000001000, 0b0000000110000000, 0b0000001000000000, 0b0000110000000000, 0b0001000000000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output       Gate 4 input        Gate 4 output             
end;

if (menu=='7404')
begin
  //                 Input     Output    Gate       POWER INPUT         GROUND INPUT         
  //                                                6543210987654321    6543210987654321   
  testIC_HexSameGate(inNormal, outNormal, gateNOT ,0b0010000000000000, 0b0000000001000000,
    0b0000000000000001, 0b0000000000000010, 0b0000000000000100, 0b0000000000001000, 0b0000000000010000, 0b0000000000100000, 0b0000000100000000, 0b0000000010000000,
    0b0000010000000000, 0b0000001000000000, 0b0001000000000000, 0b0000100000000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output       Gate 4 input        Gate 4 output             
  //  Gate 5 input        Gate 5 output       Gate 6 input        Gate 6 output                   
end;

if (menu=='7405')
begin
  //                 Input     Output               Gate       POWER INPUT         GROUND INPUT         
  //                                                           6543210987654321    6543210987654321   
  testIC_HexSameGate(inNormal, out30VOpenCollector, gateNOT ,0b0010000000000000, 0b0000000001000000,
    0b0000000000000001, 0b0000000000000010, 0b0000000000000100, 0b0000000000001000, 0b0000000000010000, 0b0000000000100000, 0b0000000100000000, 0b0000000010000000,
    0b0000010000000000, 0b0000001000000000, 0b0001000000000000, 0b0000100000000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output       Gate 4 input        Gate 4 output             
  //  Gate 5 input        Gate 5 output       Gate 6 input        Gate 6 output                   
end;

if (menu=='7406')
begin
  //                 Input     Output               Gate       POWER INPUT         GROUND INPUT         
  //                                                           6543210987654321    6543210987654321   
  testIC_HexSameGate(inNormal, out39VOpenCollector, gateNOT ,0b0010000000000000, 0b0000000001000000,
    0b0000000000000001, 0b0000000000000010, 0b0000000000000100, 0b0000000000001000, 0b0000000000010000, 0b0000000000100000, 0b0000000100000000, 0b0000000010000000,
    0b0000010000000000, 0b0000001000000000, 0b0001000000000000, 0b0000100000000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output       Gate 4 input        Gate 4 output             
  //  Gate 5 input        Gate 5 output       Gate 6 input        Gate 6 output                   
end;

if (menu=='7407')
begin
  //                 Input     Output             Gate       POWER INPUT         GROUND INPUT         
  //                                                         6543210987654321    6543210987654321   
  testIC_HexSameGate(inNormal, outHVOpenCollector, gateNOT ,0b0010000000000000, 0b0000000001000000,
    0b0000000000000001, 0b0000000000000010, 0b0000000000000100, 0b0000000000001000, 0b0000000000010000, 0b0000000000100000, 0b0000000100000000, 0b0000000010000000,
    0b0000010000000000, 0b0000001000000000, 0b0001000000000000, 0b0000100000000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output       Gate 4 input        Gate 4 output             
  //  Gate 5 input        Gate 5 output       Gate 6 input        Gate 6 output                   
end;

if (menu=='7408')
begin
  //                  Input     Output     Gate       POWER INPUT         GROUND INPUT         
  //                                                  6543210987654321    6543210987654321   
  testIC_QuadSameGate(inNormal, outNormal, gateAND, 0b0010000000000000, 0b0000000001000000,
    0b0000000000000011, 0b0000000000000100, 0b0000000000011000, 0b0000000000100000, 0b0000001100000000, 0b0000000010000000, 0b0001100000000000, 0b0000010000000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output       Gate 4 input        Gate 4 output             
end;

if (menu=='7409')
begin
  //                  Input     Output             Gate       POWER INPUT         GROUND INPUT         
  //                                                          6543210987654321    6543210987654321
  testIC_QuadSameGate(inNormal, outOpenCollector, gateNAND, 0b0010000000000000, 0b0000000001000000,
    0b0000000000000011, 0b0000000000000100, 0b0000000000011000, 0b0000000000100000, 0b0000001100000000, 0b0000000010000000, 0b0001100000000000, 0b0000010000000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output       Gate 4 input        Gate 4 output             
end;

if (menu=='7410')
begin
  //                    Input     Output     Gate          POWER INPUT         GROUND INPUT         
  //                                                       6543210987654321    6543210987654321   
  testIC_TripleSameGate(inNormal, outNormal, gateNAND, 0b0010000000000000, 0b0000000001000000,
    0b0001000000000011, 0b0000100000000000, 0b0000000000011100, 0b0000000000100000, 0b0000011100000000, 0b0000000010000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321   
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output                     
end;

if (menu=='7411')
begin
  //                    Input     Output     Gate         POWER INPUT         GROUND INPUT         
  //                                                      6543210987654321    6543210987654321   
  testIC_TripleSameGate(inNormal, outNormal, gateAND, 0b0010000000000000, 0b0000000001000000,
    0b0001000000000011, 0b0000100000000000, 0b0000000000011100, 0b0000000000100000, 0b0000011100000000, 0b0000000010000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321   
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output                     
end;

if (menu=='7412')
begin
  //                    Input     Output            Gate        POWER INPUT         GROUND INPUT         
  //                                                            6543210987654321    6543210987654321   
  testIC_TripleSameGate(inNormal, outOpenCollector, gateNAND, 0b0010000000000000, 0b0000000001000000,
    0b0001000000000011, 0b0000100000000000, 0b0000000000011100, 0b0000000000100000, 0b0000011100000000, 0b0000000010000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321   
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output                     
end;

if (menu=='7413')
begin
  //                  Input      Output            Gate        POWER INPUT         GROUND INPUT         
  //                                                           6543210987654321    6543210987654321   
  testIC_DualSameGate(inSchmitt, outOpenCollector, gateNAND, 0b0010000000000000, 0b0000000001000000,
    0b0000000000011011, 0b0000000000100000, 0b0001101100000000, 0b0000000010000000,
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321   
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output                     
end;

if (menu=='7414')
begin
  //                 Input      Output            Gate       POWER INPUT         GROUND INPUT         
  //                                                         6543210987654321    6543210987654321   
  testIC_HexSameGate(inSchmitt, outOpenCollector, gateNOT ,0b0010000000000000, 0b0000000001000000,
    0b0000000000000001, 0b0000000000000010, 0b0000000000000100, 0b0000000000001000, 0b0000000000010000, 0b0000000000100000, 0b0000000100000000, 0b0000000010000000,
    0b0000010000000000, 0b0000001000000000, 0b0001000000000000, 0b0000100000000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output       Gate 4 input        Gate 4 output             
  //  Gate 5 input        Gate 5 output       Gate 6 input        Gate 6 output                   
end;

if (menu=='7415')
begin
  //                    Input      Output     Gate       POWER INPUT         GROUND INPUT         
  //                                                     6543210987654321    6543210987654321   
  testIC_TripleSameGate(inSchmitt, outNormal, gateAND, 0b0010000000000000, 0b0000000001000000,
    0b0001000000000011, 0b0000100000000000, 0b0000000000011100, 0b0000000000100000, 0b0000011100000000, 0b0000000010000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321   
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output                     
end;

if (menu=='7416')
begin
  //                 Input     Output               Gate       POWER INPUT         GROUND INPUT         
  //                                                           6543210987654321    6543210987654321   
  testIC_HexSameGate(inNormal, out15VOpenCollector, gateNOT ,0b0010000000000000, 0b0000000001000000,
    0b0000000000000001, 0b0000000000000010, 0b0000000000000100, 0b0000000000001000, 0b0000000000010000, 0b0000000000100000, 0b0000000100000000, 0b0000000010000000,
    0b0000010000000000, 0b0000001000000000, 0b0001000000000000, 0b0000100000000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output       Gate 4 input        Gate 4 output             
  //  Gate 5 input        Gate 5 output       Gate 6 input        Gate 6 output                   
end;

if (menu=='7417')
begin
  //                 Input     Output               Gate          POWER INPUT         GROUND INPUT         
  //                                                              6543210987654321    6543210987654321   
  testIC_HexSameGate(inNormal, out15VOpenCollector, gateBuffer ,0b0010000000000000, 0b0000000001000000,
    0b0000000000000001, 0b0000000000000010, 0b0000000000000100, 0b0000000000001000, 0b0000000000010000, 0b0000000000100000, 0b0000000100000000, 0b0000000010000000,
    0b0000010000000000, 0b0000001000000000, 0b0001000000000000, 0b0000100000000000
  //  6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321    6543210987654321
  //  Gate 1 input        Gate 1 output       Gate 2 input        Gate 2 output       Gate 3 input        Gate 3 output       Gate 4 input        Gate 4 output             
  //  Gate 5 input        Gate 5 output       Gate 6 input        Gate 6 output                   
end;

I will have a function for each number of gates rather than overloading, again just for simplicity.

I will have a main function which will call each gate separately with a function specifically for testing a particular type of gate.

So this should cover all the ICs in the range and it will be completely open source.  The final device will have a 20x4 LCD display to select the IC type or run a test to work it out.

[amspire]

You could "borrow" the test vectors from other programmers. They often have a 7400/4000 series test function and the test vectors are often stored in a simple format. For example, if you download and install the one of the Wellon programmers, the vectors are in the C:\weilei\wellon\lib1\test190.lib file.

Just for example, here is the 4000 series chip in the editor:

Here it is in the test190.lib file (edited a bit to get rid of non-printing characters):

Code: [Select]

$4000        09 14
XX000HG0HH000V
XX100LG1LL001V
XX010LG0HL010V
XX110LG1LL011V
XX001LG0HL100V
XX101LG1LL101V
XX011LG0HL110V
XX111LG1LL111V*
Here is an example of a chip with a clock input:


Here is the wellon download page. If you go for one of the most recent software packages, it may have the best test190.lib file.
http://weilei.com.cn/dow.asp

[cowasaki]

You could "borrow" the test vectors from other programmers. They often have a 7400/4000 series test function and the test vectors are often stored in a simple format. For example, if you download and install the one of the Wellon programmers, the vectors are in the C:\weilei\wellon\lib1\test190.lib file.

Just for example, here is the 4000 series chip in the editor:

Here it is in the test190.lib file (edited a bit to get rid of non-printing characters):

Code: [Select]

$4000        09 14
XX000HG0HH000V
XX100LG1LL001V
XX010LG0HL010V
XX110LG1LL011V
XX001LG0HL100V
XX101LG1LL101V
XX011LG0HL110V
XX111LG1LL111V*
Here is an example of a chip with a clock input:

Thanks, I have a VP-180 so have seen their codes but the thing I don't like about them is that it just tests certain inputs against outputs.  My method would identify each individual gate and fully test that gate whilst checking that nothing happens with the other gates etc.  Also I want to be able to check buffers etc.  I'm thinking that over time (especially if it is left open source) other non 74/54/4000 series chips could be checked.

[amspire]

Thanks, I have a VP-180 so have seen their codes but the thing I don't like about them is that it just tests certain inputs against outputs.  My method would identify each individual gate and fully test that gate whilst checking that nothing happens with the other gates etc.  Also I want to be able to check buffers etc.  I'm thinking that over time (especially if it is left open source) other non 74/54/4000 series chips could be checked.

Sounds ambitious, but someone (probably you) will probably have to sit down with a big pile of data books and work through many hundreds of chips to input the vectors. There will almost certainly be heaps of mistakes so there will have to be an efficient update system.

If you are hoping that you don't need to add the vectors because users will, I think you will find you only have users if you have a very comprehensive database already. It is much harder for an end user to program good quality test vectors than it is for one person who is doing hundreds of vectors. Coming up with good test vectors is not something everyone does well. There may not be many people who are good at test vectors and who also need to test old 74 series chips.

The Weilei list is only scratching the full range of chips, but it is a very good start. I would guess that if you found a complex board with 100 TTL chips, 20% would not be in the Weilei list.

I also think you may be dismissing the simple looking Weilei vectors too quickly. They are often checking that all the gates appear to function and that adjacent pins are not shorted. They could test more, but is it really needed? Failed chips are often clearly failed - a NAND gate that just does not give the right values with the full set of input patterns. That is what the Weilei vectors test. When you are on your 300th chip, and you find that to test everything, you are struggling with your 500 vector test list (one of the more complex chips), I bet you will ask yourself "Do we really need all these vectors?"

[cowasaki]

Thanks. I plan on adding the test information for the 74 and probably 4000 range straight away. Other ICs can follow as I get chance or people can tell me what they want adding. One option I will be adding will be straight input and output values. So the weilei type would work for them 128K plus the eeprom should be space for quite a few chips :-)

Today I have a board partially built with the 1284P socket, crystal and 22pF caps in place plus a heart beat LED, the 2x20 LED display (might change to a graphical LCD later, ZIFF socket and 1284P double 40 pin header for attaching other things and testing. Just need to add a few more parts and I can look at the software. I’ll post a picture later but I’m sat in the car at the moment and the image is on my phone.

[matseng]

Maybe it would be possibly to automatically generate the testvectors by analyzing known-good chips from just some basic info like if a particular pin is in,out,bidirectional, or clock?  Then automatically generate the inputs to the chip, both as a comprehensive set of inputs in a "logical" sequence and in addition that that also apply "fuzzing" data by utilizing a (repeatable) pseudorandom sequence...

[cowasaki]

Maybe it would be possibly to automatically generate the testvectors by analyzing known-good chips from just some basic info like if a particular pin is in,out,bidirectional, or clock?  Then automatically generate the inputs to the chip, both as a comprehensive set of inputs in a "logical" sequence and in addition that that also apply "fuzzing" data by utilizing a (repeatable) pseudorandom sequence...

The circuit diagram and all the software will be totally public domain.  Once stable with the circuit I will publish a circuit diagram to discuss and then do the same with the board and once we are totally happy I will test the water and place an order for boards if people want to make it.  I can supply the 1284P already boot loaded with a board it can the be re-programmed at will via a FTDI232R lead which costs about £10 or alternatively I will add the circuitry to allow re-programming and communication via USB.  My last product was based on the Atmel IC and we did a desktop program in Windows and MacOS to control it so that would also be an option. 

Basically I'll get it started and listen to ideas etc......

[cowasaki]

The 1st prototype should be finished tomorrow (hopefully)

[james_s]

I have an IC tester I built years ago from an article in EPE magazine, somewhere I still have a pdf of the article. It uses a PIC and interfaces to a PC on which you create little test scripts, it works very well. There is even a more modern bit of software someone wrote to control it. With anything like this the hardware is relatively simple but creating the test scripts for all the ICs takes a lot of time and effort. Some stuff like basic gates are easy to test but some of the more complex parts require some thought and ideally a known good IC to test the test script.

[cowasaki]

I have an IC tester I built years ago from an article in EPE magazine, somewhere I still have a pdf of the article. It uses a PIC and interfaces to a PC on which you create little test scripts, it works very well. There is even a more modern bit of software someone wrote to control it. With anything like this the hardware is relatively simple but creating the test scripts for all the ICs takes a lot of time and effort. Some stuff like basic gates are easy to test but some of the more complex parts require some thought and ideally a known good IC to test the test script.

I fully agree.  I am hoping that with a more modern processor like the 1284P or even the 2560 we can build a completely stand alone device that does the same.  I think I can do most of the 74/54 & 4000 ranges reasonably quickly then possibly add more and more functionality to it as we go along. I picked the 1284P as it is a traditional 40 pin DIP so anyone on here should be able to solder it quite simply.  If it ends up requiring the 2560 then that would certainly give us the ability to handle graphical displays and ICs with more and more legs.  Having a 16-20 pin IC fully controllable means we could use the same device to read EPROMs/ROMs and re-program 5v devices.

Shown below is my last product which actually used the 1284P little brother.  I am going to build the 2nd prototype into one of these cases which has space for 4 AA batteries at the back.  The same case could handle a 40pin ZIFF and a full graphical LCD display running off the same 4 batteries and using a 2560.  Once the software is written for the LED display and 1284P it is a simple task to move it to the more powerful processor.  If it's open source then people can put it into any case they like.

[james_s]

I'm sure it will be possible, I don't think you'll even need much in the way of processor power, if anything perhaps an EEPROM to store the test scripts. I think you will want a companion program on a PC though to create the scripts, ideally something GUI based but the actual scripts could be simple text files. Otherwise you could spend the rest of your natural life writing test scripts and still be missing the one that somebody happens to need.

[cowasaki]

I am using this thread to think aloud as well 

Having been thinking about this for most of the day, I think it will need 6 lines for the display (many more if I go to graphics), SD card, 6 lines for input rota(s) buttons, maybe some status LEDs etc I am thinking that realistically it is going to need shift registers.  With shift registers I could drive the graphical display plus all the stuff I mentioned and still get away with using the 1284P.

With 5 x 74HC595s I can easily get out 40 pin output but the max current of each 74HC595 is 70mA so probably 7mA per output which is nowhere near enough.  Based on this I looked at a high power version of the 595 ie TPIC6A595 but these cost more than the micro controller! They are handy but still 100mA is probably enough to drive most of the ICs we are testing but it's £35 for 5 chips.......  Looks like it's going to be lots of transistors as this is cheap!  Using SMD components it's not really the end of the world......

I will build the device tomorrow to check it out and nick the menu system from another project.  This is just a proof of concept at the moment.  If it works well I can look at all the options then.

[james_s]

You might look for the EPE article to get an idea of the basic architecture. Don't worry about the display just yet, that's easy. The important part will be supplying power to the correct pins on the device under test, pullups to handle open collector outputs, etc. For the display perhaps a I2C or SPI controlled graphical LCD or OLED. Doesn't take much to show the IC type, test status and result, but with a graphical display you could show the correct socket position to insert the IC and any other info, maybe even make it possible to create a test script on the tester itself. If you wanted really fancy, small serial interfaced color TFT displays are dirt cheap.

[cowasaki]

I'm sure it will be possible, I don't think you'll even need much in the way of processor power, if anything perhaps an EEPROM to store the test scripts. I think you will want a companion program on a PC though to create the scripts, ideally something GUI based but the actual scripts could be simple text files. Otherwise you could spend the rest of your natural life writing test scripts and still be missing the one that somebody happens to need.

I thinking of including an SD card slot.  With that I can have all the 74/4000 etc ICs on the device and then read any extras from the SD card.  That would allow people to run any test they like.  With the code being open popular stuff could be added easily. 

I am just thinking about how I can adjust the output voltage of different pins.....

[cowasaki]

You might look for the EPE article to get an idea of the basic architecture. Don't worry about the display just yet, that's easy. The important part will be supplying power to the correct pins on the device under test, pullups to handle open collector outputs, etc. For the display perhaps a I2C or SPI controlled graphical LCD or OLED. Doesn't take much to show the IC type, test status and result, but with a graphical display you could show the correct socket position to insert the IC and any other info, maybe even make it possible to create a test script on the tester itself. If you wanted really fancy, small serial interfaced color TFT displays are dirt cheap.

Thanks I will take a look....

As for displays, I wrote the DUEGUE user interface for the Arduino DUE that is now open source.  I could stick a 5" or 7" touch display on it    However I think something a little more business like might be better unless people think differently - The touch display realistically needs the DUE, it will run on the 2560 but I wrote the GUI to be multitasking so I don't think the 16MHz 2560 will cut it.  If it did go down the DUE route then we could possibly get rid of the need for shift registers...

I was thinking that the IC just be placed pin 1 up as low in the ZIFF as possible. 

Connection to a PC is a simple addition that will certainly happen and any script could be saved to the EEPROM or SD card but could be written on the PC and saved to the SD card anyway.

[cowasaki]

Well I've been having a play...  I've built a prototype which has a couple of rotary encoders, 3 buttons, SD card reader, Atmel 1284P and a 20x4 Text LCD screen.  This is just to start the programming etc whilst I've also been putting together a design for the circuit.  This design has buses available so that all the Atmel 1284P legs go to double pins whilst all the added devices listed above can be removed from the circuit, added and moved within the circuit.  This will allow me to come up with the best way of doing things for this circuit but will also give me quite a powerful Atmel 1284P development system (To finalise this I will also add buses and sockets for graphic LCD, sets of 8 LEDs to show the output of buses, PS2 keyboard socket, numeric keyboard and a RTC)

[matseng]

For  product like this I think a gui and its expensive touch display would just be a waste of money.  The uint should in most cases be able to identify the chip and make a full verification automatically. And in case of any ambiguity a simpler display (character only?) with just a rotary encoder and a few buttons would probably suffice.

I mean there's only so much information to show about a digital ic (basically only the designation and a short description like "7404 - Hex Inverter")

Or do you have any other nice and cool functions planned for it?

[cowasaki]

For  product like this I think a gui and its expensive touch display would just be a waste of money.  The uint should in most cases be able to identify the chip and make a full verification automatically. And in case of any ambiguity a simpler display (character only?) with just a rotary encoder and a few buttons would probably suffice.

I mean there's only so much information to show about a digital ic (basically only the designation and a short description like "7404 - Hex Inverter")

Or do you have any other nice and cool functions planned for it?

I came to the same conclusion as you can see from the circuit design.  I have been thinking of other features that could be implemented using software with or without a few additional components.....



Simple 40 channel logic injector / analyser 

Two 20 way pin headers with ribbon cables going to IC leg clamps would give 40 clamps.  The software could change the 20 "output" pins as per any pre determined sequence and either record or display the values on the 20x4 screen.


Possibly an arbitrary signal generator

A pair of simple resistor ladders on a board plugged into the ZIFF socket could give a 16 bit analogue output with the ground coming from the other pins or a ground banana socket.  Likewise if this is a feature people would like the resistor ladder could be added to the main board and just go to banana plugs on the case anyway.


Data injector

As per the logic injector about the device could inject 8, 16 or 32 bit data from an SD card into a circuit.


Most of the above are VERY cheap additions and I'm sure there are other things.  They could still be done using the 20x4 char display or a GLCD display.

[cowasaki]

Just thought of another possible thing although it would require the addition of a simple socket.....

A serial multimeter data logger recording straight to the SD card :-)  It can then be read into excel where you can display a graph.

Oh and EEPROM programmer :-) - We've already got the socket so why not......


EDIT: I've changed the circuit diagram to add a 10 pin header inside the device.  PD2 & PD3 have been re-allocated back to their 1284P built in function of being a serial connection and the E & RS pins for the LCD are now moved elsewhere.  So RXD1 (PD2) & TXD1 (PD3) now connect to pins 1 & 2 of the header and it's just software. 

[james_s]

Watch out for feature creep. Programing EPROMs would require a DC-DC converter with several settings to supply the programming voltage.

[cowasaki]

Watch out for feature creep. Programing EPROMs would require a DC-DC converter with several settings to supply the programming voltage.

EEPROMS :-) 5v programmable ones like micro controllers etc.

[TK]

The MiniPro TL866CS Universal Programmer can do 74 logic testing... I am not sure if it supports 100% of the chips

[cowasaki]

The MiniPro TL866CS Universal Programmer can do 74 logic testing... I am not sure if it supports 100% of the chips

But where is the fun in that?  If I can spend a month and three times as much money isn't that FAR better

Seriously though.  Every time I build something I learn more and I'm hoping to make it do far more plus once it's working it shouldn't be expensive for people on here to get a PCB and build one too.

[amspire]

Still having trouble why I would use your board if I had a commercial programmer with 74/4000 series testing available. I find they do enough and I hardly ever actually use it anyway.

You could look at adding some useful extra capability.

For example, if you used a PIC microcontroller with the CTMU feature (the Charge Time Measurement Unit), you could measure chip delay times down to sub nanosecond levels. For IC's that can take a range of supply voltages, you might want to test at different voltages. If it was extended to do static RAMs, it would be nice to be able to read the actual RAM speeds.

Another thing would be static and clocked power consumption. The old 74xx/74Fxx chips do have a really high current consumption along with many of the old programmable DIP chip. Things like GALs and PEELs (eg PEEL18CV8) can have static supply currents varying from 0 to 100mA depending on what variant you buy.

[cowasaki]

Still having trouble why I would use your board if I had a commercial programmer with 74/4000 series testing available. I find they do enough and I hardly ever actually use it anyway.

You could look at adding some useful extra capability.

For example, if you used a PIC microcontroller with the CTMU feature (the Charge Time Measurement Unit), you could measure chip delay times down to sub nanosecond levels. For IC's that can take a range of supply voltages, you might want to test at different voltages. If it was extended to do static RAMs, it would be nice to be able to read the actual RAM speeds.

Another thing would be static and clocked power consumption. The old 74xx/74Fxx chips do have a really high current consumption along with many of the old programmable DIP chip. Things like GALs and PEELs (eg PEEL18CV8) can have static supply currents varying from 0 to 100mA depending on what variant you buy.

Maybe you wouldn't use it.  I'm not suggesting its just what everyone has to have. Its a project and it will have lots of extra functions that i have not even thought of as ideas come up.