Intel 4004 Assemblerprogrammierung

[Wolfgang R. (Firma: www.wolfgangrobel.de) (mikemcbike)]

8051 ist mir zu neu und ARM zu komplex. Da mir letztens ein 
Uralt-Programmer der Marke Pro-Log M900 in die Hände fiel...

http://www.wolfgangrobel.de/programmer/m900.htm

und der 4004-Code nicht mehr funktionierte, dachte ich mir, eine 
Neuprogrammierung wäre sinnfrei aber trotzdem fein.

Unter http://e4004.szyc.org/ gibt es einen hervorragenden Assembler / 
Disassembler / Emulator, der einem prächtig beim Ausprobieren der 
Programme auch ohne Hardware hilft.

Folgendes Programm habe ich mal geschrieben, um eine 16-stellige 
Dezimalmultiplikation zu erreichen. Das ist nicht ganz trivial bei so 
wenig Befehlen und nur 4 Bit Datenbreite...

; *********************************************************************
; * 4004 Testroutine - Rechner
; * *******************************************************************
; * WR - 2017-04-03
; * *******************************************************************
; * Version 1.0
; * *******************************************************************
; * Funktion: A += B; A -= B; A = C*D  
; *   P0_R0R1:  Datenpointer ZAHL A (Ergebnis)
; *    P1_R2R3:   Datenpointer ZAHL B
; *   P2_R4R5:  Datenpointer ZAHL C
; *   P3_R6R7:  Datenpointer ZAHL D
; *    P4_R8R9:  Schleifenzaehler / Austauschregister
; *    P5_R10R11:  Zaehler Subroutine / Austauschregister Subroutine
; *    P6_R12R13:  Datenpointer 1 Subroutine
; *    P7_R14R15:  Datenpointer 2 Subroutine
; *********************************************************************

; *********************************************************************
; *********************************************************************
; **************       Initialisierungen       **************
; *********************************************************************
; *********************************************************************

INIT  LDM 0      ; select RAM bank 0
    DCL        ; Set Command Line
    ; Register mit Zahlen fuellen
    FIM P0, DATAA  ; Look Up Adresse Zahl A
    FIM P1, $00    ; Registeradresse Zahl A
    JMS LDNUM
    FIM P0, DATAB  ; Look Up Adresse Zahl B
    FIM P1, $10    ; Registeradresse Zahl B
    JMS LDNUM
    FIM P0, DATAC  ; Look Up Adresse Zahl C
    FIM P1, $20    ; Registeradresse Zahl C
    JMS LDNUM
    FIM P0, DATAD  ; Look Up Adresse Zahl D
    FIM P1, $30    ; Registeradresse Zahl D
    JMS LDNUM    ; Sprung zum Programmstart
    JUN MAIN
    ; Kopierroutine
LDNUM  LDM $8
    XCH R8      ; Schleifenzaehler 8 Zugriffe
LDNUM1  FIN P2      ; Datum holen
    XCH R4
    SRC P1
    WRM
    XCH R5
    INC R3
    SRC P1
    WRM
    INC R3
    INC R1      ; naechstes Datum
    ISZ R8, LDNUM1
    BBL 0
*=$030          ; Lookup Table Start auf Vielfachem von 16!
DATAA    
    .BYTE $00    ; 00 00 00 00 00 00 00 00
    .BYTE $00    
    .BYTE $00
    .BYTE $00
    .BYTE $00
    .BYTE $00
    .BYTE $00
    .BYTE $00
DATAB    
    .BYTE $01    ; 00 00 00 89 76 54 32 10
    .BYTE $23
    .BYTE $45
    .BYTE $67
    .BYTE $89
    .BYTE $00
    .BYTE $00
    .BYTE $00
DATAC    
    .BYTE $01    ; 00 00 00 89 76 54 32 10
    .BYTE $23
    .BYTE $45
    .BYTE $67
    .BYTE $89
    .BYTE $00
    .BYTE $00
    .BYTE $00
DATAD    
    .BYTE $00    ; 00 00 00 00 00 00 00 00
    .BYTE $00
    .BYTE $00
    .BYTE $00
    .BYTE $00
    .BYTE $00
    .BYTE $00
    .BYTE $00  
      
