sábado, 27 de junio de 2015

¿Cómo emulo el panel de una DEC PDP-11/40 en Ubuntu de 64 bits?

Al recibir visitas en su despacho de Puerta de Hierro, Juan Perón demostraba su avezado entendimiento de los pormenores políticos de la Argentina, pero también utilizaba dicho tiempo para utilizar su mainframe DEC PDP-11/40 para realizar diferentes tareas simples, e instruir a la masa en las prácticas más sencillas de su conducción de este aparato que en sus inicios, sólo podía manejarse a través de interruptores.

(...)
Cuentan que en el buen año de 1785, un aniñado Carolo Federico Gauss de tan sólo 8 abriles, asistía a clase de matemáticas en una escuela repleta de teutones cargosos. Su profesor - maldiciendo la hora en que eligió su apostolado - encontró la solución que necesitaba para aquél problema que lo aquejaba: la energía juvenil de sus rubicones educandos. Les conminó entonces a encontrar el total de la suma de todos los números del 1 al 100, sólo para mantenerlos ocupados. La tediosa representación implica sumar 1+2+3+...+n.

Gauss, haciendo uso de un genio algebraico desarrollado por no contar con una Playstation, se avivó que podía reordenar los números así: (1+100) + (2+99) + (3+98) ... (50+51) = resultando en cincuenta pares de cifras que sumadas siempre cobraban el valor de 101... Y si ello se multiplicaba por cincuenta, se obtenía el resultado de la incógnita propuesta: 5050. Pero al generalizar, descubrió que sería mas sencillo ganarle de mano al profesor, plantear la ecuación n*(n+1)/2, y poder resolver cualquier problema similar con que les saliera...
Lo complejo puede parecer malo, pero será siempre bueno si nos sirve para aplicarlo a todo, y para hacer mas simple una tarea repetitiva... tal es el dogma que ha de seguir todo aquel que haga de la Conducción su arte, y de la programación, su oficio.

Vean señores, programar un sistema informático requiere de ciertos conocimientos, pero no deja de constituirse en una técnica que basa su acción en la noción de la repetición, tarea que recae en un equipo, quien será el que reciba la carga laboral. Es por ello que se dice que el software no es otra cosa que "conocimiento en acción", y mientras que abarcamos el rol de Conductor, a nuestro sistema informático recaerá el de operar como la Masa Trabajadora, destinada a realizar nuestro designio.

Nuestro Movimiento ha dado todo a todos, pero en ocasiones conviene volver a las raíces del primer Justicialismo para lograr la tan ansiada Justicia Social. Contar con las herramientas primigenias nos puede asistir a comprender lo doctrinario y lo conceptual, pues nos acercará de la manera más básica a integrar un movimiento político. Y esto que tan verdadero es en la conducción, lo encontraremos reflejado también en un ambiente informático.

Un ejemplo suele aclararlo todo, como decía Napoleón. La computadora mainframe DEC PDP-11/40 de enero de 1973 cumplió enormes funciones como equipo de uso general. Se trataba de una iteración mas potente del modelo /20, esta vez con una unidad central de proceso DEC KB11 dotada de microcódigo en dos plaquetas, capaz de un manejo de memoria de 18 bits (con hasta 128 kilowords de memoria en los sistemas mas pisteros).
Si bien es obsoleta desde el punto de vista técnico, su lógica es aún totalmente válida para comprender la doctrina general en las Ciencias de la Computación, su teoría y práctica en el uso de sistemas operativos. Ya he ilustrado como emularlas a través del excelente SimH y cargarles un sistema operativo UNIXv6, antecesores fundamentales del sistema libre GNU, lo que nos libera de tener que contar con uno de estos equipos "de colección".

En primer lugar - en el caso de utilizar Ubuntu de 64 bitios - hemos de descargar las dependencias requeridas. Para ello abrimos una Terminal e ingresamos los siguientes Comandos de Organización:


sudo dpkg --add-architecture i386 ;
sudo apt-get update ;
sudo apt-get install libx11-dev libpth-dev xorg-dev gcc libjpeg-dev libpthread-workqueue-dev x11proto-core-dev x11proto-bigreqs-dev freeglut3 freeglut3-dev ;
sudo apt-get install libc6:i386 libncurses5:i386 libstdc++6:i386 ;
sudo apt-get install libpcap0.8:i386 ;
sudo apt-get install libxext6:i386 libxtst6:i386 libxi6:i386 ;

