lunes, 5 de septiembre de 2016

Preservación de máquinas (XI): Libro del Kentelec-8 en la biblioteca de la UPV

 Índice de entradas de Preservación de máquinas 
Colabora con el proyecto: Simplemente haz click de vez en cuanto en los anuncios, no te cuesta nada y me ayudas con los costes del proyecto. Cada 11 click aportas un euro.


En la biblioteca de la Universidad Politécnica de Valencia disponen de uno de los manuales del Kentelec-8. Con los cambios de exámenes, ahora cierran en Agosto, por lo que hasta la última semana del mes no he podido ir a verlo.

Tras las expectativas y la espera, la decepción, por desgracia es solo el Manual de Programación que apenas habla del aparato, solo es un manual de programación del Intel 8008 en ensamblador, y hace referencia al manual del operador para eso.

Portada


Índice

Disponen de dos ejemplares, aunque solo he visto uno de momento. Este tiene fecha de edición de 1975. Los sellos indican que el aparato se adquirió para la biblioteca central en 1977, y que pasó en 1984 a la biblioteca de la actual escuela de Arquitectura técnica, que lo devolvió a la central posteriormente, y está en el depósito ya que nadie lo consulta nunca. Aunque lo han mirado muy amablemente, en esa época los registros eran manuales y ya no están disponibles, por lo que no hay forma de saber quien solicito el libro ni de que departamento era, con esa información podría ir a ese departamento a preguntar si saben algo, o si sabes el profesor que lo pidió lo puedes intentar localizar, aunque esté jubilado.

Al ser un manual de programación en código máquina general del Intel 8008, lo mas probable es que no se comprara para el aparato, pues en ese caso tendrían también el manual de operador, seguramente se compraría como manual de programación al ser el único en español del mercado.

Esquema del aparato


Muestra del texto
Manejo de Interrupciones

Se que los dos manuales están en la Biblioteca Nacional de España, ya que aparecen en su catálogo, tendré que ir expresamente algún día a buscarlos, o solicitar fotocopias o escaneados del manual de operador, que es el que de momento me proporcionaría información importante para su reproducción, como el saber para que sirven todos los interruptores por ejemplo.

Tras Agosto y unos días de descanso y de viaje, retomaré el proyecto y a ver si consigo avanzar un poco mas en este aparato.

lunes, 8 de agosto de 2016

Preservación de máquinas (X): Esquemas del Kenbak-1

 Índice de entradas de Preservación de máquinas 
Colabora con el proyecto: Simplemente haz click de vez en cuanto en los anuncios, no te cuesta nada y me ayudas con los costes del proyecto. Cada 11 click aportas un euro.


En unos días de vacaciones me he dedicado a crear en Eagle los esquemas del Kenbak-1, como paso para la duplicación de la placa. Lo que no parecía muy complicado, se ha liado un poco.

He estudiado hacerlo en KiCad, lo instalé y quise empezar a hacer algo, pero pero aprender a usar un nuevo programa no me ha apetecido mucho, además no podía hacer el esquema por páginas, y como ya manejo en Eagle, al final desistí y he usado Eagle para el diseño.

Primero he creado una nueva librería en la que he incluido todos los elementos de los esquemas, ya que algunos no coinciden con los que existen en las librerías normales, y al final he optado por poner todos los elementos. Como las librerías se duplican completas en los esquemas, cuando cambias algo hay que actualizarlas.

Luego he empezado a pasar los 25 esquemas en hojas de Eagle (tened en cuenta que la versión gratuita no soporta el manejo de hojas), salvo los de la fuente de alimentación externa, solo he puesto la parte que está en la placa, que es la fuente de -5 voltios que se generan a partir de la de -12 voltios.

Los esquemas los hicieron originalmente a mano, no para un programa de CAD Electrónico, por lo que he tenido algunos problemas. El primero fue sencillo, en los esquemas no aparecen las alimentaciones de los chips, por lo que las he tenido que añadir en cada hoja, si no Eagle se quejaba del tema.

