Fullscreen HTML5Med Res (??MB)HTML4

Program that! Techno Talk Max the Magnificent With the introduction of the latest programmable devices, I think we’ve finally reached my WTW (‘what the what’) moment. I’m going back to playing with 8-bit microprocessors. It’s time for younger engineers to take the strain. Good luck! O ver the course of my career, I’ve met many engineers who have experienced problems adapting to new technologies. For example, people who were experts designing circuits using valves (vacuum tubes) but who simply couldn’t wrap their brains around circuits based on transistors. I can understand this because I have the same problem the other way round – that is, I have no problem deciphering or designing a transistor-based circuit, but a tube-based schematic conveys as much information to my brain as would a wall of ancient Egyptian hieroglyphics. What I found harder to comprehend was older engineers who had blackbelts when it came to designing digital logic with transistors, but who found the concept of digital integrated circuits (ICs) – even jellybean logic like 7400-series TTL and 4000-series CMOS – to be beyond their comprehension. I wonder if anything like this will one day happen to me. Will a new technology arise in my lifetime that causes me to say WTW (‘what the what’)? Now that think about it, I have seen the origination and evolution of one such technology – that of programmable logic. I remember the early days with nostalgia (which isn’t what it used to be). The first PLDs When ICs like the 7400-series first appeared on the market in the mid-1960s, they took the world of digital design by storm. The only downside was that any functions they contained were ‘frozen in silicon,’ as it were. What was required was a device that could be purchased off-the-shelf and then configured (programmed) by digital design engineers to implement custom functions as required. Early programmable ICs first appeared in the early 1970s. These were generically referred to as programmable logic devices (PLDs). The first PLDs were programmable read-only memories (PROMs), which can be visualised as a fixed array of AND functions driving a programmable array of OR functions. These were followed in 1975 by programmable logic arrays (PLAs), in which both the AND and OR arrays could be programmed. In turn, 8 the late 1970s saw the introduction of programable array logic (PAL) devices in which the AND array was programmable while the OR array was fixed. PLDs enjoyed a variety of programming technologies. For ‘antifuse’, desired connections could be selectively added (‘grown’). By comparison, for ‘fusible links’, unwanted connections could be removed (‘blown’). In both cases, this was achieved by applying higher-than-usual voltages and currents to the device’s pins. When designing printed circuit boards (PCBs), we used PLDs for all sorts of things, including implementing lookup tables, creating simple finite state machines (FSMs), and gathering a lot of ‘glue logic’ functions into a single device. We also included them in the design to provide a way to fix unforeseen boardlevel problems – it was a lot easier to swap out a socketed PLD than it was to cut tracks and add components and patch wires to the main board. The ‘Dark Ages’ of design tools It’s hard for young engineers to understand how little we used to have in the way of design tools. For PLDs, we captured the desired functionality using pencil and paper, either as truth tables or schematics for logical functions, state diagrams for state machines, or tabular representations for look-up tables. Next, we hand-created a text programming file, which required knowledge of the device manufacturer’s proprietary file format and an intimate understanding of the device’s internal architecture. Then we used this text file in conjunction with a manufacturer-specific programming device to configure the device as required. It wasn’t until the early 1980s that industry standard file formats and programming tools started to appear on the scene. I’m thinking of things like the file format proposed by the Joint Electron Tube Engineering Council (JETEC), as was, along with names like PAL Assembler (PALASM), Advanced Boolean Expression Language (ABEL), Common Universal Tool for Programmable Logic (CUPL), and – my favorite – Automated Map and Zap of Equations (AMAZE). The first FPGAs The company Xilinx was founded in 1984. A year later it introduced the first field-programmable gate array (FPGA). I think of the programmable fabric in FPGAs as little ‘islands’ of configurable logic in a ‘sea’ of configurable interconnect. The first of these devices was the XC2064, which contained an 8x8 = 64 array of configurable logic blocks, each boasting two 3-input lookup tables (LUTs). The configuration was implemented using SRAM cells, which required loading from an external source when the board was powered up. Once again, this predated any FPGA-specific programming tools, so the configuration had to be captured as a text file by hand. ‘Well, these devices will never catch on,’ I remember thinking to myself, thereby proving I’m no clairvoyant (although I’m sure I could play one on TV). And then it was now As well as a bunch of smaller players, there are two FPGA behemoths in the industry – Altera (founded in 1983, purchased by Intel in 2015, and spun off as a wholly-owned Intel subsidiary in early 2024) and Xilinx (which was acquired by AMD in 2022). Over the past 40 years, this duo has evolved FPGAs and their design tools beyond all expectation and – in my case – comprehension. For example, AMD recently announced their Versal AI Edge Series Gen 2 SoC FPGAs for artificial intelligence (AI)-driven embedded systems at ‘the edge’ (ie, where the internet meets the real world). In addition to millions of look-up tables, the programmable fabric includes thousands of digital signal processing (DSP) functions and megabits of Block RAM functions. Also, in addition to a bunch of artificial intelligence (AI) engines, there are eight 64-bit Arm Cortex-A78AE Application Processors and ten 32-bit Arm Cortex-R52 real-time processors, plus external memory and communications interfaces, all implemented on a single monolithic silicon chip. I think we’ve reached my WTW moment. I’m going back to playing with 8-bit microprocessors. It’s time for younger engineers to take the strain. Good luck! Practical Electronics | June | 2024