Ik ben vereerd door de vraag om een artikel te schrijven voor, zoals gezegd is, het laatste nummer van Atom Nieuws. Ongetwijfeld is er een beetje weemoed als de groep mensen die nog een werkende Atom machine hebben steeds kleiner wordt omdat de IC-voetjes en de keyboard kontakten corroderen en andere onderdelen die het begeven. Of misschien dumpen de eigenaars hun machines omdat ze er geen toepassing meer voor hebben die niet beter met een ander type computer kan worden gedaan. Hoe dan ook de Atom stelde gewone mensen in staat te kunnen genieten van het samenstellen van hun eigen machine uit losse onderdelen. Dat is iets dat met de moderne Pc’s niet meer kan. Hobbyisten zetten dit idee nu voort met "homebrewed" (zelfgemaakte) computersystemen; zoals u op veel websites kunt zien. Een nadeel is dat dergelijke systemen slecht van documentatie en software zijn voorzien. Ze zijn vaak op een experimenteerboard in elkaar geflanst zonder kast met weinig meer dan een monitor, een seriële poort en een 2x16 karakter LCD schermpje. Iets anders vraagt meer tijd en inzet dan de gemiddelde hobbyist ter beschikking staat.

Tot voor kort was ik ook niet voldoende gemotiveerd. Maar toen ik bezig was om een nieuwe baan te zoeken had ik, nadat ik een aantal jaren in de software werkzaam was geweest, een project nodig om mijn vaardigheden met het ontwerpen van elektronica schakelingen te verbeteren. Een blik op de personeelsadvertenties leerde me dat voor de meeste banen in de elektronica vaardigheden worden verlangd in het ontwerpen van programmeerbare logische schakelingen. Dat is dus de ervaring die ik nodig heb. Omdat "geen ervaring = geen baan" betekent en visa versa, was de enige uitweg uit dit dilemma (een catch-22 situatie) zelf een eerste project beginnen. Ik kocht een boek over de beginselen van VHDL en een FPGA (field programmable gate array) board om prototypen te ontwerpen. Niet goedkoop, maar ik ben niet iemand die wacht tot een ander aanbiedt me iets te leren.

Ik besloot een klein computertje te bouwen. Ik wilde ook niet veel tijd besteden aan het ontwerp en debuggen van software. Daarom koos ik voor het klonen van een bestaand ontwerp. Niet chip voor chip maar het geheel implementeren in de nieuwe technologie van de programmeerbare gate arrays. Eerst heb ik de aan de ZX81 gedacht, omdat die in TTL chips was uitgevoerd en zodoende geschikt was om na te maken. Dat model is echter al in diverse programmeerbare logische circuits geïmplementeerd.

Daarna heb ik de Atom in overweging genomen. Dit is natuurlijk een machine die tot meer in staat is en uit nog steeds verkrijgbare onderdelen is opgebouwd. De samenbindende logica en het geheugen zijn gemakkelijk te kopiëren. Het belangrijkste deel is de 6847 videocontroller chip. Onverschrokken begon ik aan het project. Eerst door tellers te maken voor de videoframe controle signalen, dan video adres sequencers vervolgens dummy video RAM en karakter generators en zo voort in opklimmende graad van ingewikkeldheid. Uiteindelijk had ik een werkende 6847 kloon en verving de dummy video RAM door echte RAM (512K!).

Ook liet ik de echte 6847 zich te buiten gaan door hem kleur te laten afgeven in RGB aan drie 8-bit DAC's, waarvan de analoge signalen verder gaan naar de RGB input van een SCART-aansluiting van een TV. Dit levert een mooi plaatje op ontdaan van modulatie beperkingen. Er is ook S-video als tweede goede optie beschikbaar voor TV's zonder SCART aansluiting zoals bijvoorbeeld de meeste Amerikaanse toestellen. Overigens is het goed om op te merken dat dit project zowel de PAL als NTSC standaard ondersteunt.

De digitale RGB output is eventueel ook in staat om een kleuren LCD paneeltje direct aan te sturen. Omdat ik direct kon beschikken over de 6847 logica bouwde ik ook de mogelijkheid in om zowel de 50 Hz als 60 Hz field rates en de 40 kolommen bij 20 regels modes te kunnen produceren. Zodoende kon ik de 320 x 240 pixel mode gebruiken. Tussen twee haakjes ik heb nog geen LCD scherm getest.

