Programmieren lernen am C64 – von BASIC bis Assembler

Dieser Leitfaden führt dich Schritt für Schritt vom ersten BASIC-Listing bis zu ersten Assembler-Routinen auf dem Commodore 64.

Warum ausgerechnet der Commodore 64? Weil er wie kaum ein anderer Rechner zeigt, was ein Computer wirklich tut: Speicher lesen und schreiben, Register setzen, Bits schieben – und daraus Text, Grafik und Musik formen. Am C64 ist die Distanz zwischen Code und Hardware winzig. Genau das macht ihn zum idealen Lernsystem für alle, die programmieren verstehen wollen – nicht nur „benutzen“.

1) Was du brauchst – echte Hardware oder moderner Komfort

2) BASIC 2.0 verstehen – dein erster Fuß in der Tür

Das im ROM integrierte Commodore BASIC 2.0 ist knapp, aber lehrreich. Es bietet Variablen, Schleifen, Bedingungen, einfache Ein-/Ausgabe – und vor allem: direkten Zugriff auf Speicher via PEEK (lesen) und POKE (schreiben). Damit greifst du auf Grafik-, Klang- und Systemregister zu.

2.1 Dein erstes Programm

10 PRINT "HALLO C64!"
20 GOTO 10
RUN

Drücke RUN/STOP zum Abbrechen. Schon hier lernst du: Zeilennummern strukturieren Programme, PRINT schreibt auf den Bildschirm, GOTO springt – und du steuerst den Fluss.

2.2 Variablen, Schleifen, Zufall

10 FOR I=1 TO 10
20 X=RND(1)*40 : Y=RND(1)*25
30 POKE 1024+INT(Y)*40+INT(X), 42  : REM Stern (*) ins Screen-RAM
40 NEXT
RUN

Der sichtbare Textbildschirm beginnt beim Screen-RAM an Adresse 1024 (dezimal, also $0400). Ein Zeichen ist ein Byte. Mit der Formel setzt du Sterne an zufällige Positionen.

2.3 Farben und Ränder

Der C64 hat Border– und Background-Farbe in speziellen VIC-II-Registern:

• Border: Adresse 53280 (dez. = $D020)
• Background: Adresse 53281 (dez. = $D021)

10 FOR C=0 TO 15
20 POKE 53280,C : POKE 53281,(C+2) AND 15
30 FOR T=1 TO 300:NEXT T
40 NEXT

So fühlst du die Verbindung von Code zu Hardware: Ein Wert ins Register – sofort sichtbarer Effekt.

2.4 Tastatur lesen, Interaktion bauen

Über GET A$ liest du Zeichen, ohne zu warten:

10 PRINT "DRUECKE Q, UM ZU BEENDEN"
20 GET K$ : IF K$="Q" THEN END
30 GOTO 20

Für Spiele kombinierst du GET mit POKE-Eingriffen (z. B. Sprite-Koordinaten) – siehe unten.

3) PEEK & POKE – der direkte Draht zur Maschine

Mit POKE schreibst du Bytewerte in Adressen; PEEK liest sie. Typische Bereiche:

• Screen-RAM ab 1024: Zeichen-Codes
• Farb-RAM ab 55296 ($D800): Farbcodes
• VIC-II-Register 53248–53311 ($D000–$D03F): Grafik/Sprites
• SID-Register 54272–54391 ($D400–$D47F): Sound

3.1 Einfache Sprite-Bewegung in BASIC

Sprites sind Hardware-Objekte, die der VIC-II selbst blitted. Basisschritte:

1. Sprite aktivieren
2. Position setzen
3. Daten (Form) zuweisen

5 REM  SPRITE 0 EIN, BASISWERTE
10 POKE 53269,1           : REM $D015 - Sprite 0 an
20 POKE 53248,100         : REM $D000 - X
30 POKE 53249,100         : REM $D001 - Y
40 POKE 2040,13           : REM Sprite-Pointer (zeigt auf 13*64 Bytes)
50 REM  GROBE FORMDATEN IN DEN RAM-BEREICH SCHREIBEN, z. B. AB $3400
60 REM  (Hier der Kürze wegen weggelassen – Tools erzeugen die 64-Byte-Daten)
70 FOR X=100 TO 220 : POKE 53248,X : FOR T=1 TO 4:NEXT T : NEXT

Im Alltag erzeugst du Sprite-Daten komfortabel mit Grafik-Tools und lädst sie nach 64-Byte-Grenzen ab. Der Pointer in 2040 ist der Index auf diese 64-Byte-Blöcke.

3.2 Kleiner Sound-Kick

Für einfache Effekte reicht ein Lautstärke-Impuls:

10 FOR V=0 TO 15 : POKE 54296,V : FOR T=1 TO 30:NEXT T : NEXT
20 FOR V=15 TO 0 STEP -1 : POKE 54296,V : FOR T=1 TO 30:NEXT T : NEXT

54296 ist das SID-Lautstärkeregister ($D418). Für „richtige“ Töne setzt du Frequenz, Wellenform und Hüllkurven der Stimmen – das folgt idealerweise in einem eigenen Kapitel.

4) Von BASIC zu Assembler – warum und wann?

BASIC ist großartig zum Lernen – aber langsam bei Grafik, Spielen und Echtzeit-Sound. Assembler ist die Sprache der CPU (6510, eine Variante des 6502). Sie lässt dich:

• Pixel und Sprites sehr schnell bewegen
• präzise Soundroutinen und Effekte programmieren
• Interrupts, Rasterzeilen-Tricks, Scroller und Demos bauen

4.1 Was du über den 6510 wissen solltest

• Register: A (Akkumulator), X, Y, Status, Stackpointer, Program Counter
• Adressierungsarten: immediate (LDA #$01), absolute (LDA $D020), zero page (LDA $02), indiziert (LDA $D000,X), indirekt u. a.
• Taktrate: ~1 MHz (PAL), dafür sehr nahe am Metall

4.2 Minimales Assembler-Programm (Farben blinken)

Mit einem Cross-Assembler erzeugst du eine .prg, die du im Emulator startest. Beispiel (pseudoneutral, für gängige Assembler leicht anpassbar):

; Setzt Border/Background in einer Schleife
        * = $0801        ; BASIC-Autostart-Stub könnte hier stehen (optional)
        * = $1000
Start   LDA #$00
Loop    STA $D020        ; Border
        CLC
        ADC #$01
        AND #$0F
        STA $D021        ; Background
        JSR Wait
        BNE Loop
Wait    LDY #$FF
W1      LDX #$FF
W2      DEX
        BNE W2
        DEY
        BNE W1
        RTS

Das ist keine „schöne“ Zeitbasis – aber du siehst den Unterschied: direkte Registerzugriffe, kaum Overhead, sofortige Reaktion.

5) Tool-Empfehlungen für den Start

6) Praxis: Ein einfacher Assembler-Scroller (Text schieben)

Ein klassischer Effekt ist der horizontale Text-Scroller im Textmodus. Kernidee: Das Screen-RAM (ab 1024) nach links schieben und rechts neue Zeichen einspeisen.

; Sehr vereinfachte Idee (Pseudo-Assembler)
        * = $1000
SCROLL  LDY #$00
ROW     LDX #$00
LOOP1   LDA $0401,X      ; Zeichen aus Spalte 1
        STA $0400,X      ; nach links kopieren
        INX
        CPX #$27         ; 40 Spalten = $28, letzte bleibt für neuen Char
        BNE LOOP1
        LDA NewChar      ; neuer Buchstabe
        STA $0427        ; rechts anfügen
        ; nächste Zeile? (40er Schritte, +$28)
        ; ... (wiederholen, oder nur eine Zeile scollen)
        JMP SCROLL

Für echte Demos nutzt man Raster-Interrupts, um das Timing exakt an den Bildaufbau zu koppeln – ein ideales Lernprojekt nachdem die Basics sitzen.

7) Von der Theorie zur Praxis: Ein Lernpfad, der funktioniert

1. BASIC-Warm-up: Variablen, Schleifen, Screen-RAM, Farben, GET-Eingaben. Schreibe ein kleines Textspiel (z. B. „Ratespiel“ mit Highscore).
2. PEEK/POKE-Power: Sprite aktivieren, bewegen; Farbe/Position aus Eingaben ändern. Baue einen „Sprite-Editor light“, der Koordinaten in Variablen hält.
3. Assembler-Hello: Lade eine Mini-Routine bei $1000 und starte sie aus BASIC (SYS 4096). Lasse Border/Background blinken, bewege einen Sprite-X-Wert in einer Schleife.
4. Assembler-Spielstein: Positions-Update (X/Y), Kollision (Sprite-Kollisionsregister), Punkte zählen – zurückmelden an BASIC (gemeinsame Daten im RAM).
5. Raster-IRQ: Richte einen Interrupt ein, der regelmäßig Logik/Grafik ausführt, während BASIC oder das Hauptprogramm ruhig bleibt.
6. Sound-Step: Nutze eine einfache Tonroutine (Frequenz setzen, Gate an/aus). Erweitere später um Hüllkurven und Wellenform-Variationen.
7. Miniprojekt abschließen: Einfache „Catch-the-Star“-Mechanik oder ein einzeiliger Scroller mit Sound-Tick.

