De KIM Uno - een Microprocessor Dev Kit-emulator van € 5,- - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:17

De KIM Uno is een draagbare, softwaregedefinieerde dev-kit voor (retro) microprocessors. Maar laat me het idee ervan introduceren door terug in de tijd te gaan:

Eind 2018 bedacht ik dat ik een kleine draagbare microprocessor-ontwikkelkit wilde bouwen, net als de beroemde KIM-1 van MOS Technology, Inc. en ontworpen door Chuck Peddle, die ook betrokken was bij het maken van de 6502 CPU.

Maar het bouwen van een "kale" dev-kit met discrete logische componenten was geen optie omdat het een grote stroomvoorziening nodig had (aangezien die oude apparaten de neiging hebben om serieuze stroom te gebruiken) en ook de ontwikkeling zou erg tijdrovend zijn. En ik wil het nu!

Daarom heb ik de KIM Uno ontworpen als een draagbaar apparaat, dat in één hand past en wordt gevoed door twee CR2032-batterijen. Het gebruikt de ATMega328p ("Arduino") microcontroller die draait op 8 MHz om een gewenste CPU te emuleren (of te simuleren). Deze architectuur zorgt er ook voor dat de geëmuleerde CPU's uitwisselbaar zijn met alles wat in het flashgeheugen van de microcontroller past. Het is dus een multifunctioneel apparaat.

Toevallig zag ik later een heel goed gesprek - genaamd The Ultimate Apollo Guidance Computer Talk (34C3) - op YouTube waar "One Instruction Set Computers" of OISC's worden genoemd. Ik kende ze niet en vond dit de perfecte kandidaat om het te implementeren.

De KIM Uno emuleert een CPU met slechts één instructie: subleq - aftrekken en vertakken indien kleiner dan of gelijk aan nul.

Als je deze Instructable met mij volgt, kun je in een mum van tijd je eigen KIM Uno bouwen. En het beste deel - naast het feit dat je het naar je eigen smaak kunt aanpassen - is dat het slechts 4, 75 € kost om te maken (vanaf eind 2018).

Een hint: er is een Git-repository die alle bestanden bevat die door de verschillende stappen van deze instructable worden geleverd. Als u enkele bronnen wilt wijzigen en ze met ons wilt delen, kunt u een PR maken. Maar je kunt daar ook alle bestanden in één keer downloaden. Gewoon naar https://github.com/maxstrauch/kim-uno. Bedankt!

Er is nog een behoorlijk interessant project, hetzelfde genoemd (KIM Uno), dat een echte replica van de 6502 KIM Uno maakt. Bekijk het hier. De maker verkoopt zelfs de kit. Dus als je geïnteresseerd bent in 6502 en dit project leuk vindt, moet je daar een kijkje nemen!

Stap 1: Bronnen van de PCB

Zoals je ziet heb ik van de gelegenheid gebruik gemaakt om een printje te ontwerpen en professioneel te laten maken. Aangezien het extern produceren en naar u verzenden veel tijd in beslag zal nemen (afhankelijk van waar u zich in de wereld bevindt;-)), is het bestellen van het de eerste stap de eerste stap. We kunnen dan doorgaan met de andere stappen terwijl de printplaat wordt gemaakt en naar u wordt verzonden.

Ik bestelde mijn PCB's in China bij PCBWay voor slechts $ 5. Ik krijg geen enkel voordeel voor het presenteren van PCBWay als mijn goto-fabrikant voor PCB's, het is gewoon dat het prima werkte voor mij en misschien ook goed werkt voor jou. Maar u kunt ze op elke andere plaats bestellen, zoals JLCPCB, OSH Park of een lokaal PCB-bedrijf.

Maar als u ze bij PCBWay wilt bestellen, kunt u het bijgevoegde ZIP-bestand " kim-uno-rev1_2018-12-12_gerbers.zip" downloaden en direct uploaden naar PCBWay zonder enige wijziging. Dit is het originele bestand dat ik heb gebruikt om de PCB's te bestellen die je in de afbeeldingen kunt zien.

Als u ze bij een andere fabrikant bestelt, moet u ze mogelijk opnieuw exporteren vanuit de originele KiCad-bronnen, omdat ik ze heb gegenereerd met de specificaties van PCBWay die u hier kunt vinden. Download voor de originele KiCad-bronnen " kim-uno-kicad-sources.zip" en pak het uit.