Luego creamos un directorio para los paneles y nos dirigimos a el:

mkdir ~/.simh/ ~/.simh/panelsim/
cd ~/.simh/panelsim/

El siguiente paso variará de acuerdo a si tenemos un sistema de 32 o de 64 bitios:

  • Si tengo Ubuntu de 64 bits debo ingresar estos comandos:
wget https://github.com/j-hoppe/BlinkenBone/releases/download/1.3/panelsim_ubuntu-x64.tgz ;
tar -xvf panelsim_ubuntu-x64.tgz -z ;

  • Si tengo Ubuntu de 32 bits - en tanto - debo ingresar estos comandos:
wget https://github.com/j-hoppe/BlinkenBone/releases/download/1.3/panelsim_ubuntu-x86.tgz ;
tar -xvf panelsim_ubuntu-x64.tgz -z ;

Luego debo preparar el resto del sistema, lo podré hacer con el comando:

sudo ./prepare.sh

Tras introducir nuestra contraseña, el programa revisará si tenemos instalados todos los componentes necesarios (rpcbind, Java, y otros). Si faltase alguno nos propondrá instalarlo mediante el siguiente mensaje.

'rpcbind' not found, I'm going to install it.
OK? Enter = yes, ^C = no.

Para instalarlo presionamos Enter.

Podemos iniciar el panel de la PDP-11/40 con dos sistemas operativos: el RT-11SJ o el Unix V6. Para iniciar el primero podremos utilizar los comandos:


cd ~/.simh/panelsim/
sudo ./pdp1140_rt11.sh

Se harán presentes dos ventanas de aplicaciones: por un lado tendremos la consola de video del emulador SimH propiamente dicho que también oficiará como la consola serial de la PDP-11 emulada.
...y por otro lado se nos presentará la consola de mando de la DEC PDP-11/40, con sus interruptores, conmutadores, botones e indicadores luminosos virtualizados en calidad fotográfica. En la parte superior de dicha ventana habremos de encontrar el menú desplegable Size, que nos permitirá escoger un tamaño de ancho en pixels para la ventana (por ejemplo, 1200 píxels).


La consola de la PDP-11 estará apagada, pero al iniciarse la máquina virtual, nos mostrará actividad a través de sus indicadores luminosos parpadeantes. La consola terminal - en tanto - mostrará el prompt de arranque del sistema operativo primigenio de la PDP-11, el RT-11SJ, solicitándonos la fecha en formato dd-mmm-yy). Para facilitar la cosa, conviene ingresar una fecha anterior a 1999 (ej. 17-oct-45). Tras ingresar la fecha, hora, y cuando nos solicite archivo de arranque "Startup file", debemos ingresar Enter. El sistema estará listo, mostrándonos el prompt (un simple punto ".").
El sistema operativo RT-11SJ era la versión básica incluida, y era un entorno monotrarea. Podríamos investigarlo ingresando el comando de ayuda del mismo. Tipeando en nuestra terminal serial el comando:

help *

...nos listará todos los comandos disponibles. Si queremos conocer el uso de un comando, podemos tipear:

help comando

Por ejemplo, con el emulador se encuentran una serie de archivos de animación ASCII para la terminal serial (archivos *.VT). Podríamos listarlos con:

dir *.vt

Y visualizar alguno en el monitor de la terminal serial con la orden type, por ejemplo:

type trek.vt

Ahora bien, la terminal serial, si bien extremadamente conveniente, era oligárquica, y en un principio el Justicialismo hubo de "mover la palanca". ¿Porqué? Pues estudiemos el panel de la DEC PDP-11/40.

Es una unidad que influyó enormemente sobre otros diseños de la época, que no solo clonaban su arquitectura computacional sino su modo de operar (¡incluso detrás de la Cortina de Hierro!). En su parte superior encontramos el panel luminoso ADDRESS, el cual detalla, en octales, la dirección de memoria en la cual se encuentra el puntero del sistema. En su parte inferior encontramos el panel luminoso DATA, en el cual se muestran en octales, el registro propiamente dicho.

La PDP-11/40 se operaba - inicialmente - ingresando directamente los datos en la memoria, para ello existen en la parte inferior de la consola, los conmutadores de control, de 18 bits (nomenclados de 17 a 0), divididos en octales de colores rojo y azul alternados.