El segundo ha sido mas difícil de solucionar bien, en los esquemas hay puertas de chips de las zonas que incluyen en ese chip, por lo que puede haber puertas de un chip en dos o hasta tres hojas del esquema. En Eagle esto no se soporta, debes poner las puertas del chip que uses siempre todas en la misma hoja del esquema. Por eso me ha tocado poner puertas en hojas diferentes, y luego poner solo las señales en la hoja original, marcando en un fondo de color los cambios efectuados. No es lo mas elegante, pero funciona bien para mantener la correspondencia al máximo con los esquemas originales. En el esquema 11 no me cabían todas las puertas, y he tenido que usar dos hojas para ponerlas todas.

Al final he conseguido pasar los esquemas, y los únicos errores que me ha generado Eagle son advertencias de falta de uso de algunas puertas de los chips.

Ejemplo de esquemas, este es la hoja 1.

Otro tema ha sido que las señales de los interruptores y las bombillas van de la placa al frontal, en el esquema no hay problema, pero yo he tenido que poner un elemento extra para que en la placa figuren las conexiones.

También he puesto un chip que no se usa realmente (el IC99 no tiene conexiones con otros elementos del circuito, pero está ubicado en la placa), los tres agujeros, que en Eagle hay que ubicarlos en los esquemas, y los condensadores de filtro de la alimentación, que no figuran en los esquemas, todo en la hoja 25, junto a la fuente de -5 voltios.

Con esto tengo la base para la placa, tras 10 días de trabajo he conseguido tener los esquemas sin errores, y me he puesto con la placa base. Ubicar los 132 chips, 47 resistencias,  23 condensadores, 9 diodos, 9 transistores, los 3 agujeros y los conectores de alimentación, bombillas e interruptores, de manera lo mas precisa posible, es laborioso ya que me tengo que basar en fotos de las placas, que tampoco son muy buenas, las que no tienen los componentes tienen mucha deformación trapezoidal, las que los tienen estos tapan cosas.

Se que mi reproducción de la placa no va a ser perfecta, ya que para ello debo disponer de una placa o mejores fotos, pero si muy parecida, tampoco es mi intención que sea idéntica, con que lo sea al 95% me sobra.

Este proceso es lento, hay que ubicar todos los componentes en su lugar lo mas aproximado posible, y además ubicar las vías que conectan las dos caras de la placa, la zona con fondo gris es la que me falta por ubicar.

Elementos ubicados en la placa.


Una vez complete el posicionamiento y la ubicación de los pads, tengo que trazar los circuitos, otro proceso laborioso ya que no son rectas sino curvas todas, y van por las dos caras, y las fotos no acompañan, pero con la referencia de fotos y las vías que Eagle me dice a partir de los esquemas, lo conseguiré.