8) Typische Stolpersteine – und wie du sie vermeidest

• Zeit & Takt: BASIC-Schleifen wirken zufällig langsam; plane visuelle Effekte mit kleinen Warte-Schleifen oder (später) Raster-Interrupts.
• Speicherbereiche: Nicht jeden Bereich darfst du bedenkenlos überschreiben. Screen-RAM, Farb-RAM, Zero Page, I/O-Register – lerne ihre Adressen.
• Sprite-Datenlage: Sprite-Pointer zeigen auf 64-Byte-Blöcke. Achte auf korrekte Ausrichtung und Bank-Einstellungen, sonst „verzieht“ es Sprites.
• Emulator vs. echte Hardware: Filter, Timing, TV-Ausgabe – teste kritische Effekte auch „am Eisen“, wenn möglich.

9) Praxisbeispiele – kurz & knackig

9.1 BASIC: Textlauflicht quer über den Bildschirm

10 POKE 53280,6 : POKE 53281,0 : CLR
20 T$=" C64 ROCKT!  "
30 FOR R=1 TO 200
40 FOR I=1 TO LEN(T$)
50 POKE 1024+I,ASC(MID$(T$,I,1))
60 NEXT I
70 FOR D=1 TO 80:NEXT D
80 FOR I=1 TO LEN(T$)-1
90 POKE 1024+I,PEEK(1024+I+1)
100 NEXT I
110 NEXT R

9.2 BASIC: Einfacher „Biep“ auf Knopfdruck

10 PRINT "DRUECKE LEERTASTE FUER BIEP"
20 GET K$ : IF K$<> " " THEN 20
30 FOR V=0 TO 15 : POKE 54296,V : NEXT : FOR V=15 TO 0 STEP -1 : POKE 54296,V : NEXT
40 GOTO 20

9.3 Assembler: Border blitzt beim Tastendruck

; Läuft ab $1000, Start via SYS 4096
        * = $1000
START   LDA #$06
        STA $D020
WARTEN  JSR GETKEY        ; eigene Routine, die 0 zurückgibt, wenn kein Key
        BEQ WARTEN
        LDA #$02          ; andere Farbe
        STA $D020
        JSR DELAY
        LDA #$06
        STA $D020
        JMP WARTEN

GETKEY  LDA $C6           ; Tastatur-Pufferzähler (einfacher Poll)
        RTS

DELAY   LDY #$FF
D1      LDX #$FF
D2      DEX
        BNE D2
        DEY
        BNE D1
        RTS

Die Key-Abfrage hier ist minimalistisch. „Richtig“ tastet man die CIA-Ports ab oder nutzt KERNAL-Routinen – das lernst du im nächsten Schritt deiner Reise.

10) Didaktischer Mehrwert – C64-Programmieren als Bildungskatalysator

Ein Retro-System reduziert Komplexität: kein Paket-Chaos, keine Milliarden-Bibliotheken, keine GUI-„Magie“. Du interagierst direkt mit Speicher und Registern – ausgezeichnet, um Algorithmik (Schleifen, Bedingungen, Datenstrukturen) und Systemverständnis (Speicher, I/O, Interrupts) zu verankern. In Lernumgebungen (AGs, Maker-Spaces, Hochschul-Propädeutik) liefert der C64 schnelle Erfolgserlebnisse und fördert Transfer: Wer hier PEEK/POKE meistert, denkt auch in modernen Umgebungen näher an der Maschine.

11) Projektideen für deine ersten Wochen

• „Snake light“ in BASIC mit Score und Wänden
• Sprite-Demo: ein Objekt folgt Eingaben (links/rechts/hoch/runter)
• Scroller mit Logo (Textmodus), später Char-Animation (eigene Tiles)
• Mini-SFX (BASIC): kurze Lautstärke-Hüllkurve, „Treffer“-Sound
• Assembler-Upgrade: Sprite-Bewegung in IRQ-Routine für weiches Scrolling

12) Nächste Schritte – wie es sinnvoll weitergeht

1. Lege dir eine Cheatsheet-Liste mit Kernadressen an (Screen-RAM, VIC-II, SID, CIA).
2. Nutze den Emulator-Monitor: Step-by-Step, Register betrachten, Speicher „live“ ändern.
3. Trenne Logik und Darstellung früh – erst Daten, dann Anzeige. Das lohnt sich auch bei 1 MHz.
4. Lerne ein Assembler-Makrosystem, um wiederkehrende Muster (Warteschleifen, Sprite-Updates) sauber zu kapseln.
5. Baue dir eine kleine Libray (IRQ-Init, Zeitbasis, Zufall, Text-Out), die du in neue Projekte übernimmst.