A diferencia de un panel "tipo calculadora" en decimales, este panel de conmutadores permiten depositar valores numéricos en octales o en binario, según la necesidad. Al operar en binario, poniendo el conmutador hacia abajo quedará "0" y hacia arriba en posición "1". Al operar en octales, contaremos con 16 bits (conmutador 0 al 15) y dos bits de parada: con los valores siguientes:

Conmutador  8 = 400  Conmutador 17 = MSB
Conmutador  7 = 200  Conmutador 16 = LSB
Conmutador  6 = 100  Conmutador 15 = 100000

Conmutador  5 = 40   Conmutador 14 = 40000
Conmutador  4 = 20   Conmutador 13 = 20000
Conmutador  3 = 10   Conmutador 12 = 10000

Conmutador  2 = 4    Conmutador 11 = 4000
Conmutador  1 = 2    Conmutador 10 = 2000
Conmutador  0 = 1    Conmutador  9 = 1000

Adicionalmente, en la parte inferior izquierda contamos con un panel de control, que tiene botones de presión y conmutadores dobles. Su uso es sencillo y potente:

Botón LOAD ADDR: Carga la dirección en memoria solicitada.
Botón EXAM: Carga el registro desde la dirección de memoria indicada en el registro de direcciones.
Botón CONT: Continua el proceso desde una parada HALT.
Conmutador ENABLE/HALT: Si está en ENABLE permite correr (ejecutar) las instrucciones y rutinas programadas en la pila de memoria en el procesador, y está en HALT detiene el procesamiento de instrucciones y aguarda para el ingreso o revisión de datos.
Botón START: Pone a cero el sistema e inicia el procesado de las instrucciones en la pila de memoria.
Botón DEP: Deposita (escribe) los contenidos de los conmutadores de datos en la localización de memoria indicada por el registro de direcciones.


Ejemplos simples de operación
Podremos utilizar el panel de la PDP-11/40 para realizar operaciones de ejemplo y estudiar su empleo (aunque "cuelguen" la máquina virtual).

En primer lugar pondremos el conmutador Enable/Halt en HALT para pausar la ejecución del sistema (en una PDP-11 en funcionamiento, esto provoca que se ignore el uso de los demás conmutadores de datos). Podremos avanzar a pasos a lo largo del bucle de código, presionando CONT. Si lo deseásemos, podríamos continuar con la ejecución de las instrucciones en la pila de memoria, poniendo el conmutador Enable/Halt en ENABLE y presionando CONT nuevamente. Ahora detengamos la máquina nuevamente al procesador con HALT, y examinemos una dirección de memoria. Solicitamos una dirección de memoria cualquiera con los conmutadores de control en octales, y luego presionamos LOAD ADRS para cargar la dirección en memoria. Luego de eso, puede presionar EXAM varias veces, para ver el registro representarse con los indicadores luminosos del panel ADDRESS.

Para almacenar algo en la memoria (o "depositar", como se decía entonces), hemos de indicar primero una dirección con los conmutadores de control, y luego presionar LOAD ADRS. Se verá en el panel ADDRESS. Ingresemos alguna información, y luego presione el botón DEP. El registro binario se escribirá a la dirección de memoria dada y se presentará en el panel DATA. Podremos luego cambiar los conmutadores de control, a fin de cambiar la información binaria; si presionamos DEP nuevamente se escribirán las celdas de memoria contigua siguiente (de modo que no tenemos que indicar la dirección de memoria con cada paso, sólo con el primero y los registros que se ingresen a continuación se irán almacenando en las celdas de memoria contiguas subsiguientes de forma automática).

Si analizamos la pantalla de la consola de SimH, veremos que en ella se reflejarán todas las operaciones realizadas a través del panel frontal de la PDP-, 11/40, con la siguiente sintaxis:

deposit dirección_de_memoria registro
examine dirección_de_memoria

Indudablemente, hemos de tener presente que la mera acción de almacenar datos en las celdas de memoria de nuestra PDP-11/40 sin ton ni son, y sin tener el mas breve conocimiento de que estamos haciendo sólo arruinará el sistema operativo, hasta que reseteemos nuestra PDP-11 virtual.

