8-bit computer op een breadboard

Misschien wat uitbreiden aan programmer.py om ook EEPROM te wissen, dat uit te lezen / verifiëren en daarna de microcode weer schrijven + uitlezen.
Zou leuk zijn als het een beetje werkt.
Ben nog niet aan testen toegekomen, morgen misschien.

Wel heb ik bedacht hoe ik de microcode ga opslaan:



Ik gebruik de AT28C64 chip (8K bytes). Ik verdeel die in 4 segmenten van 2K, zodat ik adres bits 12 en 11 kan gebruiken om hardware-matig het segment te selecteren. De opcode die in het Instructie Register wordt geladen dient in bits 10 tot 3 als pointer naar een blok van 8 bytes voor de microcodes voor die instructie. De laatste 3 bits komen uit een counter die gebaseerd is op de inverted CLK. Op basis van die (CLK) wordt de microcode stap aangewezen.

Op deze manier, door de hardwired segment aanduiding, kunnen alle drie de memory chips worden geladen met dezelfde inhoud, en maakt de plaatsing van de chips op het board ook niet meer uit.

@tmdr: als je wilt samenwerken, stuur je me dan een mailtje met je Skype adres? Dan kunnen we morgen even overleggen...

Gerard
Ain't no place like 127.0.0.1
Ik ben zelf nog lang niet zo ver dat we op dit punt kunnen samenwerken, maar hierover discussiëren is altijd leuk. Zelf heb ik geen Skype maar aangezien je een Mac hebt kunnen we ook via FaceTime/iMessage communiceren. Of eventueel regel ik Skype.

Wat betreft je idee, volgens mij is dat in feiten het zelfde als Ben doet. Zou je even zij vids over moeten zoeken. Kan dus prima en maakt de boel een stuk makkelijker!
Morgen middag hoop ik ook weer aan de slag te kunnen. Dan neem ik contact op.
Op 29 september 2017 18:51:51 schreef tmdr:
Ik ben zelf nog lang niet zo ver dat we op dit punt kunnen samenwerken, maar hierover discussiëren is altijd leuk. Zelf heb ik geen Skype maar aangezien je een Mac hebt kunnen we ook via FaceTime/iMessage communiceren. Of eventueel regel ik Skype.

Wat betreft je idee, volgens mij is dat in feiten het zelfde als Ben doet. Zou je even zij vids over moeten zoeken. Kan dus prima en maakt de boel een stuk makkelijker!
Morgen middag hoop ik ook weer aan de slag te kunnen. Dan neem ik contact op.


TOP
Ain't no place like 127.0.0.1
fred101

Golden Member

Te ingewikkeld voor mij als digitaal gehandicapte ;-), tenminste dat dacht ik eerst, totdat ik een video van Ben Eater zag.

Ik ben de hele serie over die 8 bit computer aan het bekijken. Die man is een geniale leraar.

Heel erg interessant en voor het eerst begin ik te snappen hoe een processor hardware matig werkt, waarom tristate belangrijk is, wat een bus is, wat registers, latches etc zijn.
Wat een geheugen feitelijk is en het meest interessante wat ik me al heel lang afvroeg, de overgang van woorden naar signalen, ofwel hoe kun je een processor nu iets in text vertellen als het ding alleen 1 en nul kent. Nooit gedacht dat elke instructie ook echt hardware matig gebouwd wordt. Hoe ze optellen, bit shifts etc

Ik heb altijd al interesse in computers gehad, zelfs in de 80's 5 jaar in de computer-branch gewerkt maar altijd eigenlijk alleen interesse gehad in het hardware deel, niet echt in het programmeren. Te abstract en ondoorzichtig en dat wordt steeds erger. Veel te ver van de hardware af.

Er is erg weinig info over de echte basis mbt hardware te vinden, the art of electronics bevat veel info maar erg taai. Die Ben Eater lukt het echter wel. Ik kan zo 5 videos achter elkaar kijken zonder afgeleid te worden en dan snap ik ook waar hij het over heeft.

