De volgende generatie programmeerbare logica-ontwerpers

Lang geleden, nog voor het tijdperk van de logische synthese, werd ingenieurs soms gevraagd om een systeem te ontwerpen dat zuiver logisch was. Dit was toen we radar hadden, maar geen microcontrollers, en digitale signaalverwerking, maar geen kant-en-klare digitale signaalprocessors. Toch hadden we digitaal bewerkte radar.

In die tijd werd van net afgestudeerde ingenieurs verwacht dat ze wisten hoe je analoge en digitale hardware ontwerpt en hoe je software ontwikkelt. Ik vrees dat de tijd van de breed opgeleide, eclectische ingenieur voorbij is en ik maak me zorgen over de toekomst van digitale logica. Er is een gezegde dat als een timmerman alleen een hamer heeft, elk probleem eruitziet als een spijker. Hebben we dat punt bereikt waarbij elk probleem eruitziet als een softwareprobleem?

Als je op internet de woorden ‘FPGA toepassingen’ zoekt, krijg je een lijst toepassingen op het gebied van de elektrotechniek. Deze toepassingen variëren van kunstmatige intelligentie en spraakherkenning tot communicatie en beeldverwerking. Het probleem van deze toepassingen is dat ze niet eenvoudig zijn — ze zijn niet voor beginners. Het implementeren van deze toepassingen is lastig en omvat diverse niet-triviale onderwerpen.

Je moet verschillende dingen leren, zoals de programmeerbare logische chips zelf, de geïntegreerde ontwikkelomgevingen (IDE’s, en die verschillen per fabrikant), nieuwe programmeerparadigma’s (d.w.z. hardware beschrijvingstalen of HDL en de mogelijkheid voor gelijktijdigheid en het concept van tijd). En tot slot moet je de toepassing zelf begrijpen. Dit is nagenoeg onmogelijk, behalve voor experts. Helaas voorspelt dit niet veel goeds voor de volgende generatie logica-ontwerpers die nieuwe programmeerbare logische vaardigheden willen leren. De eerste stap is te hoog. Ik denk dat het mensen ervan weerhoudt om dit vakgebied in te gaan, waardoor er in de toekomst uiteindelijk minder programmeerbare logica experts zullen zijn. Er zijn veel verhalen op internet te vinden van mensen die gefrustreerd zijn met de huidige staat van de programmeerbare logica en er zijn verscheidene open source gemeenschappen die dit proberen op te lossen. Veel mensen denken dat metaprogramming de oplossing is. Dit is een programmeertechniek waarin een programma een ander programma als data behandelt.

De programmeerbare logica-bedrijven voelen de nood. Enerzijds willen hun investeerders dat ze steeds betere en duurdere chips ontwikkelen en anderzijds zijn er relatief minder bekwame mensen die deze kunnen gebruiken. Hun oplossing is om softwareontwikkelaars te converteren in hardwareontwerpers en dat doen ze met nieuwe tools.

High level synthesis of HLS-compilers brengen ontwerpabstractie naar een nog hoger niveau en dit brengt ons nog verder van de basiselementen van logica-ontwerp. Het is opmerkelijk dat we geavanceerde hardwareontwerpen kunnen maken op basis van louter softwarebeschrijvingen, maar daarbij ontbreekt de diepgewortelde aantrekkingskracht die logica-ontwerp op mensen kan hebben. Je zult mij niet horen zeggen dat een persoon beter kan optimaliseren dan een computer, maar ik geloof zeker dat het ontwerpen van simpele schakelingen vroeger eenvoudiger was. Het probleem is dat simpele schakelingen tegenwoordig moeilijker te ontwerpen zijn toen.

Ik herinner me nog hoe trots ik was op mijn handgemaakte logica-ontwerp in de vorm van een schakeling. Ik had zelf uitgeknobbeld hoe het aantal benodigde chips kon worden geminimaliseerd. Toen ik in het begin van de jaren 90 programmeerbare logica leerde, was ik blij dat ik mijn kennis over circuitontwerp kon toepassen om mijn logica in één chip van 128 logische elementen te implementeren, en dankzij mijn intelligentie kon ik ik elk van die logische elementen kiezen. Ik was niet afhankelijk van de intelligentie van een of ander onbekende algoritmeontwikkelaar.