Het werd tijd de 6502 toe te voegen. Ik koos ervoor af te wijken van het originele ontwerp en liet hem op 1,77 MHz draaien. Om zodoende "sneeuwvrij" het RAM geheugen te kunnen delen. Het kon de code lezen van de FPGA, maakte het scherm schoon en zette de bekende start boodschap ACORN ATOM gevolgd door de prompt > op het scherm. Hoera!!

Op dit punt aangekomen kan ik tevreden vaststellen dat het werkte zoals het bedoeld is. Er is slechts keyboardinput nodig is om het tot een systeem te completeren waarop een Basic programma kan worden ingevoerd. Het is verleidelijk de originele Atom key-matrix te implementeren. Maar om 59 key-schakelaars te kopen en te bedraden is niet handig en duur. De goedkoopste oplossing is gebruik te maken van een standaard keyboard. Omdat deze een PS2 interface hebben is wat vernuft nodig om ze te verleiden samen te werken met de "virtuele matrix" in de FPGA.

Ik had graag een volledig gereed project willen presenteren maar dit is niet mogelijk voor dit allerlaatste nummer van AN verschijnt. Ik moet daarom volstaan met de mededeling dat er nog veel werk moet worden gedaan voordat ik kan zeggen - hier is een op zich zelf staande kopie van een Acorn Atom -. Ik ben nu bezig met het PS2 keyboard en daarna moet ik de firmware kopiëren in de externe 256 K flash ROM chip.

De FPGA die ik gebruik is een Xilinx op RAM gebaseerde chip die door mijn PC moet worden geconfigureerd of door een relatief dure seriële ROM. Het liefst zou ik het zonder één van hen doen. Een manier is om over een niet vluchtig logisch onderdeel te gebruiken met voldoende logica om de 6502 in staat te stellen een grote hoeveelheid Flash ROM (165K voor de XC2S200 chip die ik gebruik) te kunnen lezen en te laden in de FPGA. Een andere mogelijkheid is de VHDL logica te compileren en in te voeren in een niet-vluchtige chip zoals die door Altera worden gemaakt.

Het prototype bestaat uit een 100x113 mm groot FPGA board dat op een experimenteer bordje van 200x100 mm is geprikt. Beide passen in een gietaluminium doosje dat ongeveer 50 mm hoog is. Hoewel de FPGA zelf groot genoeg is om in een luciferdoosje te passen zal een productie gereed exemplaar zo groot zijn als een grote keuken luciferdoos.

Het is een mooi om over een ontwerp te beschikken dat in een hardware omschrijvende taal is geschreven en dat in een reeks programmeerbare onderdelen kan worden ingevoerd. Als de voorraden 6847 op zijn dan is tot daar aan toe; maar men kan nu een effectieve vervanging produceren. Als FPGA zich verder ontwikkelen kan het ontwerp leiden tot nieuwe chips. Zelfs de 6502 kan in een FPGA worden onder gebracht hoewel die nu nog volop te koop zijn.

Je zou je een grote verandering kunnen voorstellen door bijvoorbeeld een kopie te downloaden van één van de mansgrote arcade machines ( zie www.fpgaarcade.com !). Eenvoudigweg laden en er mee spelen zonder een stukje extra hardware!

Het ontwerp aanpassen is mogelijk zonder altijd de bedrading te veranderen of nieuwe PC’s te ontwerpen. Ik zal er denk ik nog een printerpoort en een paar seriële poorten aan toevoegen om zo aan de basis I/O van de PC aan te passen. Zijn er lieden die de SLIP en PLIP willen implementeren?

Je zou je goed kunnen afvragen of zo'n ontwerp vandaag de dag nog zin heeft. Welnu het voorziet in een praktische basis voor toegepaste systemen en wel één die over eenvoudige TTL signalen beschikt. Vergelijk dat met het gebruikelijke doel van een PC, waarmee je over meer complexiteit beschikt en meer energie consumeert dan je echt nodig hebt en video output hebt naar een monitor die op dat moment niet beschikbaar is in je huis. Je zou bijvoorbeeld één systeem willen hebben dat de beveiliging van je huis beheert, je inbraakalarm, de deurbel, de telefoon aanneemt en je afspraken regelt enz. en je informeert over TV-programma’s. In plaats van dat kleine LCD schermpje op je mobieltje kan je op je TV je berichten zien, wie heeft aangebeld en of iemand een mailtje heeft gestuurd. Je zou op deze manier die lawaaierige PC kunnen vermijden.

