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.

miércoles, 24 de junio de 2015

¿Cómo emulo el panel de una mainframe DEC PDP-10 en Ubuntu de 64 bits?

¡Trabajadores!

En Movimientos como el nuestro, no serán pocas las ocasiones en las que habremos de cubrir con chimichurri al sapo. Y esto, que tan cierto es en la política, también lo es en los sistemas informáticos.

Vean señores, los mejores sistemas informáticos de antaño en realidad sólo disponían de una fracción de la potencia que cada uno de nosotros tiene en su más lelo de los dispositivos informáticos, pero sin duda contaban con algo que luego se hizo caro: la libertad.

Esto significa que - en aras del estudio y la lúdica - podamos emularlos hoy con muy poco costo computacional. Pero emplear un sistema moderno para las tareas de ayer deja de tener gracia, en tanto que no contamos con los enormes y costosos sistemas que otrora pululaban los centros de cómputo.

Uno de ellos era la mainframe DEC PDP-10, de 36 bitios. Disponible en diferentes modelos, inicialmente transistorizada y con su memoria núcleo, pasó luego a emplear unidades de de cinta magnética o disco como medio de almacenamiento de masa. Se hizo popular entre 1968 y 1983 como equipo primigenio de estudio para las tecnologías que actualmente empleamos.Este equipo fue el lugar de nacimiento de la Internet y el movimiento de Software Libre, así como muchas aplicaciones de software, como Emacs, TeX, numerosos dialectos de LISP, el correo electrónico, y Kermit. La configuración típica de PDP-10 incluia múltiples gabinetes de tamaño completo para la CPU, memoria, controladores, cinta magnética, infraestructura de redes, junto con discos rígidos de tamaño de un lavarropas, impresoras de línea, y demás, requiriendo habitaciones con aire acondicionado e instalación trifásica.
Las versiones más deseadas por la Masa estaban munidas de una consola de entrada/salida (lo que hoy denominaríamos unidad central de proceso) del modelo KI10, corriendo el sistema operativo TOPS-10.
La consola KI10 oficiaba de unidad de mando para inicializar el sistema y también se la podía emplear para consultar a través de sus indicadores luminosos el contenido de las direcciones individuales de la memoria (que se conectaba por separado). Por medio de las teclas retroiluminadas se podían manipular los acumuladores de memoria núcleo, cargando diferentes instrucciones de operación a través de su código binario, y llamando a las mismas para realizar programas en el macro-ensamblador nativo de la máquina, el Macro-10.

Estos dispositivos no estaban al alcance de la Masa Popular hecha partido, pero hoy, gracias al Justicialismo, os diré cómo cargar un emulador de dicho equipo en nuestro sistema GNU con Linux.

En primer lugar hemos de instalar los paquetes necesarios para poder emular todo en nuestro sistema Ubuntu de 64 bits. Para ello abrimos una terminal Linux con Ctrl+Alt+T 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.

Ahora podremos ejecutar el emulador con los siguientes comandos:


cd ~/.simh/panelsim/

sudo ./pdp10ki10_tops10.sh

Esta orden nos pedirá que introduzcamos nuestra contraseña de Conductor, y tras ello, debería presentarnos una ventana con una reproducción fotográfica de la consola DEC KI10, en estado "Apagado".
Casi instantáneamente, el procedimiento automatizado dará arranque al emulador y lo conectará con la consola de luces KI10. En la ventana de la consola KI10 se deberá encender la luz roja Active indicando que tenemos vinculadas ambas máquinas virtuales, y en su panel retroiluminado debería encenderse automáticamente en blanco el pulsador Power, así como su indicador rojo en la consola KI10. Para poder iniciar un sistema operativo cualquiera, revisamos que en el panel nomenclado STOP de la consola esté en la opción MAN, tanto como el indicador de Datos en Memoria ("Data Memory") debería presentarse encendido:

...a su vez, la pantalla de la terminal de video debería informarnos siguiente:

Se nos presentará entonces el prompt del emulador:

BOOT V3(47)

...y nos mostrará:

BOOT>