Maar er is zelfs een tweede manier: als je de PCB niet wilt bestellen, kun je je eigen versie bouwen met perfboard of zelfs een breadboard.

Hoe dan ook: aangezien de PCB's nu onderweg zijn, kunnen we ons concentreren op de andere onderdelen! Kom Volg me.

Stap 2: De componenten sourcen

Nu moet je de componenten krijgen. Hiervoor vindt u een overzichtsafbeelding van alle componenten en hoeveelheden die u nodig heeft, bij deze stap gevoegd en een BOM (stuklijst).

De stuklijst bevat links naar eBay. Hoewel die aanbiedingen mogelijk gesloten zijn wanneer u dit leest, kunt u het als startpunt gebruiken. De gebruikte componenten zijn vrij standaard.

Hieronder leg ik je alle benodigde componenten uit:

• 7x 1 kΩ weerstanden voor de zeven segment displays. U kunt de waarde verlagen (bijv. tot 470) om ze helderder te laten schijnen, maar niet te veel verlagen, anders gaan de LED's dood of is de batterij erg snel leeg. Ik ontdekte dat deze waarde voor mij werkt
• 1x 10 kΩ als pull-up weerstand voor de RESET lijn van de microcontroller
• 1x 100nF-condensator om eventuele spanningspieken weg te werken (wat niet zou moeten gebeuren omdat we batterijen gebruiken, toch, maar voor de goede orde …)
• 1x ATMega328P in het DIP-28-pakket (meestal ATMega328P-PU genoemd)
• 1x de hoofdprint - zie de vorige stap; ofwel besteld of zelf gebouwd
• 2x CR2032 batterijhouders
• 1x SPDT (enkelpolige, dubbele worp) schakelaar die in principe drie contacten heeft en in elk van zijn twee toestanden (aan of uit) verbindt hij twee contacten
• 20x tactiele drukknoppen voor het toetsenbord. Om de achterkant van de print te gebruiken heb ik SMD tactiele drukknoppen gebruikt (de standaard 6x6x6 mm exemplaren) - ze zijn vrij eenvoudig te solderen zoals je zult zien
• OPTIONEEL: 1x 1x6 pin header voor het aansluiten van de programmer, maar dit is optioneel zoals je later zult zien
• 1x zevensegmentendisplay met 4 cijfers en 1x zevensegmentendisplay met 2 cijfers - het bord heeft slechts 0,36 inch (9, 14 mm) elementen met gemeenschappelijke anodebedrading. Beide vereisten zijn belangrijk om een werkende eenheid te krijgen. Maar ook dit type display met zeven segmenten is heel gebruikelijk

Als bijlage bij deze stap vindt u het bestand "component-datasheets.zip" dat nauwkeurigere informatie bevat over afmetingen en typen van de gebruikte componenten. Maar de meeste componenten zijn erg standaard en kunnen gemakkelijk voor weinig geld worden gekocht.

Nu moet je wachten tot je alle componenten klaar hebt om verder te solderen. Gedurende deze tijd kun je al naar het einde springen en een beetje lezen over het gebruik van de KIM Uno als je wilt.

Stap 3: Overzicht soldeergereedschap

Voor het solderen en bouwen van de KIM Uno heb je het gereedschap nodig dat op de afbeeldingen wordt getoond:

• Draadknipper (om het uiteinde van de componentdraden door te knippen)
• Platte tang
• Pincet
• (fatsoenlijk) Soldeer dat niet te dik is - ik gebruik 0,56 mm soldeer
• Een soldeerbout - je hebt geen high-end soldeerbout nodig (omdat we hier ook geen raketwetenschap doen) - ik gebruik de Ersa FineTip 260 al heel lang en het is echt goed
• Een fluxpen: het toevoegen van flux aan de componenten en pads maakt het zoveel gemakkelijker om ze te solderen, omdat het soldeer dan vanzelf naar de juiste plaats "vloeit" *
• Optioneel: een spons (van metaalwol) voor je soldeerbout

Om de KIM Uno later te programmeren, heb je ook nodig:

• een computer met de AVR-GCC-toolchain en avrdude om de firmware te uploaden
• een ISP (programmeur) - zoals je op de afbeelding kunt zien, gebruik ik mijn Arduino Uno als een ISP met een speciale schets - dus het is niet nodig om dure hardware te kopen