Het ontwerpen van dit " systeem op een chip " zou een goede oefening kunnen zijn voor professionele projecten. Op veel manieren is de programmeerbare logica nu op een niveau waarop de microprocessoren waren toen die beschikbaar kwamen met een bruikbare software/prijs verhouding. En hardware oplossingen zijn potentieel zeer veel sneller dan software oplossingen, zelfs bij de huidige GHz PC standaards. Bijvoorbeeld: je hebt nu een respectabele PC nodig om een populaire 8-bits machine uit de jaren 80 te emuleren en de complexere exemplaren veroorzaken nog steeds crashes in de topmodellen op de computermarkt. Met FPGA kunnen zulke machines op de oorspronkelijke kloksnelheid worden geëmuleerd.

Ik heb het project onderwerp onafhankelijk ontworpen. Dezelfde hardware kan worden gebruikt om kopieën van andere systemen te implementeren. Op deze manier kan één model PCB meerdere systemen verzorgen (emuleren). Op deze manier worden de kosten voor lay-out en ontwerp gespreid.

Ik heb het idee dat het overzetten van ontwerpen naar hardware beschrijvende talen de " digitale DNA " ervan bewaart voor de toekomst. Ze kunnen worden bewaard zoals insecten in barnsteen, wachtend op een hobbyist die de code ontrafelt en invoert in een recente programmeerbaar logisch " ei " en op die manier zijn eigen Jurassic Park van digitale dinosauriërs loslaat! Alleen nu in snellere, kleinere en energie zuinigere versies. Niemand hoeft echter te vrezen voor rondrazende PDP-11's die almaar tekeer gaan.

U kunt de vorderingen van dit project volgen op:
"http://www.howell1964.freeserve.co.uk/logic/acorn_atom_project.htm"

Uw, zonderlinge wetenschapper, zoals dr Sickbock sprak *),

Keith Howell.

PS. Ik wil van de gelegenheid gebruik maken om vrijmoedig mijn beschikbaarheid als elektronica ingenieur te promoten. Interfacing van computers door middel van digitale en analoge input/output is mijn sterke kant en ben nu in het bezit van VHDL vaardigheid.

I'm honoured to have been asked to write an article for what I'm told is the last issue of Atom Nieuws. No doubt there is a little sadness as the population of working machines declines due to aging sockets, keyboard contacts and faulty components. Or maybe they get discarded as owners can't see any application other machines cannot do better. However, they did succeed in allowing ordinary people the satisfaction of assembling their own computer from components. That is something you can no longer do with modern PCs. Today's hobbyists often pursue "home-brewed" computer systems, as can be seen from many web sites. One problem is that such machines have little in the way of documentation or software. They are often cobbled together on stripboard without cases, usually with little more than a monitor, serial port and 2x16 character LCD. Anything more involves more time and effort than available to the hobbyist.

Until recently, I did not have enough motivation either, but since I have been looking for a new job I decided I needed a project to prove my electronic design skills were still able after several years of software work. A glance at the jobs pages showed that most digital electronics jobs require the ability to design with programmable logic. This was experience I needed. Since no experience = no job and vice versa, the only way out of this catch-22 was to commission my own first project. I bought an introduction to VHDL book and an FPGA prototyping board. Not cheap, but I'm not one to wait for someone else to offer training.

I decided to build a small computer. I didn't want to spend ages developing and debugging software for it so I chose to clone an existing design. Not chip for chip, but implementing it in the new technology of programmable gate arrays. At first I considered the ZX81, as the circuit has been implemented in TTL chips and thus was visible for copying. However, this has already been implemented in various programmable logic technologies.

Next I considered the Atom. This is of course a much more capable machine, and still largely made from off-the-shelf parts. The glue logic and memory are trivial to copy. The main section of the Atom is the 6847 video controller chip. Undeterred, I started the project. Firstly making counters for video frame control signals, then video address sequencers, then dummy video RAM, character generators, and so on in rising order of complexity. Eventually I had a largely working 6847 clone, and replaced the dummy video RAM with a real RAM (512K!).

I also exceeded the original 6847 by outputting colour as RGB to three 8-bit DACs, whose analogue signals go on to drive the RGB inputs of a SCART-socketed TV. This allows the best image, devoid of modulation limits. There is also s-video output as a second-best option, for non-SCART TVs - i.e. most American ones. Which reminds me to mention that this project supports both PAL and NTSC standards!