En terwijl logica-ontwerp evolueerde, veranderde softwareontwerp ook. Het is grotendeels een wereld van object-georiënteerde programmering (OOP) geworden en bibliotheken met veelgebruikte ontwerppatronen zijn goed gedocumenteerd en vrij verkrijgbaar in codebibliotheken. Mijn ontwerppatronenboek is het eens zo populaire boek Design Patterns, Elements of Reusable Object-Oriented Software,geschreven door Erich Gamma, et. al. Ik vind het interessant dat hardwareontwerp als objectgeoriënteerd begon, maar dat de ontwikkeling met de introductie van de HDL’s is gestopt. Hoewel HDL’s hergebruik van ontwerpen mogelijk maakt, bevatten ontwerpbibliotheken de meest fundamentele functionaliteit. Zoek maar eens ‘Lijst van 7400-serie geïntegreerde circuits’ op internet en je krijgt een aantal oude hardwareontwerppatronen. Wat ik interessant vond, is dat Meilir Page-Jones in zijn boek Fundamentals of Object-Oriented Design in UML naar geïntegreerde circuits verwijst als voorbeeld van een goed objectontwerp met hoge cohesie en lage koppeling. Maar in het streven naar steeds complexere programmeerbare logica-chips vergeten we de basiselementen van een eenvoudig en direct logica-ontwerp. De huidige ontwerpmethoden zijn afhankelijk van een computeralgoritme om onze logica te implementeren. Ik denk dat deze aanpak een barrière vormt voor beginners in programmeerbare logica.

Je zou kunnen vragen, “Hoeveel regels code waren er in het eerste Pong-spel dat we aan de achterkant van onze televisie aansloten?” Het antwoord is nul. Het was puur hardware (zie afbeelding 1) – geen software inbegrepen! Ik geloof niet dat er veel nieuw afgestudeerde ingenieurs zijn die Pong zonder software kunnen ontwerpen. Ze zouden zeggen: “Waarom zou ik?” Waarop mijn antwoord zou zijn: “Voor perspectief en omdat je moet weten dat het kan. Het is eenvoudiger dan je denkt.”

Afbeelding 1: Pong-schema (afbeelding: gevonden op Adafruit-blog, bron onbekend)

IEEE publiceerde begin 2019 een lijst met de meest en minst geliefde programmeertalen. Daaruit bleek dat Python erg in trek is bij ingenieurs. En dat geloofde ik wel. Een paar jaar geleden zat ik namelijk in de jury van een ontwerpwedstrijd van Texas Instruments en daar zag ik dat negen van de tien collegeteams Python voor hun project hadden gebruikt. VHSIC Hardware Description Language (VHDL) en Verilog stonden niet op de lijst van meest of minst geliefde programmeertalen. Misschien hadden de redacteurs bij IEEE niet aan deze HDL’s-programmeertalen gedacht, maar ik denk dat het waarschijnlijker is dat niemand die de was ondervraagd aan HDL’s had gedacht. Als dit waar is, laat dat zien hoe weinig technici bekend zijn met deze talen, of met logica-ontwerp over het algemeen – een slecht voorteken voor logica-ontwerp.

Dus wat kunnen we eraan doen? Hoe veranderen we de mentaliteit van nieuwe ingenieurs om de oplossing van een probleem in software of hardware te overwegen? De meeste problemen kunnen immers op beide manieren worden opgelost. Ik heb een idee.

Ik denk dat dankzij het Arduino-platform een groot aantal jonge mensen geïnteresseerd zijn in software. En die gaan vervolgens informatica of computerkunde studeren. Hoe is dit gebeurd? Arduino maakte het ontwikkelen van software een stuk makkelijker en meer toegankelijk.

