Wat me opvalt waneer ik voor of na een gastcollege met studenten praat is dat er zo weinig mensen zijn die een globaal idee hebben hoe die machine nou eigenlijk werkt. Misschien komt het door mijn eigen opleiding, waarbij we vanaf de basis (AND-, OR-, NOT-, NAND- en NOR-poorten, Flip-Flops en meer van dat) alle verschillende lagen langsgingen, en in combinatie met de nodige wiskunde, leerden hoe een computer was opgebouwd. Natuurlijk heeft de techniek niet stilgestaan, en is er in de tussentijd heel veel veranderd, maar toch zal een stukje basiskennis altijd bijdragen tot een beter begip.
Vandaar dat ik jullie hierbij wil wijzen op een heerlijk boekje dat helaas niet meer geprint wordt, maar wel een hele goede introductie geeft, genaamd “Digital Computer Electronics, An Introduction to Microcomputers (2nd Edition)” uit 1982, geschreven door Albert Paul Malvino. Wellicht dat jullie het ook nog ergens op Internet kunnen vinden (het is mij ook gelukt1). Maar wat nog veel leuker is, is dat er, op basis van datzelfde boekje, een werkelijk uitstekende serie door Ben Eater op zijn Youtube-kanaal2 is geplaatst waarin alle belangrijke onderdelen van een 8-bit computer gebouwd worden en je het ook kunt zien werken.
De serie begint met “8-bit computer update” waarin een kort overzicht wordt gegeven en ook de referentie naar het eerder genoemde boek is opgenomen.
Omdat een stabiel kloksignaal erg belangrijk is om alles in een computer netjes te laten verlopen wordt de introductie gevolgd door maar liefst vier afleveringen waarin gestart wordt met een astabiele 555 timer uiteindelijk een stabiele clock circuit wordt gebouwd die alle overige onderdelen van het clock-signaal zal voorzien:
- “Astable 555 timer - 8-bit computer clock - part 1”
- “Monostable 555 timer - 8-bit computer clock - part 2”
- “Bistable 555 - 8-bit computer clock - part 3”
- “Clock logic - 8-bit computer clock - part 4”
Hierna volgen er een aantal video’s over, respectievelijk de “SR Latch”, de “D Latch”, en uiteindelijk de “D Flipflop”, waarmee de meest belangrijke basis bouwstenen zijn geintroduceerd.
Nu de basiscomponenten zijn geintroduceerd gaat Ben verder met de volgende video’s die nader ingaan op de ‘bus’, zeg maar de centrale snelweg die de verschillende onderdelen van een computer met elkaar verbindt.
- “Bus architecture and how register transfers work - 8 bit register - Part 1”
- “Tri-state logic: Connecting multiple outputs together - 8 bit register - Part 2”
- “Designing and building a 1-bit register - 8 bit register - Part 3”
- “Building an 8-bit register - 8-bit register - Part 4”
- “Testing our computer’s registers - 8-bit register - Part 5”
Er zijn in totaal drie registers gebouwd die elk acht bits kunnen bevatten, en aangezien dit een basis-cursus is, wordt in de volgende video uitgelegd hoe getallen binair kunnen worden weergegeven, zowel positieve gehele getallen als negatieve gehele getallen: “Twos complement: Negative numbers in binary”.
De registers kunnen dus gehele getallen bevatten en aangezien een computer, de naam zegt het feitelijk al, een machine is die op een of andere wijze kan rekenen (= compute), zal er dus ergens een onderdeel moeten bestaan dat (eenvoudige) berekeningen moet kunnen uitvoeren op die gehele getallen die opgeslagen kunnen worden. Dat gedeelte van de computer wordt ook wel aangeduid met Artihmetic Logic Unit (ALU), en de volgende vier video’s behandelen de eerste eenvoudige versie van deze ALU:
Door middel van een werkende ALU kan het systeem nu acht bit nummers bij elkaar optellen en van elkaar aftrekken. Maar op dit moment zijn er slechts twee registers gebouwd waarmee dergelijke bewerkingen kunnen plaatsvinden. Een werkelijke computer kan meer getallen opslaan en er bewerkingen op uitvoeren. Die opslag wordt geheugen (Random Access Memory (RAM)) genoemd, en de volgende video’s leggen uit hoe dit aan deze eenvoudige computer wordt toegevoegd:
- “8-bit computer RAM intro”
- “RAM module build - part 1”
- “RAM module build - part 2”
- “RAM module build - part 3”
- “RAM module testing and troubleshooting”
Leuk dat we nu het een en ander kunnen opslaan en wat basis berekeningen kunnen uitvoeren, maar als we het over een computer hebben verwachten we geen basis rekenmachine, maar een soort van programmeerbare rekenmachine die een (simpel) programma kan opslaan en kan uitvoeren. Om dat mogelijk te maken hebben we een manier nodig om een volgende instructie op te halen en uit te voeren, en daarvoor hebben we een zogenaamde instructie teller, of program counter nodig. Dit is feitelijk een binaire teller en kan eenvoudig gebouwd worden met behulp van JK-Flipflops. Dat is de inhoud van de volgende zes video’s:
- “JK flip-flop”
- “JK flip-flop racing”
- “Master-slave JK flip-flop”
- “Binary counter”
- “Program counter design”
- “Program counter build”
Wat is het nut van een computer als je niet (eenvoudig) het resultaat kunt zien? De meest eenvoudige computers die in de jaren 70 van de vorige eeuw beschikbaar kwamen als zelfbouw pakketten hadden of LEDs of 7-segment displays om uitvoer te tonen. Dit laatste is ook de manier waarop deze simpele computer de uitvoer toont. Alleen moet daarvoor wel een binair naar (headecimal) display-digit conversie gemaakt worden. Dit wordt behandeld in “Designing a 7-segment hex decoder’. Zoals blijkt uit deze video wordt de aansturing van een dergelijk 7-segment display nogal complex als dit gebouwd wordt met logische componenten. Door gebruik te maken van een EEPROM kan de betreffende logica een stuk eenvoudiger worden geimplementeerd. Dit is de inhoud van “Using an EEPROM to replace combinational logic”.
Als een relatief klein sub-projectje, aangezien het programmeren van een EEPROM best wel arbeidsintensief is, zeker als er meer dan 16 locaties geprogrammeerd moeten worden. Een van de manieren is het bouwen van een automatische programmer, gebaseerd op een Arduino Nano. Dit is het onderwerp van de video: “Build an Arduino EEPROM programmer”.
Door de onderdelen van de bovenstaande video’s te combineren kan nu de volledige uitvoer display (vier 7-segment displays) gebouwd worden, zoals weergegeven in: “Build an 8-bit decimal display for our 8-bit computer”.
In het bovenstaande is er al eerder gesproken over de bus, en in de volgende video worden de verschillende onderdelen die hierboven gebouwd zijn verbonden met deze bus: “8-bit computer build: Connecting the bus”.
Nadat alle bovenstaande zaken aan de bus gekoppeld zijn missen we eigenlijk alleen nog de “brains” van de computer, de zogenaamde “control logic”. Dit is het onderwerp van de volgende zeven video’s:
- “8-bit CPU control signal overview”
- “8-bit CPU control logic: Part 1”
- “8-bit CPU control logic: Part 2”
- “8-bit CPU control logic: Part 3”
- “8-bit CPU reset circuit and power supply tips”
- “Reprogramming CPU microcode with an Arduino”
- “Adding more machine language instructions to the CPU”
Wat maakt een computer een computer? Daarvoor moet er een meer filosofische vraag worden beantwoordt en daar gaat de video “Making a computer Turing complete” over. Het systeem dat tot dusver gebouwd is mist feitelijk slehts een instructies om het “Turing Complete” te maken, namelijk een conditionele sprong (“Conditional jump”), en dat wordt weergegeven in de volgende drie video’s:
Hiermee wordt de cursus afgesloten. Het resultaat is dus een turing complete 8-bit computer. Het enige dat nu nog openstaat is wie er uiteindelijk voor gaat zorgen dat Doom op dit systeem gaat draaien. Alleen denk ik dat dat net iets te veel gevraagd is…