; *********************************************************************
; *********************************************************************
; **************       Hauptprogramm         **************
; *********************************************************************
; *********************************************************************
  
MAIN  FIM P6, $10    ; Register 3 = Register 1
    FIM P7, $30
    JMS COPY
    JMS MUL01    ; Register 0 = Register 1 * Register 2
    FIM P6, $30    ; Register 1 = Register 3
    FIM P7, $10
    JMS COPY
    FIM P6, $30    ; Clear Register 3
    JMS CLEAR
    
LOCK  JUN LOCK  
  
; *********************************************************************
; *********************************************************************
; **************       Unterprogramme         **************
; *********************************************************************
; *********************************************************************  

; *********************************************************************
; Leftshift REG1 - Multiplikation mit 10
; *********************************************************************
; Aendert: Register File 1
; Aendert: ACC
; Aendert: R10, R11, P7(R14,R15)
; *********************************************************************
LSHFT  LDM $0
    XCH R10      ; Schleifenzaehler 16 Digits
    LDM $0
    XCH R11      ; Austauschregister (Anfang 0)
    FIM P7, $10    ; Register  Pointer P7 (R14,R15)
LS02  SRC P7      ; Adresspointer einstellen
    RDM        ; ACC <-  REG1[R10]
    XCH R11
    WRM        ; REG0[R10] <- R11
    INC R15      ; P7 += 1
    ISZ R10, LS02
    BBL 0
    
; *********************************************************************
; CLEAR (P6) = 0
; *********************************************************************
; Aendert: Register File (P6)
; Aendert: ACC
; Aendert: R10, P6(R12,R13)
; *********************************************************************; 
CLEAR  LDM $0
    XCH R10      ; Schleifenzaehler 16 Digits
CLEAR1  SRC P6      ; Adresspointer einstellen
    LDM $0
    WRM        ; REGn[R10] <- 0
    INC R13
    ISZ R10, CLEAR1 ; Naechste Stelle
    BBL 0    

; *********************************************************************
; COPY (P6)-->(P7)
; *********************************************************************
; Aendert: Register File (P7)
; Aendert: ACC
; Aendert: R10, Vorher P6 mit Quelle und P7 mit Ziel laden!
; *********************************************************************; 
COPY  LDM $0
    XCH R10      ; Schleifenzaehler 16 Digits
COPY04  SRC P6      ; Adresspointer einstellen
    RDM        ; ACC <-  REG0[P7]
    SRC P7
    WRM        ; REG1[R8] <- ACC
    INC R13
    INC R15
    ISZ R10, COPY04  ; Naechste Stelle
    BBL 0    
        
; *********************************************************************
; Addition REG0 = REG0 + REG1
; *********************************************************************
; Aendert: Register File 0
; Aendert: ACC
; Aendert: R10, P6(R12,R13), P7(R14,R15)
; *********************************************************************;
ADDAB  CLC
    LDM $0
    XCH R10      ; Schleifenzaehler 16 Digits
    FIM P6, $00    ; Summand 1, Summe
    FIM P7, $10    ; Summand 2
ADD01  SRC P6
    RDM        ; A lesen
    SRC P7
    ADM        ; B dazu addieren
    DAA
    SRC P6
    WRM        ; A schreiben
    INC R13
    INC R15
    ISZ R10, ADD01  ; Naechste Stelle
    BBL 0

; *********************************************************************
; Subtraktion REG0 = REG1 - REG2 oder REG2 - REG1
; *********************************************************************
; Aendert: Register File 0
; Aendert: ACC
; Aendert: R10, P0(R0,R1), P6(R12,R13), P7(R14,R15)
; *********************************************************************;    
SUBBC  LDM $0
    XCH R10      ; Schleifenzaehler 16 Digits
    FIM P6, $00    ; Subtrahend 1
    FIM P7, $10    ; Subtraktor 2
    FIM P0, $20    ; Differenz