(Presionamos Enter una vez debería mostrar:.
[Loading from DSKB:BOOT.EXE[1,4]

Why Reload? opr
Date: 10-14-99 (o similar)

Time: 19:54  (o similar)

Startup Option: quick
Esto indicará que el operador de sistema ("opr") desea reiniciar la secuencia de arranque del sistema operativo (en otras palabras reencender la PDP-10 y dar inicio al sistema operativo), y hacerlo de manera veloz. Mientras tanto, podremos comprobar como se parpadean las luces de los bancos de memoria de la consola KI10:
Al terminar, podría presentarnos el prompt del sistema operativo TOPS-10 (un simple punto).
Normalmente no responderá a ningún comando hasta que nos demos de alta (logueemos al sistema multiusuario). Ello nos será indicado de la siguiente manera:

?LOGIN please
    .

*


Pues bien, podremos loguearnos como usuario invitado (public) o como superusuario. Para loguearnos como usuario simple podemos poner:

*login public

(Para loguearnos como superusuario se usa login 1,2 (y la contraseña, eventualmente, será mcp)
Podríamos pedir un listado de programas con el comando

dir

Podremos ver una pequeña guía de uso a través del programa help, y para ver una ayuda de todos los comandos utilizables, podremos indicar la opción *:

help *

Para cerrar la sesión podremos usar:

kjob

Para poder programar en Basic se podía usar el comando ejecutar (r), de la siguiente manera:

r basic

Entonces el prompt cambiará para indicarnos que estamos en modo BASIC.

Simplemente podremos escribir los comandos en dicho lenguaje. Para volver al sistema podemos usar ... o el comando system.

Para eliminar todos los procesos activos, podremos usar:

:kill all

El sistema TOPS-10 es muy completo a pesar de su obsolescencia, y fue piedra basal para nuevos sistemas que lo seguirían, entre ellos UNIX e incluso implementaciones para microodenadores, como el CP/M de la Int€rgalactic Digital Re$earch. Podremos encontrar un conjunto de manuales aquí. instrucciones completas en el Manual del operador de TOPS-10.

Para encontrarnos con una pequeña guía del panel KI10, podremos encontrarla en la web oficial aquí. Utilizando el panel, podremos programar en ensamblador de la máquina, el obtuso lenguaje DEC MACRO10.

Jugar el juego Adventure:
Adventure fue el primerísimo de los juegos del género de aventuras de texto computadas, y nos presentaba una serie de opciones para seguir en un relato en primera persona, de viaje y descubrimiento. Para poder utilizarlo en la PDP10 emulada nos logueamos como usuario público, e ingresamos el comando:

r dsk:adv

Jugar DECWAR en la PDP-10:
DECWAR 2.3 es un juego de guerra espacial multiusuario del género StarTrek, que opera en tiempo real. Fue diseñado en 1979 para ser utilizado por hasta una decena de operadores en el mainframe DEC-10 dotado del sistema operativo TOPS-10. Para instrucciones sobre cómo jugar, podremos consultar este archivo.

cd ~/.simh/panelsim/pdp10ki10/ ;
wget http://repositories.lib.utexas.edu/bitstream/handle/2152/13510/decwar_drforbin_cis2_tops10_port-2.3.tap ;

En el simh:

sim>att rp2 decwar_drforbin_cis2_tops10_port-2.3.tap

Y lo inicializamos como de costumbre:

sim>boot rp

boot>boot

viernes, 5 de junio de 2015

¿Cómo puedo ver peliculas a través de cable HDMI en mi Lenovo B50-30 con Ubuntu 14.04 MATE?


¡Trabajadores!

Como Conductor, conozco al dedillo todos los aspectos del Movimiento. Esto radica un esfuerzo de estudio y planificación que acerca a las Masas Obreras a su verdadero objetivo: el de lograr la máxima felicidad para el Pueblo Argentino.

Para obtener el máximo rendimiento de un sistema informático, hemos también de conocer sus ventajas y sus inconvenientes, y dominar los últimos con las herramientas que tengamos a mano.
La conexión HDMI presenta ciertas ventajas. Entre ellas, permite transmitir imagen y audio a través de un enlace digital sin pérdida de calidad. Se ha impuesto como estándar, y nos permite presentar en pantalla lo que vemos en nuestro sistema, o actuar como un "segundo escritorio".

Normalmente funcionará sin problemas "desde fábrica" en Ubuntu MATE 14.04LTS. Con sólo conectar el equipo a un televisor externo por medio de un cable HDMI, podremos ver una imagen de un segundo escritorio, "a la derecha" de nuestra pantalla de la portátil. Idealmente, debemos conectar el cable con la portátil apagada y el monitor externo encendido, aunque dependiendo del monitor externo, podría funcionar bien si lo conectamos con el equipo encendido. Debería autoconfigurarse las salidas de video.

Simplemente podremos "arrastrar" ventanas a dicho monitor "arrastrando" hasta el límite derecho de la pantalla de nuestro sistema portátil. Podremos así dejar en el televisor externo, una ventana de un reproductor como VLC o Totem con alguna película, presentación, etc. Este es el modo de "escritorio compartido" por defecto, y se configura solo.

Si quisiéramos otro esquema (por ejemplo, el de "espejo de video", podremos ir a Sistema / Preferencia / Monitores. El sistema debería permitirnos ver el monitor externo. Si tildamos "la misma imagen en los dos monitores" dejaremos de tener el escritorio extendido, y veremos lo mismo en ambas pantallas. Sin embargo, debemos tener en cuenta que si el monitor externo tiene mas resolución que nuestra portátil (que normalmente tiene 1366x768 pixels), podríamos requerir modificar los parámetros de dicho monitor o TV para ver a pantalla completa.



Una de las condiciones que podemos encontrar, es que el sonido se haga presente a través de los altavoces de la portátil en lugar del televisor externo. Vean señores, esta es una situación común, y debe configurarse a través de las Propiedades de Sonido. Para ello, habrán hacer clic en el icono del altavoz (localizado en el panel superior), y escoger "Sound Setting...".
Esta acción desplegará el cuadro Propiedades de Sonido, que nos permitirá configurar este aspecto en nuestro Ubuntu. Debemos indicar que queremos que la salida de audio se realice a través de la TV, a través de la conexión HDMI. Para ello, elegimos la solapa Hardware.
Una vez en dicha solapa, a través el desplegable Perfil nos encontraremos con las diferentes opciones de salida para nuestro adaptador de audio. Normalmente el sistema está configurado para que el sonido salga por los altavoces de la portátil o la salida de auriculares, a través de la opción Perfil: Estéreo Analógico Dúplex (como se muestra en la figura). Ahora bien, para que el sonido se reproduzca a través de los altavoces del televisor conectado a través del cable HDMI, hemos de elegir el Perfil: Digital Stereo (HDMI) Salida + Estéreo Analógico Entrada.

(Nota: Si en cambio disponemos de un sistema digital Home Theatre 5.1, conectado a la portátil o al Televisor Externo, podremos asignar dicha opción para escuchar el sonido a través de los seis altavoces de dichos equipos).

Indudablemente que para que la película se vea en la TV, debe "arrastrarse" con el mouse la ventana de la película hacia la derecha, por fuera del borde de la pantalla de la notebook, para que aparezca en el televisor.

Una vez vista la película y hayamos desconectado el cable HDMI, se debe volver a poner el Perfil de sonido en Estéreo Analógico Dúplex para que el sonido vuelva a salir por los parlantes de la computadora.


Otro de los inconvenientes puede darse si utilizamos Ubuntu 14.04LTS MATE con el gestor de ventanas Compiz en la portátil Lenovo B50-30 dotada de un adaptador de video Intel HD. El inconveniente que se presentará es que al conectar un cable HDMI al equipo, la imagen en la pantalla de la portátil se verá de manera "dividida" horizontalmente y descolocada, y no mostrará video alguno en la pantalla externa.

Este error se debe a un problema de compatibilidad de Compiz con el entorno de escritorio MATE junto con las opciones de múltiples monitores. De momento, para utilizar el sistema HDMI, conviene entonces desactivar el Compiz y utilizar el gestor de ventanas por defecto de MATE, el Marco.

Para desactivar entonces Compiz en MATE, abrimos una terminal con Ctrl+Alt+T e ingresando:

sudo gsettings reset org.mate.session.required-components windowmanager

Esto nos presentará con el sistema visual por defecto, llamado Marco, no bien reiniciemos la sesión. Podremos reiniciar entonces el sistema con:

sudo reboot

Si por algún motivo, quisiéramos retornar al ambiente de escritorio Compiz, podremos hacerlo ingresando el siguiente comando en la Terminal, para luego reiniciar:

sudo apt-get purge compiz compiz-plugins-default compiz-plugins compizconfig-settings-manager