MIPS Assembler Tutorial: Flux Bunny Lab 3 in MARS – Schritt-für-Schritt Anleitung

MIPS Assembler Programmierung für Einsteiger: Das Flux Bunny Projekt im MARS Simulator

Im Rahmen deines Engineering Visualization Kurses wirst du im Lab 3 mit der MIPS Assembler Programmierung konfrontiert. Die Aufgabe: Schreibe ein Programm, das eine positive Ganzzahl einliest und dann von 0 bis zu dieser Zahl iteriert. Für jede Zahl prüfst du, ob sie durch 5, 7 oder beide teilbar ist, und gibst entsprechend „Flux“, „Bunny“, „Flux Bunny“ oder die Zahl selbst aus. Klingt nach einem klassischen FizzBuzz-Problem? Genau, aber in MIPS Assembler! In diesem Tutorial zeige ich dir, wie du diese Aufgabe mit dem MARS Simulator löst – inklusive Tipps zur Registerverwendung, Formatierung und zum Debugging. Egal ob du für dein CMPE 12 Studium an der UC Santa Cruz lernst oder dich einfach für MIPS32 interessierst – dieser Leitfaden hilft dir, die Konzepte zu verstehen.

Warum MIPS Assembler? Ein Blick auf aktuelle Trends

Assembler ist die unterste Programmiersprache, die direkt mit der CPU kommuniziert. In Zeiten von KI-Chatbots und Cloud Computing mag es altmodisch wirken, doch genau diese Grundlagen sind essenziell für die Entwicklung effizienter Algorithmen. Stell dir vor, du programmierst einen Raspberry Pi Pico oder einen Mikrocontroller für ein Smart Home – dort zählt jeder Taktzyklus. Auch in der Spieleentwicklung für Konsolen wie die Nintendo Switch (die auf ARM basiert) sind Assembler-Kenntnisse Gold wert. Mit MIPS lernst du, wie ein Prozessor wirklich denkt.

Vorbereitung: MARS Simulator und Fibonacci.asm

Bevor du loslegst, lade den MARS Simulator herunter und installiere ihn. MARS ist eine IDE, die speziell für die MIPS32 Architektur entwickelt wurde. Öffne die Beispiel-Datei Fibonacci.asm und mache dich mit der Oberfläche vertraut. Achte auf die Registeransicht, den Speicher und die Konsole. Ein Tipp: Setze Breakpoints und nutze den Step-Over-Modus, um den Programmfluss zu verstehen – das ist wie ein Live-Debugging in Visual Studio Code, nur für Assembler.

Struktur deines Lab3.asm Programms

Dein Programm muss eine Header-Kommentar enthalten, der deinen Namen, CruzID, Datum, Lab-Nummer, Kurs und eine Beschreibung enthält. Hier ein Beispiel:

####################################################################################
# Erstellt von:  Mustermann, Max
#               mmuster
#               13. Mai 2026
#
# Assignment:   Lab 3: Looping in MIPS
#               CMPE 12, Computer Systems and Assembly Language
#               UC Santa Cruz, Spring 2026
#
# Beschreibung: Dieses Programm liest eine positive Ganzzahl ein,
#               iteriert von 0 bis zu dieser Zahl und gibt je nach
#               Teilbarkeit durch 5 und 7 „Flux“, „Bunny“,
#               „Flux Bunny“ oder die Zahl selbst aus.
#
# Hinweise:     Dieses Programm ist für den MARS Simulator geschrieben.
####################################################################################

Denke daran, jeden Codeblock zu kommentieren und die Registerverwendung zu dokumentieren. Verwende die $t0-$t9 Register für temporäre Werte und $v0, $a0 nur für Syscalls.

Der Algorithmus: Teilbarkeit prüfen mit dem Modulo-Operator

In MIPS gibt es keinen direkten Modulo-Befehl, aber du kannst die div und mfhi Befehle kombinieren. div $t0, $t1 teilt $t0 durch $t1 und speichert den Rest in hi (high) und den Quotienten in lo (low). Mit mfhi $t2 holst du den Rest. Ist der Rest 0, dann ist die Zahl teilbar.

Beispiel: Prüfen, ob eine Zahl in $t0 durch 5 teilbar ist:

LI   $t1, 5          # Divisor 5
DIV  $t0, $t1        # $t0 / 5
MFHI $t2             # Rest in $t2
BEQ  $t2, $zero, divisible_by_5  # wenn Rest = 0, springe zu Label

Die Ausgabe: Prompt und Strings korrekt formatieren

Der Prompt muss exakt lauten: „Please input a positive integer: “ (mit einem Leerzeichen nach dem Doppelpunkt). Speichere die Strings im .data Bereich mit .asciiz. Achte auf die Großschreibung: „Flux“, „Bunny“ und „Flux Bunny“. Nach jeder Ausgabe muss ein Newline-Zeichen (\n) kommen – in MIPS verwendest du dafür den Syscall 4 für Strings und 11 für einzelne Zeichen. Am Ende des Programms rufst du den Exit-Syscall (10) auf.