Door een board te definiëren, kon je het opzetten van linker command files elimineren, werden signaalnamen standaard en werden compilatiedetails door de IDE verborgen. Een van de voordelen van Python is dat de taal een strikte opmaak vereist. Zo moeten bijvoorbeeld inspringingen uniform zijn. Dit elimineert laagwaardige, willekeurige keuzes met als gevolg dat het hele ontwikkelingsproces eenvoudiger wordt, waardoor ontwikkelaars productiever worden. We hebben het equivalent voor programmeerbare logica nodig en de programmeerbare logica-industrie zou samen aan een standaard moeten werken.

Hier zijn een paar kenmerken die ik voor die standaard bepleit. Aangezien Arduino niet over een inherente en robuuste capaciteit beschikt om de onderliggende architectuur te wijzigen, zoals het mogelijk maken van geneste interrupts, gaan we ervan uit dat de logica-problemen die op dit platform moeten worden opgelost eenvoudig genoeg zijn, zodat de huidige programmeerbare logica-chips aan alle tijdsbeperkingen kunnen voldoen. De Arduino-equivalent printplaat met programmeerbare logica-componenten (PLDB) moet een voldoende langzame klok bevatten, zodat elk ontwerp met 1000 logica-elementen zou moeten werken. Dit betekent dat alleen functionele verificatie door het platform vereist is.

Aangezien iedereen graag in Python werkt, stel ik voor dat de PLDB Python ondersteunt en wordt gebouwd op een framework zoals nMigen of MyHDL (zie afbeelding 2) of zelfs Yosys met zijn RTLIL. Hiermee zouden beginners hun logica-ontwerpen met een geïnterpreteerde taal kunnen simuleren, waarheidstabellen kunnen produceren, en toegang krijgen tot alle andere Python-bibliotheek die voor hen beschikbaar zijn. Over Python-bibliotheek gesproken, de community kan met Python ook de Python package index (PyPi) gebruiken om herbruikbare hardwareblokken te distribueren die helpen bij het aanpakken van het gebrek aan robuuste, gedeelde ontwerppatronen. Net als Python ondersteunt nMigen metaprogramming. Dus hoewel dit framework simpele ontwerpen ondersteunt, is het platform schaalbaar en kan ook complexe ontwerpen ondersteunen.

Afbeelding 2: Op Python gebaseerd framework (Bron afbeelding: MyHDL.org en m-labs.hk)

De interface van een host-pc naar een PLDB moet USB zijn, samen met een PLDB-geïntegreerde microcontroller met een API voor de host-pc om de configuratie van de PLDB te leren, zodat de Python-omgeving automatisch kan worden ingesteld voor de ontwikkeling van programmeerbare logica. Het resultaat van deze opstelling is het verbergen van de synthesedetails, plaats en route en programmering, terwijl functionele simulatie op de pc en uitvoering op de werkelijke hardware mogelijk is.

Voor het geval sommige lezers denken dat er geen simpele logica-problemen meer zijn om op te lossen, laat ik hier Digi-Keys verkoopcijfers van microprocessors zien. Afbeelding 3 toont de verdeling van de verschillende klassen microcontrollers die door klanten gekocht worden en afbeelding 4 laat zien hoeveel eenheden van elke klasse worden verkocht. Al met al heeft DigiKey onderdeelnummers voor meer dan 80.000 microcontrollers en meer dan 19.000 microcontrollers op voorraad, klaar om per omgaande wereldwijd te worden verscheept. De aantallen geven aan dat eenvoudige 8-bits processors door meer ingenieurs worden gebruikt en dat DigiKey meer 8-bits microcontrollers verscheept dan welke andere klasse processor ook. Hieruit leid ik af dat er meer eenvoudige problemen zijn dan complexe problemen.

Afbeelding 3: Aantal DigiKey-klanten die microcontrollers kopen, per type microcontroller (Bron afbeelding: DigiKey)

Afbeelding 4: Aantal verkochte eenheden van elk type microcontroller van DigiKey (Bron afbeelding: DigiKey)

Ons doel zou moeten zijn om iedereen, zelfs mensen zonder een formele opleiding in logica-ontwerp, liefhebbers van programmeerbare logica te maken, maar hiervoor moeten we ontwikkelingsparadigma's veranderen.