Programa en Ensamblador
Pues bien, luego de destruir el sistema operativo RT-11SJ, será tiempo para un trabajo más constructivo. Para ello podremos utilizar el panel de la PDP-11/40 a fin de cargar un programa (una secuencia de códigos de operación o nemónicos de lenguaje ensamblador). El lenguaje ensamblador está formado por los códigos más básicos del microprocesador KB11 de la PDP-11, y nos permite crear programas bastante potentes operando directamente sobre el microprocesador y la memoria.

En este pequeño ejemplo, almacenaremos a partir de la dirección 001000 en la pila de memoria, un programa "Simulador Doctrinario de Peronismo", pensado para correr en la PDP-11 y mostrarnos su resultado en el panel frontal de la PDP-11... este programa nos permitirá entender el devenir ideológico de nuestro movimiento.

El listado en el ensamblador sería:

;***Programa "Simulador Doctrinario de Peronismo" en ensamblador para PDP-11***
;Dirección Datos  Nemónicos (opcodes)
001000    005000  clr       r0
001002    005200  inc       r0
001004    006100  rol       r0
001006    000005  reset
001010    000775  br        001004

   

Como vemos, son seis instrucciones. Para ingresar este programa de seis pasos mediante el panel, debemos utilizar los conmutadores de la PDP-11 e ingresar los datos (registros) en las direcciones de memoria correspondiente (iniciando desde 001000).

Básicamente, habremos de detener el equipo poniéndolo en HALT, ingresar en octal 001000, y presionar LOAD ADRS para indicar al puntero esa posición de memoria. Ingresaremos los registros en octales (los valores de los octales se suman para lograr el valor deseado). Con cada valor, ingresado, debemos presionar el botón DEP para depositarlos en memoria a en la dirección 001000 y subsiguientes...

Como no todos dominan la conversión a octales, el calidad de Conductor del Justicialismo os diré cómo ingresar los registros directamente de este programa "Simulador Doctrinario de Peronismo" en el panel de la PDP-11. Habrán de:
  • bajar todos los conmutadores, levantar el conmutador 9 (para el octal 001000) y apretar LOAD ADRS
  • bajar todos los conmutadores, levantar los conmutadores 11 y 9 (para el octal 005000) y apretar DEP
  • bajar todos los conmutadores, levantar los conmutadores 11, 9 y 7 (para el octal 005200), y presionar DEP
  • bajar todos los conmutadores, levantar los conmutadores 11, 10 y 6 (para el octal 006100), y presionar DEP
  • bajar todos los conmutadores, levantar los conmutadores 2 y 0 (para el octal 000005), y presionar DEP
  • bajar todos los conmutadores, levantar los conmutadores 8, 7, 6, 5, 4, 3, 2 y el 0 (para el octal 000775), y presionar DEP

Una vez depositados así todos los registros en memoria, será buena práctica examinar toda la pila de instrucciones del programa recientemente ingresada con el botón EXAM, pues al convertir los dígitos en octales a posiciones de los conmutadores del panel, podríamos cometer errores fácilmente. Como dato, tengamos en cuenta que el bus de 18 bits de la PDP-11/40 permitía una dirección más alta de memoria de 777776.

