Why all of the Logic Chips

[wigman27]

G'day again,

A very open ended question, in a number of Dave's tear-downs (most actually), there are so many Logic chips in the boards, whether it be 74 or 4000 series or something totally different.

I have done a few projects now and I use the processor and software to do most of my logic operations. Am I doing it wrong? should I be looking to include external logic in my projects? Is it required?

My original idea I had was that processors have developed so quickly and are capable of much more now then when I guess these devices were designed, that you had to do quite a lot of logic operations outside of the processor to save memory? Am I on the right track at all or I have I just not come across a need for them yet or missed an opportunity to use them?

Thanks

Lee

[Simon]

Logic chips were used a lot in the past because there was no alternative and they were and can still be faster plus you can dedicate them to the task unlike most microcontrollers. Of course in my mind and with some of the work i do now I would consider logic gates possibly more resilient and safer is the application is safety critical and you don't want the risk that your software locks up.

[wigman27]

That's a fair call!

So it was mainly to extend the reliability and usability and take logic operations outside the micro controller.

It may be interesting to do a project that required some logic, I must confess I have used a very small amount of it in a project I didn't design but it would be good learning to try and use some hard logic. Any suggestions on a good project that would be good to use external logic?

Thanks Mate

Lee

[bwat]

I have done a few projects now and I use the processor and software to do most of my logic operations. Am I doing it wrong? should I be looking to include external logic in my projects? Is it required?

If it works for you then you're not doing it wrong.

My original idea I had was that processors have developed so quickly and are capable of much more now then when I guess these devices were designed, that you had to do quite a lot of logic operations outside of the processor to save memory? Am I on the right track at all or I have I just not come across a need for them yet or missed an opportunity to use them?

A processor is just programmable logic. The CPU's datapath contains arithmetic and logic circuits and maybe a shifter, and registers which are configured by a control unit. Your software is used by the control unit to determine the configuration. So it really doesn't make much difference for sequential circuits if it is done by a CPU or a dedicated circuit.

[Simon]

if you wanted to do fancy sequencing lights or similar you could use logic, you could use a counter to generate a sequence of numbers from a clock signal that can be as slow as need be and you can then build a combination logic circuit that takes the number sequence and uses it to determine which combination of outputs to turn off or on.

often you will connect two open collector outputs on a comparator together with a common pull up resistor, this automatically forms a NOR gate.

[bwat]

It may be interesting to do a project that required some logic, I must confess I have used a very small amount of it in a project I didn't design but it would be good learning to try and use some hard logic. Any suggestions on a good project that would be good to use external logic?

Drop the microprocessor/microcontroller and build something only from logic gates. Simon gave you some examples. You could even build your own CPU. There's a wealth of info out there and plenty of free simulation tools so you wouldn't have to spend any money. There's also cheap FPGA boards out these if you wanted to see it in action for real.

[amyk]

One advantage of custom logic is that it can be asynchronous and parallel, unlike a CPU which has to execute instructions to simulate that. Large numbers of discrete gates have been replaced by CPLDs and FPGAs (and GALs/PALs/etc. before that), but you'll still find small numbers of discrete gates in use in various devices.

[Bukurat]

 A lot of early equipment used TTL or CMOS logic gates,  counters, flip flops etc because that's all that was available at the time. LSI is a relative newcomer.
 I have boards produced in the 70's and 80's that are full of TTL.

[dentaku]

Logic ICs are also still useful when you want to cut down on the number of pins used by your microcontroller. Shift Registers, multiplexers and even 7-segment drivers and Schmitt-trigger inverters are all useful even today.
I like messing with 4000 series stuff because it's fun to experiment with but I doubt I would be using flipflops, gates, counters, and such if I actually wanted to get stuff done in the real world except for the simplest of applications.

[T3sl4co1l]

A typical example would be, a processor to handle all the intricate, sequential operations required for operation (scheduling functions, analyzing I/O, implementing communication protocols, etc.), then discrete logic to encode/decode bus signals to implement internal I/O registers which connect to real-time functions: ADC/DAC, timers, controllers, etc.  The discrete logic, in turn, could potentially be quite intricate, and verbose if production quantities remain small enough not to justify implementing it in an ASIC (as most PC system boards got -- compare the original IBM PC-XT motherboard to late models and clones).  The reason for all the logic is usually reliability and real-time performance: with cheap processors topping out at a few MIPS, it was impossible to route tens or hundreds of signals through one, in real time.

These lessons should not go to waste today.  Computation is cheap, but processors crash.  Pointers get corrupted.  Software is inevitably the buggiest part of the system, and suffers the worst from the Dunning-Kruger effect: Bad programmers never realize how many ways their program will fail -- it should be no wonder why software is so popular, eh? -- while good programmers are constantly aware of potential problems, and attempt to avoid them.

Today, logic is cheap, when implemented in a programmable array.  But beware anything that comes back to code: it's just as possible, in firmware as in software, to make something functionally equivalent to the goal, yet which fails dramatically under various edge cases (in the simulator; in real implementation; under variation of inputs and timing; temperature and manufacturing variations; etc.).