Bedankt voor de link en dit topic, voor mij is dit belangrijke info omdat ik er bij reparatie steeds meer mee te maken heb.

Wat een iets minder neven effect is, is dat ik nu eigenlijk ook zo'n ding wil bouwen. Fascinerend hoe je die data dmv die ledjes ziet verplaatsen. Ik heb alleen geen stapel breadboards en ben er ook geen liefhebber van dus zal het wel bij videos kijken blijven. Dat is ook leuk.
www.pa4tim.nl, Reparatie van meet- en calibratie apparatuur, ook oud en exotisch
Op 4 oktober 2017 08:26:02 schreef fred101:
Te ingewikkeld voor mij als digitaal gehandicapte ;-), tenminste dat dacht ik eerst, totdat ik een video van Ben Eater zag.

Ik ben de hele serie over die 8 bit computer aan het bekijken. Die man is een geniale leraar.
...


Leuke, enthousiaste reactie Fred!

Als leraar ICT maak ik dat bij mijn leerlingen ook vaak mee, dat ze aangeven het echt niet te snappen, totdat je op een gegeven moment het "kwartje ziet vallen". Vanaf dat moment worden ze, net als jij nu, enthousiast.

Ik gebruik voor de uitleg de "Von Neumann Architecture", zie deze pagina.

Gerard
Ain't no place like 127.0.0.1
fred101

Golden Member

Weet even niet wat te doen. Het leuke is het geëxperimenteer met de hardware. bv een nummeriek keyboardje erbij maken, dingen aansturen een sensor uitlezen.
Maffe dingen als een ultra primitive voltmeter mbv een ultra primitieve ADC maken en dan de waarde op die 7 segments leds zetten. Dat soort experimenten lijken me leuk. Bouwen om het bouwen. Zoals ik soms meetaparaten bouw omdat het leuk is om te doen, niet omdat ik ze nodig heb.

Niet om enorme instructiesets te bedenken en grote programmas te schrijven.

Maar dan is juist een breadboard wel handig. Misschien een mix. Dingen die waarschijnlijk nooit veranderen solderen. Zoals de clock, counter A en B register, de display ? Volgens mij gebruikt ben per deel een breadboard. Is het een idee de bus op verobaantjes board te zetten en daar headers op solderen waar dan pcbtjes opgeprikt kunnen worden, soms direct en soms via bv bandkabel. Zo kan je een breadboard koppelen voor experimenten maar ook pcbs als iets bevalt. Dat dan op een plank schroeven.

Ik krijg een HP1615A logic analyser, lijkt me leuk om die daarop te kunnen aansluiten, en dat kan ook met headers. Past wel in het tijdsbeeld van deze experimenten.

Als ik Ben zijn computer nabouw op pcb's welke delen kan ik dan vast en bij elkaar op 1 board zetten zodat ik kan uitbreiden zonder overzicht te verliezen

Over dat laatste, hoe sla je een programmas op ?
www.pa4tim.nl, Reparatie van meet- en calibratie apparatuur, ook oud en exotisch
Zie voor (mijn) antwoorden de posts op mijn website. Stuk voor stuk beschrijf ik daar de transities van breadboards naar PCB's.

Klik hier voor alle posts over mijn "8 bit computer".

Gerard
Ain't no place like 127.0.0.1
Heb net toch een tijdje die playlist zitten te kijken en die man is inderdaad echt briljant. Dank voor het delen, zeker van meerwaarde! 't Is gek, al deze dingen wist ik eigenlijk al1, maar de man heeft zo een goede flow in zijn verhaal dat het toch weer interessant is. Echt verbazingwekkend hoe goed hij prioriteiten stelt in zijn uitleg.

Best ook een goede refresh, ik was namelijk een tijdje geleden begonnen met het proberen te ontcijferen hoe moderne kleine microcontrollers werken, en zat me door de werking van moderne kleine microcontrollertjes (PIC12F675/ATTiny85) te worstelen2, en dan is zo een gestructureerd verhaal over de basis super handig. Dan merk je pas hoeveel details er in het blokschema niet staan vermeld.