The digital RGB output should eventually allow it to drive a colour LCD panel directly. For example, a quarter-VGA panel of 320x240 pixels. Since I had direct access to the 6847 logic, I added extra features such as 50/60 Hz field rates, 40-column and 20-line video modes. The latter allow it to use the full 320x240 pixels. Note that I do not have it driving an LCD yet!

The time came to add the 6502 CPU. I chose to diverge from the original and run this at 1.77 MHz to allow 'snow-free' sharing of RAM. It ran code read from the FPGA, cleared the screen and displayed the well-know sign-on message "ACORN ATOM" followed by the prompt. Hooray!

At this point I can be confident it is working as intended, and only needs keyboard input to transform it into a system that can have BASIC programs typed in. It is trivial to implement the original Atom key matrix interface, but it is inconvenient to wire these up and to pay for 59 keyswitches. The cheapest solution is to use the mass-produced PC keyboards. Since these have a PS2 interface, some ingenuity is required to interface this with a 'virtual key matrix' inside the FPGA.

I would like to report a fully finished project but this may not happen before this issue of AN. Thus I have to state that there is still some work to do before I can say "here is a stand-alone copy of an Acorn Atom". I am working on the PS2 keyboard, and after that I will need to copy the firmware to the external 256K Flash ROM chip.

The FPGA I use is a Xilinx RAM-based chip that requires configuration by my PC or a relatively expensive serial ROM. Ideally I would like the system to do without either. One way is to have a small non-volatile logic device with enough logic to allow the 6502 to read a large amount of Flash ROM (165K for the XC2S200 I am using) and load the FPGA. Another way is to compile the VHDL logic for fitting into a non-volatile FPGA chip such as those made by Altera.

The prototype consists of a 100 x 113 mm FPGA board plugged into a 220 x 100 mm prototyping board, and both slot neatly into an extruded aluminium case about 50 mm high. Although the FPGA itself could fit into a matchbox, a production engineered system might just about fit into the size of matchbox used in the kitchen.

A beauty of having a design coded in a hardware description language is that it can be compiled and ported to a range of programmable devices. When supplies of the 6847 run out then that's it, but one can now produce an effective replacement. As FPGA devices evolve , the design can migrate onto new chips. Even the 6502 itself can reside in the FPGA though for now they are readily available.

You might fancy a complete change, for example to download a copy of those coffin-sized arcarde machines (see www.fpgaarcade.com!). Simply load and go, without any new hardware!

Modifying the design is possible without always having to re-wire or redesign PCBs. I would eventually like to add a printer port and a pair of serial ports, to match the basic I/O of the PC. Any coders out there want to implement SLIP or PLIP?

You may well ask if such a design is of any use these days. Well, it does provide a practical foundation for embedded systems, and one that has simple TTL signals. Compare that with the usual target of an embedded PC where you may have more complexity and power consumption than you really need, and video output to a monitor you may not have around the house. You might for instance want a home control system that can keep an eye on burgalar alarms, doorbells, phones, diary appointments, etc and inform you as you watch TV. Instead of a tiny LCD on your phone, you might come home from work, switch on your TV and see a screen telling you of your phone calls, who called at the door at what time, and if anyone you know e-mailed you. Thus you could avoid having your noisy PC on all the time.

Designing this system-on-a-chip may be good practice for professional projects. In many ways, programmable logic is at the stage where microprocessors where when they began to provide a practial software power/price ratio. And hardware solutions have the potential to be magnitudes faster than software even by GHz PC standards. For example, it takes a respectable PC to emulate the popular 8-bit machines of the 1980's and the more complex ones can still cause a leading-edge PC to crash. With FPGA, such machines can be emulated at the original clock speeds.

I designed the project to be target-independent. The same hardware could be used for implementing copies of other systems. Thus a custom PCB could serve several systems, spreading the PCB layout and manufacturing costs.

I feel that porting designs to hardware description languages preserves their "digital DNA" for posterity. They can be held like flies in amber, waiting for a hobbyist to splice the code into the latest programmablle logic "egg", and unleash their own Jurassic Park of digital dinosaurs! Only this time in smaller, faster, power-frugal versions. Nobody need worry about full-size PDP-11's rampaging around ever again.

You can follow the progress of this project at
http://www.howell1964.freeserve.co.uk/logic/acorn_atom_project.htm

Yours in true mad scientist fashion,

Keith.

PS. I'd like to take this opportunity to blatantly plug my own availability for hire as an electronic engineer. Real-world interfacing a forte, and now with new added VHDL skills!