Para correr el programa:

  1. Debemos poner el conmutador HALT/ENABLE en ENABLE, para permitir continuar la ejecución de programas en la PDP-11.
  2. Ingresar la dirección del programa, en este caso en el panel DATA ponemos el octal 001000 (bajando todos los conmutadores, levantar el conmutador 9, y presionando LOAD ADRS.
  3. Presionar el botón START para correr el programa.
Este programa Simulador Doctrinario de Peronismo debería mostrarnos una sola luz en el panel DATA, que - siguiendo la práctica ideológica de nuestro Movimiento - se desplazará de izquierda a derecha, para luego volver a aparecer por izquierda y repetir el ciclo ad infinitum...

Para ello, el programa está usando el nemónico (opcode) "reset": Este nemónico inicializa todos los dispositivos, requiriendo para ello 70 milisegundos (1/14 de segundo). En este intervalo, el contenido del registro R0 de la Unidad Central de Proceso se muestra en el panel DATA de LEDs.

Si quisiéramos obtener un contador binario en lugar de una luz que se desplaza, podemos reemplazar la línea:

001004  006100  rol  r0; Conmutadores de datos=006100, DEP

...por esta otra línea:

001004  005200  inc  r0; Conmutadores de datos=005200, DEP

Naturalmente, si queremos conocer más nemónicos para programar ensamblador de la PDP-11, podremos encontrar su conjunto de instrucciones aquí. El conocimiento de estos nemónicos (opcodes) nos permitirá programar, con cierta lógica y volcado matemáticos, diferentes programas y aplicaciones simples o complejas. Por ejemplo, podríamos escribir un programa en ensamblador que nos resuelva la incógnita  n*(n+1)/2 resuelta por el joven Gauss, pero para cualquier número que se nos ocurra.

Os indicaré el listado puro en ensamblador, y las instrucciones para introducirlo y utilizarlo con el parco panel frontal de la PDP-11/40.


;*** LISTADO DE PROGRAMA ***
; Programa de ensamblador para PDP-11/40.
; Este programa lee >=0 desde la consola, suma el primer n no negativo,
; integra, se detiene y muestra el resultado en la consola.
; La suma resulta ser n*(n+1)/2, que no cabe en una WORD de memoria para
; n=361, el resultado es > 2^16 y entra en una WORD de memoria.
; El registro R1 contienen la suma.
; El registro R0 cuenta de 1 a R2.
; Este programa requiere una PDP-11/40. Al hacer HALT muestra R0 en los LED "DATA"
; En máquinas QBus (LSI11, 11/23, '53, '73, '93), el
; switch/display register 177570 is not implemented,
; resulting in a trap (UNIBUS timeout)
12                               
13 177570                    sr    =    177570    ; cambio de registro
14                          
15                               .asect
16 001000                        .=1000        ; el programa se carga en 1000
17                               
18                             start:
19 001000 013702  177570           mov    @#sr,r2 ; r2 = n (lee n desde el cambio de registro)
20 001004 005000                   clr    r0        ; r0 = 0 ; // contador
21 001006 005001                   clr    r1        ; r1 = 0 ; // suma
22                             loop:        ; hace {
23 001010 005200                   inc    r0        ;   r0++ ;
24 001012 060001                   add    r0,r1    ;   r1 += r0 ;
25 001014 020002                   cmp    r0,r2    ; } en tanto  (r0 != r2) ;
26 001016 001374                   bne    loop
27                               
28                             disp:
29 001020 010100                   mov    r1,r0    ; muestra la suma. Desbordará si el input es >361.
30 001022 000000                   halt        ; El OPR debe presionar conmutador CONTINUE ahora!
31                               
32 001024 000765                   br    start    ; ejecuta el programa nuevamente
***FIN DE PROGRAMA***


Fase 1 - Preparación

- Poner todos los conmutadores en posición normal "0".
- Poner el conmutador HALT/ENABLE en HALT.
- Power en ON.
- Realizar test de lámparas.

 

Fase 2 - Ingreso de los registros.

Paso 2.1

 Qué hacer: Inicializar la dirección actual en 001000
 Cómo: Ponga todos los conmutadores ABAJO, luego en 9 ARRIBA. Luego presione LOAD ADRS.
 Revisar: Panel de luces =

         _ ___ __ __ ___ __ __ ___ __ __ ___ __ __ ___ __ __ _ 
ADDRESS [_._|_.__.__._|_.__.__O_|_.__.__._|_.__.__._|_.__.__._]
         15  14 13 12  11 10  9   8  7  6   5  4  3   2  1  0 

 

Paso 2.2
 Qué hacer: Completar la dirección de memoria 001000 con el registro 013702
 Cómo: Poner todos los conmutadores ABAJO, luego los conmutadores 12,10-6, y 1 ARRIBA. Luego presionar DEP.
 Revisar: Panel de luces =

         _ ___ __ __ ___ __ __ ___ __ __ ___ __ __ ___ __ __ _ 
ADDRESS [ . | .  .  . | .  .  O | .  .  . | .  .  . | .  .  . ]
   DATA [_._|_.__.__O_|_.__O__O_|_O__O__O_|_.__.__._|_.__O__._]
         15  14 13 12  11 10  9   8  7  6   5  4  3   2  1  0 

 

Paso 2.3  
 Qué hacer: Completar la dirección 001002 con el registro 177570
 Cómo: Poner todos los conmutadores ABAJO, luego los conmutadores 15-8,6-3 ARRIBA. Luego oprimir DEP.
 Revisar: Panel de luces =     

         _ ___ __ __ ___ __ __ ___ __ __ ___ __ __ ___ __ __ _ 
ADDRESS [ . | .  .  . | .  .  O | .  .  . | .  .  . | .  O  . ]
   DATA [_O_|_O__O__O_|_O__O__O_|_O__.__O_|_O__O__O_|_.__.__._]
         15  14 13 12  11 10  9   8  7  6   5  4  3   2  1  0 

 

Paso 2.4
 Qué hacer: Completar memoria en la dirección 001004 con el registro 005000
 Cómo: Poner todos los conmutadores ABAJO, luego los conmutadores 11,9 ARRIBA. Luego oprimir DEP.
 Revisar: Panel de luces =

         _ ___ __ __ ___ __ __ ___ __ __ ___ __ __ ___ __ __ _ 
ADDRESS [ . | .  .  . | .  .  O | .  .  . | .  .  . | O  .  . ]
   DATA [_._|_.__.__._|_O__.__O_|_.__.__._|_.__.__._|_.__.__._]
         15  14 13 12  11 10  9   8  7  6   5  4  3   2  1  0 

 

Paso 2.5
 Qué hacer: Completar memoria en la dirección 001006 con el valor 005001
 Cómo: Poner todos los conmutadores ABAJO, luego los conmutadores 11,9,0 ARRIBA. Luego oprima DEP.
 Revisar: Panel de luces =

         _ ___ __ __ ___ __ __ ___ __ __ ___ __ __ ___ __ __ _ 
ADDRESS [ . | .  .  . | .  .  O | .  .  . | .  .  . | O  O  . ]
   DATA [_._|_.__.__._|_O__.__O_|_.__.__._|_.__.__._|_.__.__O_]
         15  14 13 12  11 10  9   8  7  6   5  4  3   2  1  0 

 

Paso 2.6  
 Qué hacer: Completar memoria en la dirección 001010 con el valor 005200
 Cómo: Poner todos los conmutadores ABAJO, luego los conmutadores 11,9,7 ARRIBA. Luego oprimir DEP.
 Revisar: Panel de luces =

         _ ___ __ __ ___ __ __ ___ __ __ ___ __ __ ___ __ __ _ 
ADDRESS [ . | .  .  . | .  .  O | .  .  . | .  .  O | .  .  . ]
   DATA [_._|_.__.__._|_O__.__O_|_.__O__._|_.__.__._|_.__.__._]
         15  14 13 12  11 10  9   8  7  6   5  4  3   2  1  0 

 

Paso 2.7
 Qué hacer: Completar memoria en la dirección 001012 con el valor 060001
 Cómo: Poner todos los conmutadores ABAJO, luego los conmutadores 14-13,0 ARRIBA. Luego oprima DEP.
 Revisar: Panel de luces =

         _ ___ __ __ ___ __ __ ___ __ __ ___ __ __ ___ __ __ _ 
ADDRESS [ . | .  .  . | .  .  O | .  .  . | .  .  O | .  O  . ]
   DATA [_._|_O__O__._|_.__.__._|_.__.__._|_.__.__._|_.__.__O_]
         15  14 13 12  11 10  9   8  7  6   5  4  3   2  1  0 

 

Paso 2.8
 Qué hacer: Completar memoria en la dirección 001014 con el valor 020002
 Cómo: Poner todos los conmutadores ABAJO, luego los conmutadores 13,1 ARRIBA. Luego oprima DEP.
 Revisar: Panel de luces =

         _ ___ __ __ ___ __ __ ___ __ __ ___ __ __ ___ __ __ _
ADDRESS [ . | .  .  . | .  .  O | .  .  . | .  .  O | O  .  . ]
   DATA [_._|_.__O__._|_.__.__._|_.__.__._|_.__.__._|_.__O__._]
         15  14 13 12  11 10  9   8  7  6   5  4  3   2  1  0 


Paso 2.9
 Qué hacer: Completar memoria en la dirección 001016 con el valor 001374
 Cómo: Poner todos los conmutadores ABAJO, luego los conmutadores 9,7-2 ARRIBA. Luego oprima DEP.
 Revisar: Panel de luces =    

         _ ___ __ __ ___ __ __ ___ __ __ ___ __ __ ___ __ __ _ 
ADDRESS [ . | .  .  . | .  .  O | .  .  . | .  .  O | O  O  . ]
   DATA [_._|_.__.__._|_.__.__O_|_.__O__O_|_O__O__O_|_O__.__._]
         15  14 13 12  11 10  9   8  7  6   5  4  3   2  1  0 

 

Paso 2.10
 Qué hacer: Completar memoria en la dirección 001020 con el valor 010100
 Cómo: Poner todos los conmutadores ABAJO, luego los conmutadores 12,6 ARRIBA. Luego oprima DEP.
 Revisar: Panel de luces =

         _ ___ __ __ ___ __ __ ___ __ __ ___ __ __ ___ __ __ _
ADDRESS [ . | .  .  . | .  .  O | .  .  . | .  O  . | .  .  . ]
   DATA [_._|_.__.__O_|_.__.__._|_.__.__O_|_.__.__._|_.__.__._]
         15  14 13 12  11 10  9   8  7  6   5  4  3   2  1  0 

 

Paso 2.11
 Qué hacer: Completar memoria en la dirección 001022 con el valor 000000
 Cómo: Poner todos los conmutadores DOWN. Luego levante DEP.
 Revisar: Panel de luces =

         _ ___ __ __ ___ __ __ ___ __ __ ___ __ __ ___ __ __ _
ADDRESS [ . | .  .  . | .  .  O | .  .  . | .  O  . | .  O  . ]
   DATA [_._|_.__.__._|_.__.__._|_.__.__._|_.__.__._|_.__.__._]
         15  14 13 12  11 10  9   8  7  6   5  4  3   2  1  0 


Paso 2.12
 Qué hacer: Completar memoria en la dirección 001024 con el valor 000765
 Cómo: Poner todos los conmutadores ABAJO, luego los conmutadores 8-4,2,0 ARRIBA. Luego oprima DEP.
 Revisar: Panel de luces =

         _ ___ __ __ ___ __ __ ___ __ __ ___ __ __ ___ __ __ _
ADDRESS [ . | .  .  . | .  .  O | .  .  . | .  O  . | O  .  . ]
   DATA [_._|_.__.__._|_.__.__._|_O__O__O_|_O__O__._|_O__.__O_]
         15  14 13 12  11 10  9   8  7  6   5  4  3   2  1  0 


Fase 3 - Verificar los datos


Pasos 3.1 - 3.12
 Qué hacer: Leer cada dirección de memoria ingresada y verificar los registros.
 Cómo: Repetir pasos 2.1. - 2.12., pero presionar EXAM en lugar de DEP.
 Revisar: Los patrones de luces deben ser como los ilustrados.

Fase 4 - Control de Programa

Paso 4.1 
 Qué hacer: Poner el punto de inicio del programa en dirección 001000.
 Cómo: Poner todos los conmutadores ABAJO, poner conmutador 9 ARRIBA. Presionar LOAD ADRS.
 Revisar: Panel de luces =

         _ ___ __ __ ___ __ __ ___ __ __ ___ __ __ ___ __ __ _ 
ADDRESS [_._|_.__.__._|_.__.__O_|_.__.__._|_.__.__._|_.__.__._]
         15  14 13 12  11 10  9   8  7  6   5  4  3   2  1  0 

 

Paso 4.2  
 Qué hacer: Comenzar el programa con argumentos.
 Cómo: Configurar ENABLE/HALT en la posición ENABLE.
       Configurar los conmutadores de control de datos como se desee..
       Presionar el botón START.
 Revisar: El indicador RUN se encenderá.
          Si el programa se detiene al presionar HALT, el indicador RUN se apagará nuevamente.

Paso 4.3
 Qué hacer: Detener el programa, avanzar un paso, y continuar procesando.
 Cómo: Para detener la ejecución del programa, poner el conmutador ENABLE/HALT en HALT.
 Revisar: El indicador RUN se apagará.
 Cómo: Para avanzar un solo paso, dejar el conmutador ENABLE/HALT en HALT, y presionar CONT para cada paso del programa.
 Cómo: Para comenzar la ejecución del programa, poner conmutador ENABLE/HALT en ENABLE.
 Revisar: El indicador RUN se encenderá.


Si queremos usar UNIX V6 en la PDP-11/40: 
Usamos los comandos: 


cd ~/.simh/panelsim/
sudo ./pdp1140_unixv6.sh

Cuando aparezca el prompt "@", ingresamos rkunix
Nos logueamos como root, sin contraseña
En el prompt de Unix "#", ingresamos "stty -lcase" para poder usar minúsculas.

No hay comentarios:

Publicar un comentario