1Als in: al eerder gehoord en aan gewerkt, maar 'nowhere near' in staat om het geordend uit mijn mouw te schudden.

2Die rustig een paar ordegroottes complexer zijn dan de breadboardprocessor.
Okay guys,

Ik werk aan een programma om de EEPROMs te programmeren.

De code staat op GitHub, je kunt het hier vinden.

Denk mee, doe suggesties / er je voordeel mee...

Gerard
Ain't no place like 127.0.0.1
Hallo, is er iemand in Amsterdam die het leuk vind om in de kroeg over dit topic breadboard schakelingen te praten? Ik wil proberen iets "slims" te doen met het RAM, de ALU en de PC.

De uitgang van de PC hoeft alleen maar bij het instructie register adres te komen, dat hoeft niet over de bus.

Volgens mij zijn de meeste register / geheugen operaties nauw verbonden met register A & B van de ALU en de "local IO-bus".

EMC technisch is het op dit niveau ook raadzaam om bus lijnen, aftakkingen, loops etc. klein te houden, en ook lekker op de <150 kHz klok te blijven draaien :)
Ik zit helaas niet in Amsterdam, anders was ik wel even langs gefietst. :)

Wat betreft kloksnelheden, was je echt van plan de grens op te gaan zoeken? Dit soort dingen zou ik juist bouwen om de klok zo traag te laten draaien dat je kan zien wat er gebeurt (<5Hz). Die Ben Eater geeft een heel inzichtelijke analyse van de werking van zijn computer door de klok handmatig te bedienen (in dit filmpje geeft dat een zeer goed inzicht in wat er gebeurt).

PS @GerardWassink: Goed bezig!
Momenteel ben ik bijzonder druk met studie etc. Helaas veel te weinig tijd om te hobbyen.

@SuperPrutser:
Voor mijn 16-bit addressing architectuur heb ik inderdaad een separate bus gepland. Alleen de PC, IR, MAR en RAM komen daar op.
RAM en MAR worden wel op de data bus aangesloten.

Wat betreft de ALU is het misschien leuk om naar de 74181 te kijken.
Veel operaties voor weinig. Daar ga ik op termijn ook op over.