Undoubtedly, the same is still true of old discrete designs, but the much more lengthy (and expensive) design procedure likely would've included better testing (including breadboarding and real test signals), which at least helps.  There's also the problem of timer sequenced logic: something you can't synthesize from VHDL, but which both simplifies (when done right) and massively complicates (when applied carelessly) discrete logic designs.  There have been many discrete designs that were un-maintainable due to their use of complex webs of timer circuits.  This (besides the inability to synthesize it) is why timed logic is frowned upon today.

Tim

[tszaboo]

I felt really weird the first time when I had to use discrete logic. But after a while I find it that I'm using more and more. And surprisingly, most of the times when if is near analog circuits.
Like I had a board which had the LEDs on the front panel, MCU on the other side, precision analog in between. To keep the nosie down I had to buffer the signals driving the LEDs, because after several request not to, they still decided to make PWM for the LEDs.
When the NOT gate was there, it was only microamps flowing next to the analog instead of ten miliamps. This was just one example.
I've seen a (recently designed)power supply, where they had a CD4046 PLL to make the phase shift between phases. Genius usage. If you would go with a microcontorller, it just wouldn't fit on the board, because you need a power supply, level shifting back and forth... While the 4046 just run from the input ~12V.

[tautech]

have I just not come across a need for them yet or missed an opportunity to use them?

Logic still can be quite useful for simple designs and particularly in uPower applications.
Done properly they are very reliable and cheap.
The massive PCB's of yesteryear were pre LSI and SMD.
Most of the 74 and 4000 series now can be had in SMD and that should ensure their survival for a few more decades. 
One must be aware of the families of these devices and their different supply and threshold requirements.

A term that applied to strings of logic IC's, and not often seen these days, is glue logic, which describes how they are interfaced (stuck) together to provide the necessary result/output.

[VK5RC]

Who was it who said My favourite programming language is solder?

[miguelvp]

It was often used to address the CS_N when you had a lot of memory banks. I guess it does apply to other chip select pins for other things than memory. Like say you have several video processors sharing the same bus, you could select which one is currently active.

[jeremy]

Who was it who said My favourite programming language is solder?

bunnie: http://www.bunniestudios.com/

[Vgkid]

Who was it who said My favourite programming language is solder?

Bob Pease. analog guru.

[T3sl4co1l]

I felt really weird the first time when I had to use discrete logic. But after a while I find it that I'm using more and more. And surprisingly, most of the times when if is near analog circuits.

Exactly.  Very often, you have an analog circuit which does everything it needs to, in and of itself: but you need control or management or status or fault detection to support that circuit.  Well, all you need is a couple logic chips and you can implement all of that!

And no, you wouldn't want to use an MCU here, even if you have one handy, because by "faults" I mean "mission critical", blowing stuff up, or zapping people, if it fails to trip.  You can have software poking the registers that control it... in fact, that's the perfect place for it.  But having it entirely in software, that's an invitation right there.

It also allows you to build a bottom-basement absolutely stripped down minimal implementation of the project, which is otherwise fully functional and quite usable on its own: for example, a power supply with start/stop pushbuttons and control (volts/amps) pots.  The digital implementation would simply provide these signals from logic pins and DACs hanging off an MCU.

That way, the MCU gets to handle the things it's best at -- human or machine interface, driving a display, monitoring secondary conditions (like measuring voltages and temperatures -- rather than just tripping on a temp limit, say), things like that.  If the MCU crashes, at worst, the interface goes dead and the process output gets stuck where it was.  But you still have the big red "oh shit" button available to turn off the analog circuit, and it otherwise just keeps on doing whatever it's supposed to do.

Tim

[WarSim]

I see nobody has used the reasons of serial vs parallel and synchronous and asynchronous.  People seem to have exchanged these terms with digital and analog.  Problem is they may be very descriptive.  They are no as accurate as they should be for this topic. 

All types of computers had what is called analog and digital. 
Mechanical computers had both parallel resolvers and step stage processing.
Electrical computers had both settle symbol resolution and set set processing. 
Then processing was diverged into what is called analog and RDL/DTL/TTL etc.
Now that we have formulated new packaging in processors. uC, PLCC, FOGA, GAL etc.  The old terms are being confused and readopted, to the point of being inaccurate. 

I believe the key is use what is required.  Requirements are determined by specifications. 
Serial processing is a poor choice for very low latency applications.  For example it will be some time before we will have DDS serial processors for XSHF. 
Discrete or packaged logic would be a poor choice for serialized tasks.  For example the cost programable fabric or discrete logic cost more than equivalent serialized processors. 
Utilizing analog processing to accept and represent two or three state logic would not be cost effective.  For example powering and controlling 1000 OpAmps cost allot more than 2000 gates no mater what form. 
In the serialized processing environment we commonly use redundancy to provide reliability.  It wouldn't make sense to use another processor for arbitration because it would introduce a single point of failure. 
Discrete logic can have a latency well below 1nS.  An equivalent serialized processor of any type would cost much more.
The list of examples seems endless. These are the choices every designer makes to decide "why all the logic chips".