SUBBC1  STC
SUBBC2  TCS        ; Transfer Carry Subtract
    SRC P6
    SBM        ; ACC = ACC - P1
    CLC
    SRC P7
    ADM        ; ACC = ACC + P0
    DAA        ; Decimal Adjust
    SRC P0
    WRM        ; P2 = ACC
    INC R1
    INC R13
    INC R15
    ISZ R10, SUBBC2  ; naechste Stelle
    JCN CN, SUBBC3  ; Wenn Ergebnis <0 --> Subtrahenden tauschen
    FIM P7, $00    ; Subtrahend 1
    FIM P6, $10    ; Subtraktor 2
    FIM P0, $20    ; Differenz
    SRC P0      ; Registeradresse einstellen
    LDM 1
    WR3        ; Status Ergebnis negativ
    JUN SUBBC1    ; Subtraktion noch mal machen
SUBBC3  BBL 0    

; *********************************************************************
; Multiplikation REG0 = REG1 * REG2
; *********************************************************************
; Aendert: Register File 0, 1
; Aendert: ACC
; Aendert: R10, P2(R4,R5)
; *********************************************************************;          
; Multiplikation REG0 = REG1 * REG2 (A = B * C)
MUL01  LDM $0
    XCH R8      ; Schleifenzaehler 16 Digits MUL
    FIM P2, $20    ; Pointer C
MUL02  SRC P2
    RDM        ; Digit lesen
    XCH R9      ; Additionszaehler
MUL03  LD  R9      ; Anzahl Schleifendurchlaeufe; 0: Break!
    JCN A0, MUL04  ; Abbruch bei 0
    DAC        ; ACC-=1
    XCH R9      ; Zaehler zurueckschreiben
    JMS ADDAB    ; A+=B
    JUN MUL03    ; naechster Schleifendurchlauf
MUL04   JMS LSHFT    ; B<<1
    INC R5
    ISZ R8, MUL02
MUL05  BBL 0     
    
.END

[Wolfgang R. (Firma: www.wolfgangrobel.de) (mikemcbike)]

Der Spaß ist mir eingefallen, weil es hier im Forum schon mal die Frage 
nach einer solchen Multiplikation gab...

Wer will, kann den Code gerne ausprobieren oder auch eigene Routinen zur 
Verfügung stellen. Komisch, im Netz sind kaum Code-Snippets zum 4004 zu 
finden, woran mag das liegen?

;-)

[Georg (Gast)]

Wolfgang R. schrieb:
> und der 4004-Code nicht mehr funktionierte

Programme nutzen sich nicht ab und hören auf zu funktionieren. Auf 
funktionsfähiger Hardware muss das Programm noch in Tausenden von Jahren 
laufen.

Georg

[(º°)·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.· (Gast)]

Den 4004 haette ich auch nur mit der Kneifzange angefasst.

Allein schon die von Intel dafuer vorgesehenen EPROMs,
mit 1/4 kByte und Programmierspannungen von > 50V wenn
ich mich richtig entsinne.

Und gegen die damals schon vorhandenen Minicomputer mit
16 oder 32 bit Verarbeitungsbreite, konnte ein 4004 auch
nichts reissen. Der einzige Vorteil waere die kleine moegliche
Bauform gewesen...


P.S.: Das Institut wo ich damals gearbeitet habe, hatte
ein komplettes IC-Kit vom 4004 im Panzerschrank.

Nur zusammenbauen wollte es keiner :-). Weil: Siehe oben...

[Wolfgang R. (Firma: www.wolfgangrobel.de) (mikemcbike)]

Georg schrieb:
> Programme nutzen sich nicht ab und hören auf zu funktionieren.

Ach...

Aber EPROMs verlieren ihre Programmierung.

[Wolfgang R. (Firma: www.wolfgangrobel.de) (mikemcbike)]

(º°)·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.· schrieb im Beitrag 
#4962977:
> damals schon vorhandenen Minicomputer mit
> 16 oder 32 bit Verarbeitungsbreite

Welche waren das?

[Der Andere (Gast)]

Wolfgang R. schrieb:
>> damals schon vorhandenen Minicomputer mit
>> 16 oder 32 bit Verarbeitungsbreite
>
> Welche waren das?

PDP 11

[Wolfgang R. (Firma: www.wolfgangrobel.de) (mikemcbike)]

Der Andere schrieb:
> PDP 11

War vom Stromverbrauch und der benötigten Grundfläche nicht direkt 
vergleichbar... ;-)

[Der Andere (Gast)]

Wolfgang R. schrieb:
> War vom Stromverbrauch und der benötigten Grundfläche nicht direkt
> vergleichbar... ;-)