* enige begeleiding door mensen nodig;-)

Ben je klaar? In de volgende stap gaan we beginnen met het monteren van de KIM Uno.

Stap 4: Solderen #1: Weerstanden en condensatoren toevoegen

Werk altijd van de kleinste (qua componenthoogte) componenten eerst, naar de hoogste componenten als laatste. Daarom beginnen we met het toevoegen van de weerstanden en buigen over de pootjes aan de achterkant zodat de weerstanden makkelijk te solderen zijn en op hun plaats blijven. Knip daarna de lange draden door.

Voeg ook, niet weergegeven in de afbeeldingen, de kleine 100 nF-condensator op dezelfde manier toe.

Een tip: bewaar die draadpootjes in een bakje, ze komen soms van pas.

Stap 5: Solderen #2: Het toetsenbord monteren

De volgende stap is het solderen van de 20 SMD-tactiele schakelaars. Omdat dit werk een beetje lastig is, doen we het nu, wanneer de print plat op de werkbank ligt.

We werken van boven naar beneden (of van links naar rechts als de print is georiënteerd zoals op de foto's) en beginnen met de eerste rij: kies een van de vier pads voor elke schakelaar en bevochtig deze met de fluxpen.

Gebruik vervolgens een pincet om een schakelaar te pakken en plaats deze voorzichtig op de vier pads. Soldeer vervolgens alleen het been van de schakelaar die zich op de pad bevindt die u hebt gekozen en voorbereid met flux. Hiervoor moet je wat soldeer met je strijkijzer "grijpen" voordat je begint. Gebruik deze methode om de hele rij schakelaars te voltooien en slechts één poot te solderen.

De afbeelding met de pijlen laat een vergroting zien hoe het solderen precies is gedaan.

Nadat je de hele rij (slechts één pin) hebt gesoldeerd, kun je kleine aanpassingen maken door de pin weer op te warmen en de schakelaar opnieuw te positioneren. Zorg ervoor dat de schakelaars zo goed mogelijk zijn uitgelijnd.

Als u tevreden bent met de uitlijning, kunt u alle andere pinnen nat maken met de fluxpen en ze vervolgens solderen door deze aan te raken met de soldeerbout en een klein beetje soldeer toe te voegen door deze ook aan te raken. Je zult zien dat het soldeer direct op de pad wordt gezogen.

Na het solderen van een rij of zo zul je merken dat je het onder de knie hebt en het is niet zo moeilijk maar repetitief. Dus doe gewoon de rest en je hebt binnen de kortste keren een afgewerkt toetsenbord.

Stap 6: Solderen # 3: het zevensegmentendisplay, schakelaar en pinkop

Nu kunt u de schakelaar en de pin-header (optioneel) toevoegen door deze met uw vinger vast te houden en een pin te solderen om deze op de printplaat te houden, zodat u de andere pinnen kunt solderen en uiteindelijk de eerste vasthoudpin kunt bijwerken.

Pas op dat u zich niet verbrandt aan de hete soldeerbout. Als u zich hier niet prettig bij voelt, kunt u een klein beetje tape (bijv. schilderstape) gebruiken om het onderdeel vast te houden. Zo heb je beide handen vrij om te bewegen.

De displays met zeven segmenten zijn op dezelfde manier gesoldeerd (zie afbeelding): je steekt hem erin, houdt hem vast met je hand of tape en soldeert twee tegenover elkaar liggende pinnen om hem op zijn plaats te houden, terwijl je de andere pinnen kunt solderen.

Maar wees voorzichtig en zet het zevensegmentendisplay in de goede richting (met de decimale punten naar het toetsenbord gericht). Anders heb je een probleem…

Stap 7: Solderen #4: De microcontroller solderen

Nu je veel hebt geoefend, kun je doorgaan en de microcontroller plaatsen met de inkeping aan de bovenkant (of eerste pin) naar de schakelaar gericht. Met behulp van een platte tang kun je de pootjes van de microcontroller voorzichtig een klein stukje naar binnen buigen, zodat ze overeenkomen met de gaatjes op de print.

Omdat het een strakke pasvorm is, heb je wat gecontroleerde kracht nodig om de microcontroller in te zetten. Het voordeel is dat het er niet uit valt. Dit betekent dat u de tijd kunt nemen en het vanaf de achterkant kunt solderen.

Stap 8: Solderen #5: de batterijhouders toevoegen (laatste stap)

Ten slotte moet je de batterijhouders aan de achterkant toevoegen. Hiervoor gebruik je gewoon de fluxpen en maak je alle vier de pads nat en krijg je wat soldeer op je strijkijzer. Lijn de batterijhouder zorgvuldig uit op beide pads. Aan beide uiteinden van de contacten moet dezelfde hoeveelheid van de printplaat zichtbaar zijn. Raak de printplaat en de poot van de batterijhouder aan met uw strijkijzer. Het soldeer zal onder de pad en eroverheen stromen en het op zijn plaats bevestigen zoals weergegeven in de afbeelding. Als je hier problemen mee hebt, kun je met de pen meer flux toevoegen.

Stap 9: De emulator flashen

In het bijgevoegde zip-archief " kim-uno-firmware.zip" vindt u de broncode voor de emulator samen met een reeds gecompileerde "main.hex" die u direct naar de microcontroller kunt uploaden.

Voordat je het daadwerkelijk kunt gebruiken, moet je de fuse-bits van de microcontroller instellen, zodat deze de interne 8 MHz-klok gebruikt zonder deze in tweeën te delen. U kunt de klus klaren met de volgende opdracht:

avrdude -c stk500v1 -b 9600 -v -v -P /dev/cu.usbmodem1421 -p m328p -U lfuse:w:0xe2:m -U hfuse:w:0xd9:m -U efuse:w:0xff:m

Als je avrdude niet kent: het is een programma om programma's te uploaden naar een microcontroller. Je kunt er hier meer over leren. In principe installeer je het en dan is het klaar voor gebruik. Voor uw setup moet u mogelijk het argument van "-P" wijzigen in een andere seriële poort. Controleer op uw computer welke seriële poort wordt gebruikt (bijvoorbeeld in de Arduino IDE).

Hierna kun je de firmware op de microcontroller flashen met dit commando:

avrdude -c stk500v1 -b 9600 -v -v -P /dev/cu.usbmodem1421 -p m328p -U flash:w:main.hex

Nogmaals: hetzelfde geldt voor "-P" als hierboven.

Aangezien ik geen "professionele" ISP (In-System Programmer) heb, gebruik ik altijd mijn Arduino UNO (zie afbeelding) en de schets die ik heb bijgevoegd ("arduino-isp.ino", van Randall Bohn). Ik weet dat er een nieuwere versie is, maar met deze versie heb ik de afgelopen vijf jaar geen problemen gehad, dus ik bewaar hem. Het werkt gewoon. Met behulp van de opmerking in de header van de schets krijg je de pinout op de Arduino UNO en met behulp van het schema van de KIM Uno (zie bijgevoegd) kun je de pinout van de 1x6 ISP-header op de KIM Uno krijgen. De vierkante pin, in de buurt van het zevensegmentendisplay, is pin 1 (GND). De volgende pinnen zijn (in de juiste volgorde): RESET, MOSI, MISO, SCK, VCC. U kunt VCC aansluiten op 3V3 of op 5V.

Als u de 1x6-pins header niet hebt toegevoegd, kunt u breadboard-draden gebruiken en deze in de verbindingsgaten steken en ze met uw vinger in een hoek plaatsen - net zoals op de afbeelding. Dit maakt voldoende contact om de firmware te flashen en de zekeringen in te stellen. Maar als je van een meer permanente opstelling houdt, moet je zeker de 1x6 pin-headers toevoegen.

Ik heb twee apparaten: een productieversie zonder de pin-headers en een ontwikkelversie met pin-headers die ik aangesloten laat en tijdens de ontwikkeling keer op keer gebruik. Dit is veel comfortabeler.

Stap 10: Klaar

Nu bent u klaar en kunt u beginnen met het schrijven van uw eigen subleq-programma's op papier, deze in elkaar zetten en vervolgens in het geheugen invoeren.

De KIM Uno wordt geleverd met een voorgeprogrammeerde Fibonacci-berekening vanaf geheugenlocatie 0x0a. Het is standaard ingesteld op n = 6, dus zou moeten resulteren in een waarde van 8. Druk op "Go" om de berekening te starten.

Stap 11: PCB-ontwerpanalyse

Na het voltooien van dit project heb ik een aantal punten gevonden die opmerkelijk zijn en die in een nieuwe revisie van het bord moeten worden aangepakt:

• De zeefdruk van de ATMega328p heeft niet de gebruikelijke inkeping waar de eerste pin zich bevindt. De footprint van de DIP-28 heeft niet eens een vierkante pad waar de eerste pin zich bevindt. Dit moet zeker verbeterd worden met een meer gedetailleerde zeefdruk om verwarring te voorkomen
• de ISP-header heeft geen verbindingslabels op de zeefdruk. Dit maakt het moeilijk om te herkennen hoe het te verbinden met de ISP
• de ISP-header kan worden gewijzigd in een 2x6-pins header met een standaard pinlay-out om verwarring te voorkomen

Afgezien van die punten ben ik best blij met hoe het is verlopen en werkte bij de eerste poging.

Stap 12: Hoe SUBLEQ programmeren?

Zoals aan het begin vermeld, emuleert de huidige firmware van de KIM Uno een One Instruction Set Computer (OISC) en biedt de subleq-instructie om berekeningen uit te voeren.

De subleq-instructie staat voor aftrekken en vertakken indien kleiner dan of gelijk aan nul. In pseudo-code ziet dit er als volgt uit:

subleq A B C mem[B] = mem [B] - mem[A]; als (mem[B] <= 0) ga naar C;

Aangezien de KIM Uno een 8-bits machine emuleert, zijn alle argumenten A, B en C 8-bits waarden en kan daarom een totaal hoofdgeheugen van 256 bytes aanspreken. Uiteraard kan dit uitgebreid worden door A, B en C multi-byte waarden te maken. Maar laten we het voorlopig simpel houden.

De KIM Uno heeft ook "randapparatuur": het display en toetsenbord. Het gebruikt een geheugen toegewezen architectuur om die randapparatuur te koppelen, hoewel de geheugenkaart heel eenvoudig is:

• 0x00 = het Z-register (nul) en moet op nul worden gehouden.
• 0x01 - 0x06 = zes bytes die de waarde vertegenwoordigen van elk van de weergavesegmenten (van rechts naar links). Een waarde 0xf - zie de broncode (main.c) voor meer details.
• 0x07, 0x08, 0x09 = drie bytes waarbij elke byte twee displays met zeven segmenten vertegenwoordigt (van rechts naar links). Met deze geheugenlocaties kan eenvoudig een resultaat worden weergegeven zonder het resultaat in twee nibbles te splitsen om het in de geheugenlocaties met één cijfer 0x01 - 0x06 te plaatsen.
• 0x0a+ = Een programma begint bij 0x0a. Momenteel wordt de "Go" -toets uitgevoerd vanaf 0x0a vast.

Met deze informatie kan men nu een programma in assembler schrijven en de instructies in het geheugen invoeren en vervolgens uitvoeren. Omdat er maar één instructie is, worden alleen de argumenten (A, B en C) ingevoerd. Dus na drie geheugenlocaties beginnen de volgende instructieargumenten, enzovoort.

Als bijlage bij deze stap vindt u het bestand "fibonacci.s" en ook een afbeelding van het handgeschreven programma dat een voorbeeldimplementatie van Fibonacci is. Maar wacht even: er worden drie instructies gebruikt - met name ADD, MOV en HLT - die niet ondergeschikt zijn. 'Wat is er aan de hand? Zei je niet dat er maar één instructie is, subleq?' jij bent aan het vragen? Het is heel eenvoudig: met subleq kan men die instructies heel gemakkelijk nabootsen:

MOV a, b - kopieer data op locatie a naar b kan bestaan uit:

1. subleq b, b, 2 (volgende instructie)
2. subleq a, Z, 3 (volgende instructie)
3. subleq Z, b, 4 (volgende instructie)
4. subleq Z, Z, b.v. 5 (volgende instructie)

Met behulp van de aftrekfunctie van subleq, die mem - mem[a] doet en mem overschrijft met het resultaat, wordt de waarde gekopieerd met behulp van het nulregister. En "subleq Z, Z, …" reset eenvoudig het nulregister naar 0, ongeacht de waarde van Z.

ADD a, b - telt de waarden a + b op en slaat de som op in b kan worden samengesteld uit:

1. subleq a, Z, 2 (volgende instructie)
2. subleq Z, b, 3 (volgende instructie)
3. subleq Z, Z, b.v. 4 (volgende instructie)

Deze instructie berekent eenvoudig mem - (- mem[a]) wat mem + mem[a] is door ook de aftrekfunctie te gebruiken.

HLT - stopt de CPU en beëindigt de uitvoering:

Per definitie weet de emulator dat de CPU wil beëindigen als hij naar 0xff springt (of -1 als hij is verschroeid). Dus een simpele

ondergeschikt Z, Z, -1

doet het werk en geeft aan de emulator aan dat het de emulatie moet beëindigen.

Met behulp van deze drie eenvoudige instructies kan het Fibonacci-algoritme worden geïmplementeerd en werkt het prima. Dit komt omdat de OISC alles kan berekenen wat een "echte" computer kan berekenen met alleen de instructie subleq. Maar er zijn natuurlijk veel afwegingen te maken, zoals codelengte en snelheid. Maar desalniettemin is het een geweldige manier om te leren en te experimenteren met low-level softwareprogrammering en computers.

Als bijlage bij deze stap vindt u ook het zip-archief " kim_uno_tools.zip". Het bevat een basis assembler en simulator voor de KIM Uno. Ze zijn geschreven in NodeJS - zorg ervoor dat je het hebt geïnstalleerd.

Programma's samenstellen

Als je kijkt naar "fibonacci/fibonacci.s" zul je zien dat dit de broncode is voor de besproken fibonacci-implementatie. Om het in elkaar te zetten en er een programma van te maken, dat de KIM Uno kan draaien, voer je het volgende commando in (in de root van het uitgepakte "kim_uno_tools.zip" archief):

node assemble.js fibonacci/fibonacci.s

en het zal ofwel een fout afdrukken als u een fout hebt gemaakt of het resulterende programma morst. Om het op te slaan, kunt u de uitvoer kopiëren en opslaan in een bestand of gewoon deze opdracht uitvoeren:

node assemble.js fibonacci/fibonacci.s > jouwbestand.h

De uitvoer is zo geformatteerd dat deze direct als C-headerbestand in de KIM Uno-firmware kan worden opgenomen, maar de simulator kan deze ook gebruiken om te simuleren. Voer eenvoudig in:

node sim.js jouwbestand.h

En u krijgt het simulatieresultaat en de verwachte uitvoer van de KIM Uno op het display te zien.

Dit was een zeer korte introductie tot deze tools; Ik raad je aan om ermee te spelen en te kijken hoe ze werken. Op deze manier krijg je een diepgaande kennis en leer je de werkingsprincipes achter CPU's, instructies, assemblers en emulators;-)

Stap 13: Outlook

Gefeliciteerd

Als je dit leest, heb je waarschijnlijk deze hele instructable doorlopen en je eigen KIM Uno gebouwd. Dit is echt leuk.

Maar de reis eindigt hier niet - er zijn oneindig veel opties om de KIM Uno aan te passen en aan uw behoeften en voorkeuren aan te passen.

De KIM Uno zou bijvoorbeeld kunnen worden uitgerust met een "echte" retro CPU-emulator die de beroemde MOS 6502 of Intel 8085, 8086 of 8088 zou kunnen emuleren. Dan zou het de weg zijn naar mijn aanvankelijke visie, voordat ik over OISC's leerde.

Maar er zijn andere toepassingen mogelijk, aangezien het hardware-ontwerp vrij generiek is. De KIM Uno kan worden gebruikt als …

• … een afstandsbediening b.v. voor CNC's of andere apparaten. Misschien bedraad of uitgerust met een IR-diode of een andere draadloze zender
• … een (hexadecimale) zakrekenmachine. De firmware is zeer eenvoudig aan te passen en het ontwerp van het bord hoeft niet veel veranderd te worden. Misschien kan de zeefdruk worden aangepast met wiskundige bewerkingen en kan de opening tussen de segmenten worden verwijderd. Afgezien hiervan is het al klaar voor deze transformatie

Ik hoop dat je net zoveel plezier hebt gehad bij het volgen en hopelijk bouwen van de KIM Uno als ik had bij het ontwerpen en plannen ervan. En als u het verlengt of wijzigt, laat het me dan weten. Proost!

Tweede plaats in de PCB-wedstrijd