Como punto a considerar la placa es muy grande ya que el tamaño que me sale es de 410x236mm (tener en cuenta que yo mido a partir de las fotos, contando que los pads de los chips tienen una distancia de 2'5mm entre ellos, por lo que tampoco puedo dar una medida igual a la original que no tengo, pero es lo que me sale), eso no se puede usar con la versión gratuita del Eagle tampoco.

miércoles, 20 de julio de 2016

Preservación de máquinas (IX): Nuevo Manual del Kenbak-1 Traducido

 Índice de entradas de Preservación de máquinas 
Colabora con el proyecto: Simplemente haz click de vez en cuanto en los anuncios, no te cuesta nada y me ayudas con los costes del proyecto. Cada 11 click aportas un euro.


Sigo con el Kenbak-1, aunque voy saltando de una a otra cosa un poco conforme tengo ganas, por eso sale un poco desordenador todo.

He traducido al español el manual de Instalación, Mantenimiento y Teoría de Operación del Kenbak-1, lo he tenido que consultar pues no estaba claro algún aspecto de programación definido en el Manual de Referencia de Programación.

Ahora estoy terminando el emulador, y a la vez pasando a Eagle los esquemas de la máquina, lo primero ha sido desarrollar una librería para los componentes, con los mismos símbolos y posiciones de pines descritos en el manual original, ya que los habituales de la serie 74 no se corresponden al 100%. Yo uso Eagle porque lo conozco y lo se manejar, aunque he probado con KiCad pero aprender otro programa no me motiva, ya estoy mayor, lo dejo para los expertos en ese programa.

Reproducir el esquema es el primer paso para intentar recrear la placa, lo que no será sencillo pues a partir de fotos de la misma costará bastante, pero poco a poco.

La lista de tareas es un poco larga todavía, poco a poco va a avanzando, en este momento me queda por desarrollar:

  • Emulador
    • Completar la operatividad cambiando la forma de temporizar, y poner unos botones de ajuste de velocidad.
    • Poder guardar y cargar programas
    • Desarrollo del ensamblador y desensamblador.
  • Manuales
    • Traducir el manual de prácticas, pero es muy largo y eso costará bastante mas tiempo
  • Reproducción con Arduino
    • Desarrollar la placa de control de pulsadores y luces
    • Desarrollar el programa del arduino
    • Desarrolalr una alimentación con pilas o baterias para que sea autónomo
    • Desarrollar una disquetera virtual con la memoria flash del arduino y poder guardar y cargar los programas de forma autónoma
    • Desarrollar el enlace entre el Arduino y el PC para intercambiar programas, ya sea por USB o por bluethoot
  • Reproducción de la placa
    • Pasar los esquemas a Eagle
    • Desarrollar la placa (proceso largo y laborioso a partir de los esquemas y las fotos)
    • Reproducir en CPLD los chips que ya no se consiguen
  • Reproducción de la caja
    • Desarrollar un prototipo de la caja en madera o plástico de 1mm
    • Desarrollar un prototipo del frontal en un vinilo
    • Desarrollar una caja en aluminio o chapa completa (proceso caro)

lunes, 18 de julio de 2016

Preservación de máquinas (VIII): Emulador Kenbak-1 Funcionando y Cambio en el Manual

 Índice de entradas de Preservación de máquinas 
Colabora con el proyecto: Simplemente haz click de vez en cuanto en los anuncios, no te cuesta nada y me ayudas con los costes del proyecto. Cada 11 click aportas un euro.


Primero, hay nueva versión del manual de referencia de programación, corregido un error en los saltos que por copiar y pegar de lo anterior no cambié la tabla de los tres últimos bits de las de modos de direccionamiento a la de condiciones de salto, y había un párrafo mal traducido en la parte de salto y marca, no estaba claro su funcionamiento, creo que ahora si.

Luego, ya tengo una versión operativa del aparato, esta es la nueva beta, no os preocupeis si el antivirus os dice que tiene un virus, es un falso positivo muy habitual en los ejecutables de Visual Basic. La máquina ya funciona, y tiene cargado en memoria el programita de pruebas que se incluye en el manual de referencia de programación, si pulsáis RUN viereis como las lámparas empiezan a contar.

No me acaba de convencer, ya que tras ejecutar una instrucción se queda en un bucle 1/4 de segundo para simular a velocidad de la máquina, y en ese tiempo no responde bien a las pulsaciones de botones, lo tengo que cambiar un poco usando un temporizador, que deja la máquina menos parada.

Al ejecutar, las casillas de la derecha van cambiando conforme se avanza, y se puede ver por ejemplo la instrucción que se va a ejecutar en texto, me faltaría cambiar la letra del modo de direccionamiento por la dirección real que usará, para que sea mas claro.

Me falta también poder ajustar la velocidad de la ejecución a gusto del usuario, no que se quede fijo a 1/4 de segundo por instrucción, la máquina real es complicado simularla a su velocidad pues depende de la memoria serie que usa principalmente, pero tampoco es el objetivo de este emulador, el objetivo es que sea claro de entender, y la rutina que ejecuta las instrucciones la he echo muy sencilla para que se entienda bien su funcionamiento.

A ver si pronto lo completo con estos cambios, dotándola de un modo paso a paso para poder seguir mejor los programas, añadir que se puedan meter datos en la memoria directamente, yañadiendo un ensamblador y desensamblador, para que sea mas sencilla de manejar.

Una vez completada pondré el código a disposición de todos, y ya me meto a la reproducción con Arduino del aparato.


martes, 12 de julio de 2016

Preservación de máquinas (VII): Emulador Kenbak-1 Manejo

 Índice de entradas de Preservación de máquinas 
Colabora con el proyecto: Simplemente haz click de vez en cuanto en los anuncios, no te cuesta nada y me ayudas con los costes del proyecto. Cada 11 click aportas un euro.


Ya está desarrollado el manejo del interface del aparato, creo que se comporta como el original, según lo que he visto en YouTube de uno funcionando:


Este segundo paso completa la operatoria, ahora me falta el simulador de la máquina en sí, junto a algunas ideas sobre un ensamblador y desensamblador.

Podéis probarlo en cualquier versión de Windows a partir de XP que disponga del Framework 2 en adelante. Es un ejecutable en un solo fichero, no necesita instalación. Descargar y funcionar.

Adelanto el conjunto completo de instrucciones que estoy montando, se aprecia que hay 16 instrucciones que se refieren todas a HALT y otras 16 instrucciones que son NOOP, esto es así pues solo mira los tres últimos bits de la instrucción para determinar las, y si son 000 entonces mira los dos primeros para ver si es HALT o NOOP. También hay un pequeño hueco entre la 203 y la 207 que no están definidas en el juego de instrucciones, tengo que investigar un poco mas que hacían.

El que existan 32 formas de indicar 2 instrucciones y 5 no definidas permiten ampliar el conjunto de instrucciones de la máquina, añadiendo hasta 35 nuevas instrucciones, además del truco de hacer que una instrucción indique solo que se extiende el juego de instrucciones, y el siguiente byte puede usarse para ampliar en otras 255 instrucciones. Yo de momento no voy a implementar nada de esto, voy a desarrollar la parte del emulador que me falta.

Se indica Código (Tamaño Formato) Instrucción
  • Código es el valor numérico en decimal de la instrucción
  • Tamaño indica el número de bytes que conforman la instrucción, puede valer 1 o 2
  • Formato indica el de la instrucción, y puede ser:
    • I: Operación
    • A: Operación Registro, Número
    • B: Operación Registro, Dato
    • C: Operación Número, Dato
  • Las operaciones permitidas son ADD, AND, HALT, JMD, JMI, JPD, JPI, LNEG, LOAD, NOOP, OR, ROTL, ROTR, SET0, SET1, SFTL, SFTR, SKP0, SKP1, STORE, SUB
  •  Los registros que se manejan son A, B y X
  • Número es un entero de 0 a 4 o de 0 a 8 máximo
  • Dato es el valor que se maneja en la instrucción y depende del modo de direccionamiento, puede ser:
    • c indica dato inmediato, se reemplaza por el contenido del siguiente byte
    • d indica dirección inmediata, se reemplaza por el contenido de la dirección indicada en siguiente byte
    • (d) indica dirección indirecta, se reemplaza por el contenido de la posición de memoria indicada por el contendió de la dirección indicada en siguiente byte
    • X+c indica dato indexado, se reemplaza por el contenido de la posición de memoria indicada por sumar a X (sin alterarlo) el siguiente byte
    • X+d indica dirección indexada, se reemplaza por el contenido de la posición de memoria indicada por sumar a X (sin alterarlo) el contenido de la dirección indicada en siguiente byte

000 (1I) HALT 064 (1I) HALT 128 (1I) NOOP 192 (1I) NOOP
001 (1B) SFTL A,4 065 (1B) ROTL A,4 129 (1B) SFTR A,4 193 (1B) ROTR A,4
002 (2C) SET0 0,d 066 (2C) SET1 0,d 130 (2C) SKP0 0,d 194 (2C) SKP1 0,d
003 (2A) ADD A,c 067 (2A) ADD B,c 131 (2A) ADD X,c 195 (2A) OR A,c
004 (2A) ADD A,d 068 (2A) ADD B,d 132 (2A) ADD X,d 196 (2A) OR A,d
005 (2A) ADD A,(d) 069 (2A) ADD B,(d) 133 (2A) ADD X,(d) 197 (2A) OR A,(d)
006 (2A) ADD A,X+c 070 (2A) ADD B,X+c 134 (2A) ADD X,X+c 198 (2A) OR A,X+c
007 (2A) ADD A,X+d 071 (2A) ADD B,X+d 135 (2A) ADD X,X+d 199 (2A) OR A,X+d
008 (1I) HALT 072 (1I) HALT 136 (1I) NOOP 200 (1I) NOOP
009 (1B) SFTL A,1 073 (1B) ROTL A,1 137 (1B) SFTR A,1 201 (1B) ROTR A,1
010 (2C) SET0 1,d 074 (2C) SET1 1,d 138 (2C) SKP0 1,d 202 (2C) SKP1 1,d
011 (2A) SUB A,c 075 (2A) SUB B,c 139 (2A) SUB X,c 203
012 (2A) SUB A,d 076 (2A) SUB B,d 140 (2A) SUB X,d 204
013 (2A) SUB A,(d) 077 (2A) SUB B,(d) 141 (2A) SUB X,(d) 205
014 (2A) SUB A,X+c 078 (2A) SUB B,X+c 142 (2A) SUB X,X+c 206 (1I) INVALID
015 (2A) SUB A,X+d 079 (2A) SUB B,X+d 143 (2A) SUB X,X+d 207 (1I) INVALID
016 (1I) HALT 080 (1I) HALT 144 (1I) NOOP 208 (1I) NOOP
017 (1B) SFTL A,2 081 (1B) ROTL A,2 145 (1B) SFTR A,2 209 (1B) ROTR A,2
018 (2C) SET0 2,d 082 (2C) SET1 2,d 146 (2C) SKP0 2,d 210 (2C) SKP1 2,d
019 (2A) LOAD A,c 083 (2A) LOAD B,c 147 (2A) LOAD X,c 211 (2A) AND A,c
020 (2A) LOAD A,d 084 (2A) LOAD B,d 148 (2A) LOAD X,d 212 (2A) AND A,d
021 (2A) LOAD A,(d) 085 (2A) LOAD B,(d) 149 (2A) LOAD X,(d) 213 (2A) AND A,(d)
022 (2A) LOAD A,X+c 086 (2A) LOAD B,X+c 150 (2A) LOAD X,X+c 214 (2A) AND A,X+c
023 (2A) LOAD A,X+d 087 (2A) LOAD B,X+d 151 (2A) LOAD X,X+d 215 (2A) AND A,X+d
024 (1I) HALT 088 (1I) HALT 152 (1I) NOOP 216 (1I) NOOP
025 (1B) SFTL A,3 089 (1B) ROTL A,3 153 (1B) SFTR A,3 217 (1B) ROTR A,3
026 (2C) SET0 3,d 090 (2C) SET1 3,d 154 (2C) SKP0 3,d 218 (2C) SKP1 3,d
027 (2A) STORE A,c 091 (2A) STORE B,c 155 (2A) STORE X,c 219 (2A) LNEG A,c
028 (2A) STORE A,d 092 (2A) STORE B,d 156 (2A) STORE X,d 220 (2A) LNEG A,d
029 (2A) STORE A,(d) 093 (2A) STORE B,(d) 157 (2A) STORE X,(d) 221 (2A) LNEG A,(d)
030 (2A) STORE A,X+c 094 (2A) STORE B,X+c 158 (2A) STORE X,X+c 222 (2A) LNEG A,X+c
031 (2A) STORE A,X+d 095 (2A) STORE B,X+d 159 (2A) STORE X,X+d 223 (2A) LNEG A,X+d
032 (1I) HALT 096 (1I) HALT 160 (1I) NOOP 224 (1I) NOOP
033 (1B) SFTL B,4 097 (1B) ROTL B,4 161 (1B) SFTR B,4 225 (1B) ROTR B,4
034 (2C) SET0 4,d 098 (2C) SET1 4,d 162 (2C) SKP0 4,d 226 (2C) SKP1 4,d
035 (2A) JPD A,c 099 (2A) JPD B,c 163 (2A) JPD X,c 227 (2A) JPD ,c
036 (2A) JPD A,d 100 (2A) JPD B,d 164 (2A) JPD X,d 228 (2A) JPD ,d
037 (2A) JPD A,(d) 101 (2A) JPD B,(d) 165 (2A) JPD X,(d) 229 (2A) JPD ,(d)
038 (2A) JPD A,X+c 102 (2A) JPD B,X+c 166 (2A) JPD X,X+c 230 (2A) JPD ,X+c
039 (2A) JPD A,X+d 103 (2A) JPD B,X+d 167 (2A) JPD X,X+d 231 (2A) JPD ,X+d
040 (1I) HALT 104 (1I) HALT 168 (1I) NOOP 232 (1I) NOOP
041 (1B) SFTL B,1 105 (1B) ROTL B,1 169 (1B) SFTR B,1 233 (1B) ROTR B,1
042 (2C) SET0 5,d 106 (2C) SET1 5,d 170 (2C) SKP0 5,d 234 (2C) SKP1 5,d
043 (2A) JPI A,c 107 (2A) JPI B,c 171 (2A) JPI X,c 235 (2A) JPI ,c
044 (2A) JPI A,d 108 (2A) JPI B,d 172 (2A) JPI X,d 236 (2A) JPI ,d
045 (2A) JPI A,(d) 109 (2A) JPI B,(d) 173 (2A) JPI X,(d) 237 (2A) JPI ,(d)
046 (2A) JPI A,X+c 110 (2A) JPI B,X+c 174 (2A) JPI X,X+c 238 (2A) JPI ,X+c
047 (2A) JPI A,X+d 111 (2A) JPI B,X+d 175 (2A) JPI X,X+d 239 (2A) JPI ,X+d
048 (1I) HALT 112 (1I) HALT 176 (1I) NOOP 240 (1I) NOOP
049 (1B) SFTL B,2 113 (1B) ROTL B,2 177 (1B) SFTR B,2 241 (1B) ROTR B,2
050 (2C) SET0 6,d 114 (2C) SET1 6,d 178 (2C) SKP0 6,d 242 (2C) SKP1 6,d
051 (2A) JMD A,c 115 (2A) JMD B,c 179 (2A) JMD X,c 243 (2A) JMD ,c
052 (2A) JMD A,d 116 (2A) JMD B,d 180 (2A) JMD X,d 244 (2A) JMD ,d
053 (2A) JMD A,(d) 117 (2A) JMD B,(d) 181 (2A) JMD X,(d) 245 (2A) JMD ,(d)
054 (2A) JMD A,X+c 118 (2A) JMD B,X+c 182 (2A) JMD X,X+c 246 (2A) JMD ,X+c
055 (2A) JMD A,X+d 119 (2A) JMD B,X+d 183 (2A) JMD X,X+d 247 (2A) JMD ,X+d
056 (1I) HALT 120 (1I) HALT 184 (1I) NOOP 248 (1I) NOOP
057 (1B) SFTL B,3 121 (1B) ROTL B,3 185 (1B) SFTR B,3 249 (1B) ROTR B,3
058 (2C) SET0 7,d 122 (2C) SET1 7,d 186 (2C) SKP0 7,d 250 (2C) SKP1 7,d
059 (2A) JMI A,c 123 (2A) JMI B,c 187 (2A) JMI X,c 251 (2A) JMI ,c
060 (2A) JMI A,d 124 (2A) JMI B,d 188 (2A) JMI X,d 252 (2A) JMI ,d
061 (2A) JMI A,(d) 125 (2A) JMI B,(d) 189 (2A) JMI X,(d) 253 (2A) JMI ,(d)
062 (2A) JMI A,X+c 126 (2A) JMI B,X+c 190 (2A) JMI X,X+c 254 (2A) JMI ,X+c
063 (2A) JMI A,X+d 127 (2A) JMI B,X+d 191 (2A) JMI X,X+d 255 (2A) JMI ,X+d

viernes, 8 de julio de 2016

Preservación de máquinas (VI): Emulador Kenbak-1 Interface

 Índice de entradas de Preservación de máquinas 
Colabora con el proyecto: Simplemente haz click de vez en cuanto en los anuncios, no te cuesta nada y me ayudas con los costes del proyecto. Cada 11 click aportas un euro.


Como primer paso voy a desarrollar el interface para el emulador del Kenbak-1, esto me permite conocer a fondo como se comporta la máquina, y el manejo de su interface, en este caso los botones y luces frontales.

El desarrollo lo quiero hacer en Visual Studio, usando Visual Basic, que mejor que el viejo y querido Basic para emular estas máquinas, aunque luego lo pasaré a C para poder subirlo al Arduino.

El interface es muy simple, se trata de poner un fondo con la máquina, y sobre el ubicar para cada bombilla un objeto imagen, que puedo ir alternando entre dos imágenes, una de luz encendida y otra de luz apagada. Los interruptores lo mismo, son objetos imagen que voy alternando entre las dos posiciones del interruptor. Los botones son objetos button que ya tienen un pequeño efecto cuando los pulsas por no complicarme, aunque podrían ser imágenes igualmente. En los botones voy a activar que con clic se pulsan, y con doble-clic se mantienen pulsados hasta otros clic, de esta forma se pueden pulsar dos botones a la vez, lo que hace falta para la ejecución paso a paso.

Con esto tengo el interface del aparato, pero por comodidad voy a poner también los registros visibles y la memoria debajo, con botones para verla en octal, decimal, hexadecimal, binario, o no verla. Así es mas sencillo meter programas para el aparato. Al disponer solo de 256 posiciones de memoria, caben todas en una sola pantalla, pero no voy a poner 256 objetos TextBox durante el diseño, y responder a 256 eventos de validación diferentes en ellos, sino que los monto en tiempo de ejecución con un bucle y los enlazo a un solo manejador de eventos de validación, así es mas rápido y práctico. Cuando arranca el emulador la memoria está oculta por defecto, pero he puesto los registros principales visibles de todas formas.

Emulador sin memoria visible

Pulsando cualquiera de los botones se abrirá la inspección de la memoria y este es el resultado de momento, pues estoy pensando en otras alternativas para que se vea el código del programa, pero así cabe bien en una pantalla de ordenador actual.

Emulador con la memoria visible

Para los programadores, este es el trozo que crea los textBox de las posiciones de memoria, enlaza el evento de validación para poder editar sin problemas, y los añade al formulario:

'Creo los TextBox para presentar la memoria
For Col = 0 To 15
    For Lin = 0 To 15
        'Calculo la posición para evitar hacerlo muchas veces, y creo el TextBox con su manejador de evento
        Dim nro As Integer = Lin * 16 + Col
        
        Dim tb As New TextBox

        AddHandler tb.Validating, AddressOf bt_Validating

        'Ponemos colores especiales en estas posiciones de memoria
        Select Case nro
            Case posRegA, posRegAOC : tb.BackColor = col_RA
            Case posRegB, posRegBOC : tb.BackColor = col_RB
            Case posRegX, posRegXOC : tb.BackColor = col_RX
            Case posPC : tb.BackColor = col_PC
            Case posOUT : tb.BackColor = col_OU
            Case posIN : tb.BackColor = col_IN
        End Select
        
        'Ajusto el TextBox
        tb.Font = New System.Drawing.Font("Microsoft Sans Serif", 
                                          8.0!, 
                                          System.Drawing.FontStyle.Regular, 
                                          System.Drawing.GraphicsUnit.Point, 
                                          CType(0, Byte))
        tb.Location = New System.Drawing.Point(Base_Columna + (Col * tbAncho), 
                                               Base_Linea + (Lin * tbAlto))
        tb.Name = "M" + (nro).ToString.PadLeft(3, "0"c)
        tb.Size = New System.Drawing.Size(tbAncho, tbAlto)
        tb.TabIndex = 102 + (nro)
        tb.Text = tb.Name
        
        'Añado el TextBox al control que presenta la memoria
        Me.gbMemoria.Controls.Add(tb)
        
        'Me lo guardo en el arreglo
        tbMemoria(nro) = tb
        
    Next
Next

jueves, 7 de julio de 2016

Preservación de máquinas (V): Kentelec-8 esquema de la fuente



Buena noticia, Jordi Ardèvol me remite el esquema de la fuente de alimentación que usaba el Kentelec-8, dibujado por Manel Puigbó a mano en su día. En la hoja pone Kentelec-8, con C y no con K, por tanto vuelta a lío de la C o la K. Vuelvo a ponerlo con C que me parece mas apropiado.


Esta fuente usa como regulado el 723, muy popular en ese momento, capaz de proporcionar como máximo 150mA regulados, por lo que se utiliza un transistor para aumentar la corriente soportada. Por lo que yo entiendo el esquema no está completo, le faltaría la parte de los 5 voltios, solo es de las corrientes auxiliares que requiere el aparato.