z80 os

Sistema operativo Zebra Z80

Zebra es un sistema operativo multitarea para computadoras Z80, implementado principalmente en C con algún ensamblador.

Licencia

Este software tiene licencia bajo GPLV3. Para los términos completos de la licencia, ver aquí.

Que contribuye

Si está interesado en configurar el sistema operativo para su propio sistema, ¡póngase en contacto!

Descripción general

El sistema operativo se dirige a mi computadora modular Z80 personalizada.

El kernel está destinado a ejecutarse con 32 kb de RAM y proporciona interacción del usuario a través de una interfaz serie. Los programas de usuario se asignan una página de 32 kb de RAM bancared, lo que permite que los múltiples programas se ejecuten simultáneamente.

Este repositorio también contiene algunos programas de utilidad integrados, como un intérprete básico.

Funcionalidad actual

Cargador de arranque

Mejorador de dos etapas que permite la carga de imágenes del sistema operativo desde el sistema de archivos

Núcleo

• Sistema:
  • Multitarea utilizando RAM bancado
  • Syscalls para abstracción de hardware, implementado utilizando la instrucción Z80 rst
  • Sistema de archivos "plano" FAT16 (sin manejo de directorio) que admite las siguientes operaciones:
    • Escribir archivos nuevos (sin modo "agregar")
    • Lectura de archivos
    • Eliminar archivos
• Hardware:
  • TTL en serie E/S
  • Tarjeta CompactFlash para almacenamiento de datos

Procesador de comandos

• Interfaz de línea de comandos simple
• Comandos incorporados, por ejemplo, dir para ver archivos
• Cargador ejecutable para cargar programas desde el disco

Funcionalidad planificada (a corto plazo)

• Depurador/monitor
• Carga de programas sobre serie en formato Intel-HEX
• Guardar programas cargados en el disco
• Modo "Agregar" al escribir en archivos

Funcionalidad planificada (a largo plazo)

• Interfaz gráfica (requiere hardware de video)

Diseño del sistema

Proceso de arranque

Al inicio, la computadora modular tiene 8k de ROM a 0x0000 y 32k de RAM a 0x8000 . Un gestor de arranque reside en ROM y tiene controladores básicos de tarjetas CF capaces de leer sectores individuales del disco.

Un gestor de arranque secundario reside en los primeros 9 sectores de la tarjeta CF. Este cargador de la segunda etapa tiene las mismas rutinas de tarjetas CF, pero además tiene un controlador FAT-16 capaz de leer archivos del disco, que se formatea en formato FAT16.

Este gestor de arranque secundario se carga en RAM a 0x8000 y luego se ejecuta. Primero cambia el banco inferior ( 0x0000 a 0x7fff ) de ROM a RAM y escribe la imagen del núcleo, ubicada en el sistema de archivos de la tarjeta CF como kernel.bin , a RAM a 0x0000 . El cargador secundario se restablece a 0x0000 para arrancar en el núcleo.

El kernel inicializa un controlador completo del sistema de archivos y otros componentes del sistema operativo, luego carga el procesador de comandos ( command.exe ) desde el disco y comienza a ejecutarlo.

En este punto, el control se entrega al usuario, que puede interactuar con el sistema a través de la línea de comandos para ejecutar programas.

Mapa de memoria

 Low RAM                                  High RAM

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

• Kernel: este es el área de memoria en la que reside el núcleo (incluidos los vectores de reinicio)
• Área de programa de usuario: los programas de usuario se cargan en esta área de memoria cuando se ejecutan
• Pila: reservada para la pila de programas. Stack Pointer se inicializa a 0xF7FF en el inicio del programa y crece.
• Programa de usuario Args: Reservado para argumentos del programa de usuario ( argv y argc ).