Nein, aber ein damals verfügbarer "Minicomputer".

Und ein 4004 alleine macht auch noch keinen Rechner :-)
Der war doch eigentlich nur als Herzstück von Rechenmaschinen entwickelt 
worden, oder?

[Wolfgang R. (Firma: www.wolfgangrobel.de) (mikemcbike)]

Vom Konzept her war er als 5-Chip Lösung ein funktionsfähiger Computer.

Prozessor: 4004
RAM: 4002
ROM: 4001 (verzichtbar, wenn EPROM)
Bus-Multiplexer 4008/9
und EPROM, z.B. 1702A oder 2708.

--> http://www.wolfgangrobel.de/programmer/img_m900/m900_05.jpg

Ein 6502 funktioniert auch nicht alleine...

[Bitwurschtler (Gast)]

Der Andere schrieb:
> Wolfgang R. schrieb:
>> War vom Stromverbrauch und der benötigten Grundfläche nicht direkt
>> vergleichbar... ;-)
>
> Nein, aber ein damals verfügbarer "Minicomputer".
>
> Und ein 4004 alleine macht auch noch keinen Rechner :-)
> Der war doch eigentlich nur als Herzstück von Rechenmaschinen entwickelt
> worden, oder?

Naja, so einen richtigen standalone 4004 gab es eigentlich nicht. Dazu 
gabs "passend" entworfenen RAM/ROM. Und damit man für alle IC's das 
selbe billige Gehäuse nehmen kann wurde der 8bit Bus auf 4bit 
gemultiplexed. Also Datenrate mal mindestens halbiert nur um ein paar 
Cents für die Gehäuse zu sparen. Also Dämlichkeit ist keine Erfindung 
der letzen Jahre.

Da mal der Schaltplan zu dem Kerlchen: 
http://www.intel.com/Assets/PDF/General/4004_schematic.pdf

Ist heute nur noch als schlechtes Beispiel für Rechenwerkarchitektur 
brauchbar.

Vor 8008 sollte man keine CPU anfassen, erst mit Z80 kommt Spass auf. 
Meinetwegen noch 6502 und 6800, aber 4004 nimmer.

[Carl D. (jcw2)]

Eigentlich sollte das doch ein Chipsatz für einen Tischrechner werden, 
aber ein kleiner Intel-Rebell hatte das Problem, daß er dieses Projekt 
ziemlich planlos geerbt hat. Durch die Idee der Programmierbarkeit, 
konnte er Hard- und Software parallel entwickeln und seinem Kunden, dem 
späteren Entwickler von Z80/Z8000 und 80286, plausibel machen, daß intel 
ihn nicht betrogen hatte. Und Rechenmaschinen leben von serieller 
BCD-Arithmetik und 4-Bit Speicherbreite. Es gibt auch die 
Original-Source der Busicom Rechenmaschine, in der man sehen kann, wie 
eine Virtuelle Maschine die Einzelziffern-Arithmetik zu komplexeren 
Operationen zusammenbaut.
Keine PDP11, aber auch keine Schrankwand!

http://www.4004.com/2009/Busicom-141PF-Calculator_asm_rel-1-0-1.txt

[Soul E. (Gast)]

Bitwurschtler schrieb:

> Vor 8008 sollte man keine CPU anfassen, erst mit Z80 kommt Spass auf.
> Meinetwegen noch 6502 und 6800, aber 4004 nimmer.

Ford T-Modell fährt sich auch scheisse. Vor allem weil Gas und Bremse an 
der falschen Stelle sind.

[Manfred (Gast)]

Wolfgang R. schrieb:
> Komisch, im Netz sind kaum Code-Snippets zum 4004 zu
> finden, woran mag das liegen?
Zu der Zeit haben die Leute noch gelesen und selbst nachgedacht.

Internet für Faule gab es damals noch nicht, wer der Materie nicht Herr 
wurde, hat sich einen anderen Beruf suchen müssen!

Wie Du sagst
Wolfgang R. schrieb:
> sinnfrei aber trotzdem fein
sehe ich das auch - aber mache es trotzdem weiter! Ich bin zu faul 
geworden, meine 6502 und 68HC805 noch einzusetzen.