z80 os

Système d'exploitation Zebra Z80

Zebra est un système d'exploitation multitâche pour les ordinateurs Z80, implémentés principalement en C avec un assembleur.

Licence

Ce logiciel est sous licence GPLV3. Pour les conditions de licence complète, voir ici.

Contributif

Si vous êtes intéressé à installer le système d'exploitation pour votre propre système, veuillez nous contacter!

Aperçu

Le système d'exploitation cible mon ordinateur modulaire Z80 personnalisé.

Le noyau est destiné à fonctionner avec 32 Ko de RAM et fournit une interaction utilisateur via une interface série. Les programmes utilisateur reçoivent chacun une page de 32 Ko de RAM en banque, permettant aux programmes multiples d'être exécutés simultanément.

Ce référentiel contient également certains programmes utilitaires intégrés, tels qu'un interprète de base.

Fonctionnalité actuelle

Chargeur de démarrage

Chargeur de démarrage en deux étapes permettant le chargement des images du système d'exploitation à partir du système de fichiers

Noyau

• Système:
  • Multi-tâches à l'aide de la RAM bancée
  • Syscalls pour l'abstraction matérielle, implémentée à l'aide rst instruction Z80
  • Système de fichiers FAT16 "Flat" (pas de gestion de répertoire) Soutenir les opérations suivantes:
    • Rédaction de nouveaux fichiers (pas de mode "Ajouter")
    • Fichiers de lecture
    • Suppression de fichiers
• Matériel:
  • E / S série TTL
  • Carte compacteflash pour le stockage de données

Processeur de commande

• Interface de ligne de commande simple
• Commandes intégrées, par exemple dir pour afficher les fichiers
• Chargeur exécutable pour le chargement des programmes à partir du disque

Fonctionnalité planifiée (à court terme)

• Débogueur / moniteur
• Chargement des programmes sur la série au format Intel-HEX
• Économie des programmes chargés sur disque
• Mode "Ajouter" lors de l'écriture dans les fichiers

Fonctionnalité planifiée (à long terme)

• Interface graphique (nécessite du matériel vidéo)

Conception du système

Processus de démarrage

Au démarrage, l'ordinateur modulaire a 8k de ROM à 0x0000 et 32k de RAM à 0x8000 . Un chargeur de démarrage réside dans ROM et dispose de pilotes CF-cartes de base capables de lire les secteurs individuels du disque.

Un chargeur de démarrage secondaire réside sur les 9 premiers secteurs de la carte CF. Ce chargeur de deuxième étape a les mêmes routines CF-Card mais a en outre un pilote FAT-16 capable de lire des fichiers du disque, qui est formaté au format FAT16.

Ce chargeur de démarrage secondaire est chargé dans RAM à 0x8000 puis exécuté. Il change d'abord la banque inférieure ( 0x0000 à 0x7fff ) de la ROM à la RAM et écrit l'image du noyau, située sur le système de fichiers de la carte CF sous le nom de kernel.bin , à RAM à 0x0000 . Le chargeur secondaire réinitialise ensuite 0x0000 pour démarrer dans le noyau.

Le noyau initialise un pilote complet du système de fichiers et d'autres composants du système d'exploitation, puis charge le processeur de commande ( command.exe ) à partir du disque et commence à l'exécuter.

À ce stade, le contrôle est remis à l'utilisateur, qui est en mesure d'interagir avec le système via la ligne de commande pour exécuter des programmes.

Carte de mémoire

 Low RAM                                  High RAM

0x0000┌────────────────────────┐         0x8000┌────────────────────────┐
      │ Kernel                 │               │ User Program Area      │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │               │                        │
      │                        │         0xe000├────────────────────────┤
      │                        │               │ Stack                  │
      │                        │               │                        │
      │                        │               │                        │
      │                        │         0xF800├────────────────────────┤
      │                        │               │ User Program Args      │
      └────────────────────────┘               └────────────────────────┘

• Noyau: c'est la zone de mémoire dans laquelle réside le noyau (y compris les vecteurs de réinitialisation)
• Zone de programmes utilisateur: les programmes utilisateur sont chargés dans cette zone de mémoire lorsqu'ils sont exécutés
• Stack: réservé pour la pile du programme. Le pointeur de pile est initialisé sur 0xF7FF au démarrage du programme et se développe.
• Programme utilisateur Args: Réservé pour les arguments du programme utilisateur ( argv et argc ).