In the beginning there was few choices but we still used the best option for each purpose.  Now we have more choices because there are much larger overlapping specification boundaries.

[westfw]

LSI is a relative newcomer.

Amen!  This is easy to forget, now that you have $1 microcontrollers that contain all the peripherals and memory that you could ever want, for simple (and not so simple) functions.
But in 1974, sort of the hay-day of 74xx TTL logic, something like a 7400 would cost $0.20 (on the hobbyist market), and the brand new 8080 microprocessor was several hundred dollars (just for the 8080), required a bunch of additional chips AND memory (which came in chips measured in bits (not even kbytes!) AND peripherals (which largely didn't exist; build them out of TTL!) AND multiple power supplies.  And you needed a programmer (the person) as well, and those were hard to find (especially with EE skills too!)

You can jump forward to the first flash or eeprom based microcontrollers (1993); before that you had to commit to having your firmware in ROM (only suitable for large volumes), External EPROM, or (some limited number of) chips with internal UV-eraseable EPROM and windows (expensive - you can still buy these) or One-time programmables (risky!)

Cortex M3, the first ARM-based 32bit microcontroller was 2004.

Dave has been tearing down a lot of older stuff, because it's more interesting.   A modern gadget, with a microcontroller under a blob of plastic, and some connectors, is ... boring!
(also, there are other sites that cater to the "Apple introduced a new iPad; let's take it apart!" crowd.)

[bwat]

LSI is a relative newcomer.

Amen!

It's not. We've had commercially available computers since, what, 1951 (the UNIVAC I was delivered in June 1951) which was 63 years ago. LSI came in the mid 1970s which was 40 years ago. That means it's not a newcomer relatively speaking. Relatively new would be the late 1990s.

[22swg]

As an old timer who was weaned on TTL , CMOS and MSI, ( favorite was 8255 ) now hitting the dizzy heights of 16 bit mcu I still find use for an odd  logic ic  for example using a  74HTC04  to level shift I/O from 3.3v to 5v.

[wigman27]

WOW!! 

I never expected such an awesome response from everyone! THANK YOU!

I have a lot of thinking to do about this and certainly look into a few projects that I can do and include some logic, even completely logic chip based. 

I would love nothing more than to spend some time "Work Experience" learning professional circuit design and learning how things are implemented.

I will have to keep my eye out for any opportunities that arise, unfortunately I don't think I could make a career move ass all of my studies are based around power but I would love to have the opportunity one day!

Thanks again everyone!

Lee

[westfw]

the mid 1970s which was 40 years ago.

Oh crap!  That must mean I've gotten old!

Perhaps we should have said "VLSI is relatively recent."

Your Univac 1 had 5200 vacuum tubes ("valves.")  THAT doesn't have anything to do with LSI.

"Computers" up through the mid 1980s tended to be based on relatively not very dense chips (2901 bitslices were very popular toward the end, there.   Four bits of ALU per 40-pin DIP, and still much more powerful than most of the LSI-based microprocessor systems.)

I'll stand by "flash program memory" being a significant event in the replacement of logic by microcontrollers, and that was the mid to late 1990s.

[coppice]

LSI is a relative newcomer.

You can jump forward to the first flash or eeprom based microcontrollers (1993); before that you had to commit to having your firmware in ROM (only suitable for large volumes), External EPROM, or (some limited number of) chips with internal UV-eraseable EPROM and windows (expensive - you can still buy these) or One-time programmables (risky!)

Cortex M3, the first ARM-based 32bit microcontroller was 2004.

There are some errors there. In the late 80s/early 90s you could get EPROM microcontrollers which were practical for small scale production, but you needed to use the one time programmable (windowless) version to get any kind of reasonable price. Serious volume demanded masked parts, to get the cost down, and most EPROM microcontrollers had a masked counterpart.

Flash microcontrollers started at the end of the 90s. Devices like the MSP430 started to establish a regime where development, small scale production, and large scale production could all be based on the same part. It was only in the mid 2000s that the big clunky emulators finally disappeared, and everyone was on board with flash parts, on board emulators and simple JTAG based debug tools.

The first successful M3 microcontrollers were the STM32s, which I think came out in 2007. Well before that many people made ARM7 based MCUs, although most were notorious for being piles of junk thrown together from peripherals designs found in someone's waste bin, and never debugged. ARM7 was the biggest thing in controller cores, but not from sales of MCUs. It was from them being embedded in application specific devices, such as GSM chip sets, hard disk chip sets, and so on.

[bwat]

Your Univac 1 had 5200 vacuum tubes ("valves.")  THAT doesn't have anything to do with LSI.

The UNIVAC I was chosen as the oldest commercial computer and at 63 years ago defines the start of the period, i.e. as old as old gets. It was the my main premise for  LSI, at 40 years old, not being "relatively new".

2901 bitslices were very popular toward the end, there.   Four bits of ALU per 40-pin DIP, and still much more powerful than most of the LSI-based microprocessor systems.

For some reason those were completely off my radar as a young nerd. It's only lately that I've realised that some of the CPUs which I regard as interesting were built with 2900 chips.