Wanneer ik naar een dedicated (16-bit) instructie bus ga, ga ik waarschijnlijk dat met bedrading doen en niet met de breadboard power bussen zoals Ben dat doet.
Daniel Kendell (https://www.youtube.com/watch?v=yr9yEfCctOU) doet dat erg mooi. Misschien heb je er wat aan.
The programma's werken. Weliswaar met enig handmatig werk, maar de EEPROMs kunnen worden geprogrammeerd!

Zie mijn GitHub pagina.

Gerard
Ain't no place like 127.0.0.1
@tmdr, als je even tijd hebt, graag feedback op de programma's?

Gerard
Ain't no place like 127.0.0.1
Op 7 oktober 2017 13:23:07 schreef tmdr:
@SuperPrutser:
Voor mijn 16-bit addressing architectuur heb ik inderdaad een separate bus gepland. Alleen de PC, IR, MAR en RAM komen daar op.
RAM en MAR worden wel op de data bus aangesloten.


Sorry, een MAR zegt mij niet veel, I'm curious :) / Denk je ALU bedoeld.
Op 9 oktober 2017 05:43:23 schreef GerardWassink:
@tmdr, als je even tijd hebt, graag feedback op de programma's?

Gerard


Hi Gerard,
Lekker bezig joh.
Zelf heb ik echt nul tijd op het moment. Dus heb zowel mijn eigen code als die van jou nog niet kunnen draaien. Ik weet niet of je feedback-vraag dan ook gaat over "of het werkt", of qua code/aanpak. In ieder geval hier wat puntjes wat betreft het laatste (ongevraagd).

Qua code:
Zeer netjes en helder. Misschien wat meer modulair opbouwen. Begrijp dat dit een vrij recht toe recht aan toepassing is, maar dat schept ook duidelijkheid.

Qua aanpak:
Ik begrijp niet zo goed waarom je een dergelijk "protocol" opstelt. Mijn aanpak was vrij simpel met drie operaties en aan de client kant een simpele state machine. Dan krijg je een veel meer lichtgewicht protocol. Dat is misschien pre-mature optimalisation, maar zeker als ik 20 keer iets moet wijzigen aan de instructieset, vind ik het wel fijn als dat in een fractie van een seconde kan.
Zo zag het er ongeveer uit:
code:
[opcode 8-bits] [address 16-bits] [data 8-bits]
bijv:
0x0					// RESET op
0x1		[address]	[data]	// WRITE op
0x2		[address]		// READ op


In feiten doen we precies het zelfde, alleen stuur jij de opcodes als een twee-letterige string. Dat maakt weinig verschil, maar aangezien je ASCII over de lijn stuurt, is dat al weer twee bytes. Verder begrijp ik niet zo goed waarom je op verschillende plekken met HEX waardes bezig bent. Voor zo ver ik kan zien verstuur je de ASCII HEX waarde over het lijntje. Dit is anders dan wat ik doe; ik stuur de exacte binaire waarde. Dit scheelt aan de host kant het omzetten naar ASCII HEX en dat ongedaan maken aan de client kant. Keep in mind: HEX is puur een weergave encoding. Bovendien, wanneer je een 8-bit waarde naar HEX omzet, heb je daar vervolgens 16-bit voor nodig. Afin, je begrijpt me, het is ballast. Maar hey, if it works it ain't stupid ;-)

@SuperPrutser: met MAR bedoel ik Memory Address Register. Mij stond bij dat Ben deze terminologie ook gebruikt, maar ik kan het zo snel nergens terug vinden. Vreemd, misschien vergis ik me!
Op 9 oktober 2017 10:17:03 schreef tmdr:
[...]

Qua code:
Zeer netjes en helder. Misschien wat meer modulair opbouwen. Begrijp dat dit een vrij recht toe recht aan toepassing is, maar dat schept ook duidelijkheid.


Hoe bedoel je, 'modulair', op splitsen in modules of classes maken?


Qua aanpak:
Ik begrijp niet zo goed waarom je een dergelijk "protocol" opstelt. Mijn aanpak was vrij simpel met drie operaties en aan de client kant een simpele state machine. Dan krijg je een veel meer lichtgewicht protocol. Dat is misschien pre-mature optimalisation, maar zeker als ik 20 keer iets moet wijzigen aan de instructieset, vind ik het wel fijn als dat in een fractie van een seconde kan.
Zo zag het er ongeveer uit:
code:
[opcode 8-bits] [address 16-bits] [data 8-bits]
bijv:
0x0					// RESET op
0x1		[address]	[data]	// WRITE op
0x2		[address]		// READ op


In feiten doen we precies het zelfde, alleen stuur jij de opcodes als een twee-letterige string. Dat maakt weinig verschil, maar aangezien je ASCII over de lijn stuurt, is dat al weer twee bytes. Verder begrijp ik niet zo goed waarom je op verschillende plekken met HEX waardes bezig bent. Voor zo ver ik kan zien verstuur je de ASCII HEX waarde over het lijntje. Dit is anders dan wat ik doe; ik stuur de exacte binaire waarde. Dit scheelt aan de host kant het omzetten naar ASCII HEX en dat ongedaan maken aan de client kant. Keep in mind: HEX is puur een weergave encoding. Bovendien, wanneer je een 8-bit waarde naar HEX omzet, heb je daar vervolgens 16-bit voor nodig. Afin, je begrijpt me, het is ballast. Maar hey, if it works it ain't stupid ;-)

...


Als ouwe systeemprogrammeur 'denk' ik in hexadecimaal, vandaar mijn voorkeur. Verder wilde ik fixed position operands voor de commands, dat maakt het decoderen even wat makkelijker.

Ik ben benieuwd wat je er van vindt wanneer je tijd hebt om de code te draaien...

Gerard
Ain't no place like 127.0.0.1
Op 9 oktober 2017 10:27:38 schreef GerardWassink:
[...]

Hoe bedoel je, 'modulair', op splitsen in modules of classes maken?

In ieder geval de communicatie (het "protocol") isoleren van de rest van de code. Zodat je met een makkelijke wijziging ook bijv. de EEPROM voor de 7-segment display kunt programmeren. Is natuurlijk geen must, maar zo wel een leuke toevoeging zijn. Zeker omdat je het al zo uitgebreid aan het doen bent.

Op 9 oktober 2017 10:27:38 schreef GerardWassink:
Als ouwe systeemprogrammeur 'denk' ik in hexadecimaal, vandaar mijn voorkeur. Verder wilde ik fixed position operands voor de commands, dat maakt het decoderen even wat makkelijker.

Ik ben benieuwd wat je er van vindt wanneer je tijd hebt om de code te draaien...

Gerard


Haha dan is dat natuurlijk een mooie reden. Vanuit mijn achtergrond "denk" ik juist "wat probeer ik te doen". Als in, in dit geval is een binaire waarde (want dat is bijv. een int in Python gewoon) precies wat ik van de host naar de client wilt sturen. Vandaar dat ik ook aangaf dat de adressen en data operatoren prima plain over de Serial kunnen. Dan is van decoderen namelijk geen sprake. Nogmaals, if it works...!

Wat betreft je argument mbt de operands. Goed punt. Ik moet eerlijk zeggen dat ik even terug moet kijken in mijn code. Misschien dat de RESET op eerder als een aantal 0xFF gedaan kan worden; een soort jam op de lijn zetten. En dan natuurlijk niet voor elke nieuwe op, maar na het constateren van een fout. En dan als antwoord van de client op een WRITE op de waarde van de ROM direct lezen en terugsturen ter controle. Wanneer antwoord (voor W én R) uitblijft defaulten naar een RESET jam.

Ik moet er nog eens goed naar kijken. Dat gaat echter pas dit weekend of later worden :(
fred101

Golden Member

@SuperPrutser: met MAR bedoel ik Memory Address Register. Mij stond bij dat Ben deze terminologie ook gebruikt, maar ik kan het zo snel nergens terug vinden. Vreemd, misschien vergis ik me!


klopt, Ben gebruikt dat idd voor Memory Address Register

Het schiet hier niet echt op, ik ben nog niet verder dan het schema van de klokcomponenten uittekenen ivm bedrading. Ik heb wel bijna alle videos gezien.

mbt de eproms, is een diy programmer nodig ? ik heb een TL866 programmer en het kan volgens mij ook handmatig.

Ik wil eigenlijk die 74lS181 gebruiken. Met die adder/subtracter is hij wel erg hardcore maar het lijkt me leuker als het resultaat iets meer is dan een heel primitief "4 banger" rekenmachientje.
Alleen nog uitvlooien hoe dat moet (en dat is ook leerzaam)
Belangrijkste is dat ik nu wel snap hoe add/subtract werkt.
www.pa4tim.nl, Reparatie van meet- en calibratie apparatuur, ook oud en exotisch
Op 9 oktober 2017 10:54:13 schreef fred101:
[...]

klopt, Ben gebruikt dat idd voor Memory Address Register

Het schiet hier niet echt op, ik ben nog niet verder dan het schema van de klokcomponenten uittekenen ivm bedrading. Ik heb wel bijna alle videos gezien.

mbt de eproms, is een diy programmer nodig ? ik heb een TL866 programmer en het kan volgens mij ook handmatig.

Ik wil eigenlijk die 74lS181 gebruiken. Met die adder/subtracter is hij wel erg hardcore maar het lijkt me leuker als het resultaat iets meer is dan een heel primitief "4 banger" rekenmachientje.
Alleen nog uitvlooien hoe dat moet (en dat is ook leerzaam)
Belangrijkste is dat ik nu wel snap hoe add/subtract werkt.


Volgens mij is een DIY programmer juist ivm gebrek aan een volwaardige. Je zou dan met Python oid een hex file kunnen schrijven die je in de software van je programmer kunt inladen.

Wat betreft die 74181, dat wil ik ook gaan doen op termijn. Gerard heeft dat al gedaan. Misschien dat hij wat meer info kan geven of misschien heeft hij zelfs wel schema's voor je.
Op 9 oktober 2017 10:53:16 schreef tmdr:
Misschien dat de RESET op eerder als een aantal 0xFF gedaan kan worden; een soort jam op de lijn zetten. En dan natuurlijk niet voor elke nieuwe op, maar na het constateren van een fout. En dan als antwoord van de client op een WRITE op de waarde van de ROM direct lezen en terugsturen ter controle. Wanneer antwoord (voor W én R) uitblijft defaulten naar een RESET jam.

Ik moet er nog eens goed naar kijken. Dat gaat echter pas dit weekend of later worden :(


Ik heb in de Arduino Nano code een
code:
maxTries = 5;
ingebouwd die aangeeft hoe vaak een write gevolgd door een vergelijkende read plaatsvindt wanneer de teruggelezen waarde niet overeenkomt met de aangeboden waarde...

Gerard
Ain't no place like 127.0.0.1
Wat betreft de 74LS181, ik heb mijn microcode signalen op de bus uitgebreid als volgt:

code:
# EEPROM 2, bits D23 - D16
 
CE      = 1 << 23  # 0x800000 - Count Enable
HLT     = 1 << 22  # 0x400000 - Halt
PCI     = 1 << 21  # 0x200000 - PC In
PCO     = 1 << 20  # 0x100000 - PC Out
MAI     = 1 << 19  # 0x080000 - Memory Address In
MI      = 1 << 18  # 0x040000 - Memory In
MO      = 1 << 17  # 0x020000 - Memory Out
IRI     = 1 << 16  # 0x010000 - Instruction Register In
 
# EEPROM 1, bits D15 - D08
 
EO      = 1 << 15  # 0x008000 - Sigma Out (ALU value)
OI      = 1 << 14  # 0x004000 - Output In
AI      = 1 << 13  # 0x002000 - A Register In
AO      = 1 << 12  # 0x001000 - A register Out
BI      = 1 << 11  # 0x000800 - B register In
BO      = 1 << 10  # 0x000400 - B register Out
ALM     = 1 <<  9  # 0x000200 - ALU Mode
AL0     = 1 <<  8  # 0x000100 - ALU function 0
 
# EEPROM 0, bits D07 - D00
 
AL1     = 1 <<  7  # 0x000080 - ALU function 1
AL2     = 1 <<  6  # 0x000040 - ALU function 2
AL3     = 1 <<  5  # 0x000020 - ALU function 3
ALCI    = 1 <<  4  # 0x000010 - ALU Carry In
n3      = 1 <<  3  # 0x000008 - 
n2      = 1 <<  2  # 0x000004 - 
n1      = 1 <<  1  # 0x000002 - 
RSC     = 1 <<  0  # 0x000001 - Reset Step Counter on CU for Microcode Steps


Alle signalen die met 'AL' beginnen zijn voor of van de 74LS181.

Gerard
Ain't no place like 127.0.0.1
Gerard, je ALCI signaal doet mij afvragen of je al nagedacht hebt over een flags register. Want dit signaal zou met een logical AND de ALU in moeten gaan. Hoe heb je dit vormgegeven?
Hewlett

Golden Member

Misschien is het interessant om naar de schema's van DEC PDP11 machines te kijken, meeste PDP11 integer ALU's zijn ook 74S181 gebasseerd met een 74S182 carry lookahead en een wallace-tree hardware integer mutliplier. Alternatief is een AMD 2901 bit-slice ontwerp, dan ben je wat sneller klaar, die chip werd ook veel in floating-point units gebruikt (ook in de PDP11). Interessant boek hierover is het "Bit-slice Microprocessor Design" van John Mick and James Brick uitgegeven in 1980 bij McGraw-Hill.
HamRadio PA2HK // Keep Calm and Carry On.