Schritt-für-Schritt: Das Programm schreiben

1. Datensektion (.data)

.data
prompt: .asciiz "Please input a positive integer: "
flux:   .asciiz "Flux"
bunny:  .asciiz "Bunny"
fluxbunny: .asciiz "Flux Bunny"
newline: .asciiz "\n"

2. Textsektion (.text) – Hauptprogramm

.text
main:
    # Prompt ausgeben
    LI   $v0, 4
    LA   $a0, prompt
    SYSCALL

    # Ganzzahl einlesen
    LI   $v0, 5
    SYSCALL
    MOVE $t0, $v0          # $t0 = user input (n)

    # Schleifenvariable initialisieren
    LI   $t1, 0            # $t1 = i = 0

loop:
    BGT  $t1, $t0, exit   # wenn i > n, beende Schleife

    # Prüfe Teilbarkeit durch 5 und 7
    # Zuerst durch 5
    LI   $t2, 5
    DIV  $t1, $t2
    MFHI $t3               # Rest bei Division durch 5
    
    # Durch 7
    LI   $t2, 7
    DIV  $t1, $t2
    MFHI $t4               # Rest bei Division durch 7

    # Entscheidungslogik
    BEQ  $t3, $zero, check7
    BEQ  $t4, $zero, printBunny
    # Weder durch 5 noch durch 7: Zahl ausgeben
    LI   $v0, 1
    MOVE $a0, $t1
    SYSCALL
    J    printNewline

check7:
    BEQ  $t4, $zero, printFluxBunny
    # Nur durch 5
    LI   $v0, 4
    LA   $a0, flux
    SYSCALL
    J    printNewline

printBunny:
    LI   $v0, 4
    LA   $a0, bunny
    SYSCALL
    J    printNewline

printFluxBunny:
    LI   $v0, 4
    LA   $a0, fluxbunny
    SYSCALL
    J    printNewline

printNewline:
    LI   $v0, 4
    LA   $a0, newline
    SYSCALL
    ADDI $t1, $t1, 1       # i++
    J    loop

exit:
    LI   $v0, 10
    SYSCALL

Häufige Fehler und wie du sie vermeidest

Vergessene Newline nach der letzten Ausgabe: Die Ausgabe muss mit einem Newline enden, sonst erkennt der automatische Grader das nicht.
Falsche Registerverwendung: Verwende $t0-$t9 für temporäre Daten. $v0 und $a0 sind für Syscalls reserviert. Dokumentiere jede Registerverwendung im Kommentar.
Prompt-Format: Der Prompt muss exakt „Please input a positive integer: “ sein – inklusive Leerzeichen am Ende. Kein zusätzlicher Punkt oder andere Zeichen.
Großschreibung: „Flux“ und „Bunny“ werden großgeschrieben, „Flux Bunny“ mit Leerzeichen. Der Grader ist case-sensitive.

Der README.txt: Mehr als nur Formalität

Die README-Datei ist Teil der Bewertung. Beantworte die Fragen in mindestens 8 Sätzen. Frage 1: „In welchem Adressbereich liegen die Strings nach dem Assemblieren?“ – Öffne den Data Segment in MARS und notiere die Start- und Endadresse. Frage 2: „Was waren die Lernziele?“ – Beschreibe, dass du gelernt hast, Schleifen, Division und Syscalls in MIPS zu nutzen. Frage 3: „Gab es Probleme?“ – Vielleicht hattest du Schwierigkeiten mit dem Modulo oder der Formatierung. Frage 4: „Wie würdest du das Lab verbessern?“ – Vorschläge wie mehr Beispiele oder ein Debugging-Tutorial sind willkommen.

Tipps für den Erfolg

Nutze die MARS Tutorials und die Beispiel-Datei Fibonacci.asm als Referenz.
Teste dein Programm mit verschiedenen Eingaben: 0, 5, 7, 35, 10. Der Grader erwartet exakte Ausgabe.
Kommentiere deinen Code ausführlich – das hilft nicht nur dem Grader, sondern auch dir beim Debuggen.
Denke daran: In der Spieleentwicklung oder bei Embedded Systems sind solche Schleifen und Teilbarkeitsprüfungen Alltag. Du legst hier den Grundstein für effiziente Algorithmen.

Zusammenfassung

Mit diesem Leitfaden bist du bestens gerüstet, um das Lab 3 in Engineering Visualization zu meistern. Du hast gelernt, wie man in MIPS Assembler eine Schleife implementiert, Division und Modulo nutzt und bedingte Ausgaben erzeugt. Die MARS IDE ist ein mächtiges Werkzeug – nutze sie, um dein Programm Schritt für Schritt zu testen. Viel Erfolg bei deinem CMPE 12 Projekt!