Assemblage SAP-1 dans Turing Complete : guide

Construire le SAP-1 dans Turing Complete : Un guide étape par étape pour les développeurs

Dans le jeu Turing Complete, vous assemblez l'ordinateur SAP-1 (Simple As Possible) — une architecture 8 bits classique avec un espace d'adresses 4 bits (16 octets de mémoire). C'est un modèle basé sur un accumulateur où toutes les opérations utilisent l'accumulateur comme registre principal. Le jeu vous permet de progresser des portes logiques de base à l'architecture complète et aux programmes assembleur.

SAP-1 reproduit le design de Ben Eater : deux registres (accumulateur et auxiliaire), 16 octets de mémoire. Limitation du jeu — pas de sauvegarde de données dans les blocs de programme.

Principaux composants du SAP-1

L'architecture comprend :

• Décodeur d'instructions basé sur une puce ROM pour simplifier le microcode.
• Registres : accumulateur (A), instruction (IR), mémoire (RAM).
• ALU : additionneur/soustracteur avec drapeaux Z (zéro) et C (carry).
• Contrôleur : microcode avec signaux MI, RO, II, AI, AO, et autres.

La disposition suit l'original de Ben Eater : mémoire à gauche, ALU au centre, sortie à droite.

Implémentation du microcode

Le décodeur d'instructions utilise une ROM avec un microprogramme. Pour le chargement dans le jeu, un fichier ROM est généré. Voici le code C++ pour créer le microcode (tient compte des drapeaux ZF/CF) :

#include <windows.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <format>
#include <filesystem>

#define HLT 0b1000000000000000
// ... (ostalnye #define how in originale)

uint16_t ucode_TEMP[16][8] = {
    {MI|CO, RO|II|CE, 0, 0, 0, 0, 0, 0},  // NOP
    // ... (full array)
};

uint16_t ucode[4][16][8];

void initUCode() {
    memcpy(ucode[FLAGGS_Z0C0], ucode_TEMP, sizeof(ucode_TEMP));
    // Adaptatsiya for flagov JC/JZ
}

int main() {
    initUCode();
    std::ofstream fout("2929467240861350664.rom", std::ios::binary);
    fout.write((char*)&ucode, sizeof(ucode));
    fout.close();
    return 0;
}

Compiler avec C++20 (gnu++20 dans VS Code). Copier le fichier .rom dans le dossier utilisateur du jeu.

Commandes du processeur

| Code | Mnémonique | Description |

|-----|-----------|----------|

| 0000 | NOP | Aucune opération |

| 0001 | LDA | Charger dans A |

| 0010 | ADD | Ajouter B |

| 0011 | SUB | Soustraire |

| 0100 | STA | Stocker A |

| 0101 | LDI | Charger immédiat |

| 0110 | JMP | Saut inconditionnel |

| 0111 | JC | Saut sur carry |

| 1000 | JZ | Saut sur zéro |

| 1110 | OUT | Sortie |

| 1111 | HLT | Arrêt |

Le microcode génère des séquences de signaux pour chaque cycle d'horloge.

Installation du SAP-1 dans Sandbox

• Téléchargez les fichiers du projet.
• Trouvez le chemin dans les paramètres : C:\Users\[User]\AppData\Roaming\Godot\app_userdata\Turing Complete.
• Copiez le .rom et les schémas dans le dossier utilisateur.
• Lancez Sandbox et chargez sap-1.

Testez-le : exécutez le programme de test (jeu de mikado de Fort Boyard).

Problèmes d'assemblage et subtilités

• Éléments rotatifs : barre d'espace.
• Sélection : Shift.
• Entrée en architecture : double-clic.
• Éléments personnalisés : une entrée/sortie par tuile, au moins un composant interne.

Le jeu est en accès anticipé : la campagne s'arrête en cours de route, mais Sandbox regorge de possibilités.

Points clés

• SAP-1 est une architecture accumulateur des années 80 conçue pour économiser la mémoire.
• Microcode en ROM simplifie le décodage (alternative — logique pure).
• Limitation : 16 octets de RAM sans données dans le programme.
• Le jeu enseigne tout, des NAND à l'assembleur.
• Génération ROM via C++ pour puces personnalisées.

— Editorial Team