Restauración de un Multímetro FN Hansen

FN Hansen

Tenía un multímetro FN Hansen sin funcionar, coleccionando polvo en una caja. Se trata de una verdadera pieza de museo, que según Radiomuseum.org es de la década de 1960. Además, tiene un gran valor afectivo porque perteneció a mi padre y recuerdo haber visto el "tester" en muchas oportunidades en distintas partes de la casa. Es que, a pesar de que él trabajaba profesionalmente como Ingeniero en sistemas de control de procesos y luego en electro-medicina e informática, también le gustaba la electrónica como hobby.

La medición de corriente alterna estaba en cortocircuito, no medía corriente continua, tampoco resistencia. Probé el instrumento (aguja y solenoide) y funcionaba perfectamente. Le cambié unos componentes (diodos) y le soldé algunas conexiones... y voilá. Volvió a la vida.

Fig. 1 El interior del multímetro

El círculo rojo que se observa en la Figura anterior, corresponde a la prueba temporaria de los "diodos" de silicio, en realidad, le puse dos transistores que tenían una juntura dañada. El capacitor que se observa en el extremo superior izquierdo estaba mal soldado al terminal positivo, éste, a su vez, tenía una conexión intermitente con el gabinete y, al mismo tiempo, con el borne negativo -a través de la llave selectora-, lo que hacía que entrara en corto al medir CA.

Fig. 2 Prueba de Corriente Alterna

Como puede observarse, el instrumento sobre-estima la tensión de corriente alterna, marca 290V, mientras que el multímetro de al lado, un Micronta 22-2010 que compré hace unos años en un local de RadioShack en Los Angeles, marca correctamente 220V. Como el error es lineal, no me molesta. La resistencia la mide correctamente en la escala x10 y x1K, mientras que la escala de Megohms no la pude probar ya que requiere de una batería de 22V. Cuando termine la cuarentena, voy a comprar un par de minibaterías de 12V, para tener el instrumento con la funcionalidad básica completa (ohms, amperes, vca y vcc). Las mediciones de RF y de Alta Tensión las dejaré para otra ocasión.

FIN

Programming the MEK-6800

Lenguaje de Maquina

Desde el nacimiento de la "Ciencia del Computador", que ha  dado paso a la "Informática" como se la conoce en la actualidad en todo el mundo, se desarrollaron una miríada de lenguajes de programación. No cabe duda que aguellos "programadores" que implementaban sus cálculos en la ENIAC interconectando enormes cables entre los paneles tuvieron la motivación suficiente para buscar un mecanismo mas simple y eficiente.

Fig. 1 Codificadoras "cargando" un Programa.

Pero primero tuvo que desarrollarse en la computadora la capacidad de almacenar un programa, el modelo de Von Newman cubrió esa necesidad. A partir de allí ya hizo su aparición el primer lenguaje: el Lenguaje de Máquina.

Programa en 8086

El siguiente es el código completo, en lenguaje de máquina 8086 del algoritmo "Torre de Hanoi".

0000000000000000B81100B91200BA13 00BB0400E80500B84C00CD2183FB0074 52525150534B8916060189CA8B0E0601 E8E9FF5B58595AA30201890E04018916 0601E82F004B891E00018B1E0201E823 008B1E0601E81C008B1E0001A102018B 0E04018B160601A3020189C88B0E0201 E8A9FFC3B40289DA83C230CD21BA2000 CD21C3

El código fuente puede verse aquí

El lenguaje de máquina se programa por medio de señales eléctricas, a través de interruptores o botones diréctamente en posiciones de memoria de la computadora. Aún hoy se programa en este lenguaje, en proyectos con microcontroladores o microprocesadores.   

Programación en MS-DOS Debug (Video)

Programación de Mircrocontrolador (Video)

Hanoi en Assembler A86

El punto de partida del peregrinaje de Hanoi fue la implementación del algoritmo de las Torres de Hanoi en lenguaje de máquina del microprocesador 6800 de Motorola. Para "programarlo", tuve que escribir un pseudo código, pasarlo a lenguaje ensamblador de 6800, posteriormente “ensamblarlo” en el papel, instrucción por instrucción, para luego ingresarlo por medio de un teclado hexadecimal, directamente en la memoria del MEK-6800.

Fig. 1 Teclado del MEK-6800

En memoria de ese acontecimiento, hace unos años repetí la experiencia, pero en esa ocasión, con una PC y por medio del Debug de DOS. Hoy, tanto el código fuente de la versión "light" como la versión "de Luxe" se perdieron en alguna de las tantas migraciones de PC. Pero, el artículo que publiqué en este blog aun permanece, de manera que es lo que usaré como punto de partida para la realizar esta nueva versión en A86.

Vean el Proceso Completo

El video muestra el código fuente en A86, el proceso de compilación y su puesta en funcionamiento.

El A86 es un Macroassembler, de manera que el código que usé para ensamblar con Debug requerirá varias modificaciones para que el A86 lo acepte y me genere un ejecutable.

El Código Original

El siguiente listado corresponde al código tal como está publicado en este blog: Reursion and Machine Language.

NHANOI.COM A DW 0 DW 0 DW 0 DW 0 MOV AX,11 MOV CX,12 MOV DX,13 MOV BX,4 CALL 11C MOV AX,4C INT 21 CMP BX,0 JE 173 PUSH DX PUSH CX PUSH AX PUSH BX DEC BX MOV [106],DX MOV DX,CX MOV CX,[106] CALL 11C POP BX POP AX POP CX POP DX MOV [102],AX MOV [104],CX MOV [106],DX CALL 174 DEC BX MOV [100],BX MOV BX,[102] CALL 174 MOV BX,[106] CALL 174 MOV BX,[100] MOV AX,[102] MOV CX,[104] MOV DX,[106] MOV [102],AX MOV AX,CX MOV CX,[102] CALL 11C RET MOV AH,2 MOV DX,BX ADD DX,30 INT 21 MOV DX,20 INT 21 RET RCX 95 W Q

Listado 1

Si observamos en detalle el Listado 1, notaremos la aparente ausencia de "variables", tampoco se observan "procedimientos" o "subrutinas". En realidad, tanto las variables como las subrutinas están ahí, solo que no tienen nombre, son solo posiciones en la memoria.

La primera tarea consiste en asignar nombres "simbólicos" a esas posiciones de memoria, para convencer al A86 de que se trata de un programa en lenguaje ensamblador y no de una lista de compras. Para eso, primero vamos a ensamblar el código (con Debug), para determinar donde están las posiciones de memoria a las que hacemos referencia.

Compilación con Debug

E:\TC\A86>debug <hanoi.txt

El Debug genera un archivo ejecutable .COM

Pruebo el Funcionamiento

E:\TC\A86>hanoi
1 A B 2 A C 1 B C 3 A B 1 C A 2 C B 1 A B 4 A C 1 B C 2 B A 1 C A 3 B C 1 A B 2 A C 1 B C

Funciona!

Para ahorrar tiempo

• Genero un listado con el debug
• E:\TC\A86>debug hanoi.com >prog.txt
• Luego escribo cinco veces u y luego q.

Obtengo el siguiente listado

0E19:0100 DW 0 0E19:0102 DW 0 0E19:0104 DW 0 0E19:0106 DW 0 0E19:0108 MOV AX,11 0E19:010B MOV CX,12 0E19:010E MOV DX,13 0E19:0111 MOV BX,4 0E19:0114 CALL 11C 0E19:0117 MOV AX,4C 0E19:011A INT 21 0E19:011C CMP BX,0 0E19:011F JE 173 0E19:0121 PUSH DX 0E19:0122 PUSH CX 0E19:0123 PUSH AX 0E19:0124 PUSH BX 0E19:0125 DEC BX 0E19:0126 MOV [106],DX 0E19:012A MOV DX,CX 0E19:012C MOV CX,[106] 0E19:0130 CALL 11C 0E19:0133 POP BX 0E19:0134 POP AX 0E19:0135 POP CX 0E19:0136 POP DX 0E19:0137 MOV [102],AX 0E19:013A MOV [104],CX 0E19:013E MOV [106],DX 0E19:0142 CALL 174 0E19:0145 DEC BX 0E19:0146 MOV [100],BX 0E19:014A MOV BX,[102] 0E19:014E CALL 174 0E19:0151 MOV BX,[106] 0E19:0155 CALL 174 0E19:0158 MOV BX,[100] 0E19:015C MOV AX,[102] 0E19:015F MOV CX,[104] 0E19:0163 MOV DX,[106] 0E19:0167 MOV [102],AX 0E19:016A MOV AX,CX 0E19:016C MOV CX,[102] 0E19:0170 CALL 11C 0E19:0173 RET 0E19:0174 MOV AH,2 0E19:0176 MOV DX,BX 0E19:0178 ADD DX,30 0E19:017B INT 21 0E19:017D MOV DX,20 0E19:0180 INT 21 0E19:0182 RET

Listado 2

Procesamiento con Excel

Esta es una de las aplicaciones prácticas de Excel, nos permite trabajar con texto en forma tabular y aplicar funciones para agregarle o quitarle elementos (también es muy útil para trabajar con páginas web).

• Separamos las direcciones de las instrucciones (B y D).
• Insertamos una columna (C).
• Asignamos Nombres a las direcciones representativas.
• Copiamos las columas C y D en un archivo de texto con la extensión .8 que es la extensión de los programas fuentes en A86.

Listado A86 Coompleto

;HANOI Sergio F. Otaño ** ;En Macro Assembler A86 ** DATA SEGMENT N DW 0 _AX DW 0 _CX DW 0 _DX DW 0 DATA ENDS MOV AX,0011 MOV CX,0012 MOV DX,0013 MOV BX,0003 CALL CMP_N_0 MOV AX,004C INT 33 CMP_N_0: CMP BX,0 JZ RETORNA PUSH DX PUSH CX PUSH AX PUSH BX DEC BX MOV _DX,DX MOV DX,CX MOV CX,_DX CALL CMP_N_0 POP BX POP AX POP CX POP DX MOV _AX,AX MOV _CX,CX MOV _DX,DX CALL IMPRIME DEC BX MOV N,BX MOV BX,_AX CALL IMPRIME MOV BX,_DX CALL IMPRIME CALL NL MOV BX,N MOV AX,_AX MOV CX,_CX MOV DX,_DX MOV _AX,AX MOV AX,CX MOV CX,_AX CALL CMP_N_0 RETORNA: RET IMPRIME: MOV AH,02 MOV DX,0020 INT 33 MOV DX,BX ADD DX,48 INT 33 RET NL: MOV AH,02 MOV DL,10 INT 33 MOV DL,13 INT 33 RET

Listado 3 Programa Completo en A86

Compilación y Prueba

E:\TC\A86>A86 HANOI.8
A86 macro assembler, V3.72 Copyright 1994 Eric Isaacson
Source:
HANOI.8
Object: HANOI.COM
Symbols: HANOI.SYM

E:\TC\A86>HANOI
1 A C
2 A B
1 C B
3 A C
1 B A
2 B C
1 A C

El código funciona perfectamente e incluye la generación del carácter "\n" o (0D0A) provisto por la subrutina NL, para mejorar la salida por pantalla. El A86 genera un archivo .COM y no requiere enlazarlo. Este A86 en particular lo bajé del sitio de su autor. Cuando vivía en USA, yo había comprado un A86 (shareware) que generaba .OBJ además de .COM, pero es posible que su autor haya modificado su esquema de distribución.

¡Que tengan un gran día!

Sergio Otaño

Calendario Perpetuo

El programa Regi para Puntos de Venta (POS) tuvo una versión D.O.S (sistema operativo de disco), que presentaba su pantalla splash consistente de un archivo .PCX que era un formato similar al BMP y muy utilizado en DOS. Luego de la pantalla splash tenía un campo de texto para ingresar la clave de usurario y en la misma pantalla un calendario. En este artículo les presento el código fuente completo del calendario perpetuo que adornaba al Regi.

Fig. 1 Cale1.prg en DBase III plus

Es Leyenda

A pesar de que me refiero al Regi en su versión DOS en tiempo pasado, tengo conocimiento de que hay numerosos usuarios que aún lo emplean para comunicar sus registradoras y gestionar sus comercios. Sin duda que por la distancia con la tecnología vigente en la actualidad, el Regi se convierte un clásico por derecho propio, es Leyenda...

Esta versión de Regi está programada en Clipper y enlazada con Rtlink con algunos módulos programados en Turbo C y otros pocos en Assembler. El código fuente en Clipper es bastante fácil de leer para cualquier programador y por su simpleza puede ser implementado Java, JavaScript o VisualBasic con gran facilidad.

DBase III Plus

En la Fig. 1 se puede observar la ventana de DBase III plus corriendo el programa, simplemente se lanza el dbase y desde su línea de comando se escribe “do cale1.prg”.

Fig. 2 Calendario en ASP

En las imágenes de la Fig. 2 y Fig. 3 se observan las versiones ASP y Java con el agregado de cuadros combinados para la selección de opciones de mes y de año. Se puede acceder a estos calendarios por medio de las Mini Aplicaciones.

Fig. 3 Calendario en Java

Download

Si pensamos que DBase ocupa menos de 1Mb y que permite mover tablas dbf de cientos de Mb (recientemente la probé con el padrón nacional que tiene tablas de más de 300 Mb) tenemos que reconocer su calidad. Pueden bajar un Dbase III en el siguiente enlace: DBase III Plus

El Código Fuente

set talk off set echo off set scoreboard off set century on set color to W+/B,N/W clear *fecha = ctod("02/02/2000") fecha = date() anio = year(fecha) mes = month(fecha) diasem = dow(fecha) dia = day(fecha) dm1 = dia - 1 do while dm1 > 0 diasem = diasem - 1 dm1 = dm1 - 1 if diasem < 1 diasem = 7 endif enddo desp = diasem - 1 if (mes = 11 .or. mes = 4 .or. mes = 6 .or. mes = 9) cdias = 30 do case case mes = 11 cmes = "Noviembre" case mes = 4 cmes = "Abril " case mes = 6 cmes = "Junio " case mes = 9 cmes = "Setiembre" endcase else if mes = 2 cmes = "Febrero " if (anio / 4 - int(anio / 4) = 0) .and. ( (anio / 100 - int(anio / 100) <> 0) .or. (anio / 400 - int(anio / 400) = 0)) cdias = 29 else cdias = 28 endif else do case case mes = 12 cmes = "Diciembre" case mes = 7 cmes = "Julio " case mes = 8 cmes = "Agosto " case mes = 10 cmes = "Octubre " case mes = 1 cmes = "Enero " case mes = 3 cmes = "Marzo " case mes = 5 cmes = "Mayo " endcase cdias = 31 endif endif vta = 0 set color to W/N+ @ 5,28 clear to 17,52 set color to W+/R,N/W @ 5,28 clear to 16,51 @ 6,30 say cmes @ 6,42 say ltrim(str(anio)) @ 7,29 to 7,50 @ 8,29 say " D L M M J V S" @ 9,29 to 9,50 @ 5,28 to 16,51 double do while vta < cdias fila = 10+int((vta+desp) / 7) vta = vta+1 if vta = dia set color to W+/B,N/W else set color to W+/R,N/W endif do case case diasem = 1 @ fila,30 say right(' '+ltrim(str(vta)),2) case diasem = 2 @ fila,33 say right(' '+ltrim(str(vta)),2) case diasem = 3 @ fila,36 say right(' '+ltrim(str(vta)),2) case diasem = 4 @ fila,39say right(' '+ltrim(str(vta)),2) case diasem =5 @ fila,42 say right(' '+ltrim(str(vta)),2) case diasem = 6 @ fila,45say right(' '+ltrim(str(vta)),2) case diasem =7 @ fila,48 say right(' '+ltrim(str(vta)),2) endcase diasem = diasem+1 if diasem >7 diasem = 1 endif enddo ? ? ? set color to W+/B,N/W ?

Los Calendarios

El calendario permite organizar el tiempo, mientras que los relojes brindan su seguimiento permanente. Este invento ha sido fundamental para la civilización y también motivo de controversias y desvelos entre aquellos que proponían el calendario Juliano y los impulsores del calendario Gregoriano. Hacia la primera mitad del siglo XX la casi totalidad de naciones había suscripto al calendario Gregoriano, sin embargo, mientras los cristianos occidentales de varias denominaciones ya celebraron el nacimiento de Cristo, la Iglesia Ortodoxa Rusa los celebrará el 7 de Enero de 2012. La razón es que las denominaciones occidentales se basan en el calendario gregoriano mientras que la Ortodoxa Rusa lo hace en el calendario juliano.

¡Felices Fiestas!

Sergio Otaño

Gorilas en Java

Aquellos que iniciaron su sendero informático en la década de 1990 recordarán el sistema operativo DOS, el Windows 3.0 y aquellos juegos como el Super Mario, Príncipe de Persia y Wolfenstein entre tantos otros. El DOS incluía en esos días el QBasic.exe, un editor e intérprete de Basic muy completo. Dentro de este conjunto venía el programa Gorillas.bas muy popular en esos días. Jorilas es una versión Java de aquél clásico.

Fig. 1 Gorilas en Java

Como se Juega

El juego en cuestión consiste en hacer estallar al oponente por medio de bananas explosivas. La característica que hizo este juego bastante popular entre informáticos y programadores es que había que realizar un ejercicio de trayectoria para aproximar mentalmente el rango del impacto y el ángulo necesario para evitar los edificios (bastante similar al tipo de cálculo que deben realizar los artilleros).

En este caso hay dos gorilas Maximus a la izquierda y Eslavon a la derecha que disparan alternativamente las bananas en los ángulos y con la fuerza apropiada para hacer volar al oponente. Sin embargo pueden estallar ellos mismos si eligen algunas opciones de velocidad o ángulo.

Imágenes

En el aspecto gráfico, traté al máximo de mantener el estilo y los colores del original, sin embargo el sol es un poco más grande y lo dibujé con una combinación de los métodos fillOval(), drawLine() y cálculos trigonométricos. Los gorilas están grabados del programa original en una máquina con XP ya que en W7 y Vista no permiten ejecutar DOS en pantalla completa (una posibilidad para hacerlo sería por medio de DOSBox o un emulador similar). Las bananas son en realidad 1 banana que bajé de internet, la reduje y la procesé en iaza.com donde la convertí a gif transparente y luego hice las rotaciones.

Sonidos

Con respecto a los sonidos, probé grabar los originales pero sonaban muy mal de manera que utilicé sonidos de galerías gratuitas y en un caso, edité con el Vegas un pequeño fragmento de una pista de percusión africana, lo subí a convertfiles.com para generar los archivos de audio .au requeridos por Java.

Sitios recomendados:

¡Que tengan un gran día!

Sergio Otaño

Experimentos con Microprocesadores

En una entrada anterior comenté sobre mis experiencias con el Kit de desarrollo MEK-6800 de Motorola (ver Fig. 2) que permitía realizar toda clase de desarrollos tanto en el terreno del hardware como del software. Permitía comprender en plenitud la estructura de una computadora basada en la arquitectura de Von Neumann, programarla y desarrollar interfaces para conectarla con el mundo exterior.

Fig. 1 Entrenador Heathkit ET-3400

Debido a esta versatilidad es que en las universidades de todo el mundo, en especial en carreras de ingeniería, aún hoy se utilizan kits similares para el aprendizaje acabado de técnicas digitales y programación de bajo nivel. El Kit de Motorola consistía básicamente de dos placas (bastante grandes) una de las cuales contenía el uP 6800, las memorias ROM y RAM, una PIA (chip de bus paralelo) y una ACIA (chip de interface serie); la otra placa contenía un robusto conjunto de teclas 16 de valores hexadecimales y 8 de control y el display de 7 segmentos con 6 dígitos.

En futuros artículos voy a extenderme sobre algunas particularidades de estos sistemas, pero ahora, vamos “a las cosas” como aleccionaba Ortega y Gasset, porque cómo señalé en otras oportunidades, la propuesta de estos artículos es que los estudiantes y ocasionales lectores puedan llevar a la práctica los conceptos y se animen a experimentar un poco de lo que pueden encontrar en textos tecnicos, desarrollado en forma muy completo y detallada.

Ya expliqué en el artículo Recursion and Machine Language de este blog, cómo implementar la recursividad en lenguaje de máquina. Entonces: ¿Cuál es el objetivo?

Fig. 2 El Kit MEK6800 de Motorola

¡El objetivo es dar pautas simples para poder reproducir estas actividades!

Se preguntarán cómo pueden realizar las experiencias sin contar con el Kit entrenador MEK-6800 (que Motorola denominó Exorcicer, aludiendo humorísticamente a la película “El Exorcista”). Pues bien, el primer paso lo podemos realizar empleando un EMULADOR que corre bajo Windows. Claro está que con el emulador no tendremos la posibilidad de realizar los experimentos de electrónica digital, pero podremos tener un entendimiento completo de la estructura de un uP. A partir de ese conocimiento, pueden acceder al trabajo con Microcontroladores que tienen todas las funciones mencionadas en un solo chip, por lo que son muy económicos y fáciles de usar. El emulador que conseguí está basado en otro Kit que desarrolló la firma Heathkit, se trata del ET-3400 (en este caso no remite a la película ET sino que prosaicamente corresponde a ENTRENADOR).

Fig. 3 Emulador del ET-3400

Primera Experiencia

Al iniciar nuestro EMULADOR, el programa, replica el funcionamiento del ET-3400, muestra en el display de 7 segmentos el mensaje "CPU UP" que indica que el sistema esta listo para recibir instrucciones. El primer botón que vamos a oprimir es RESET. Este botón nos será útil cada vez que el sistema se cuelque porque hay alguna falla en el código que ingresamos.

Operaciones Con Registros y memoria

Para comenzar, vamos a realizar una serie de prácticas para familiarizarnos con el EMULADOR, y emplearemos las siguientes instrucciones: LDAA, STAA, LDAB, STAB, TAB y HLT. Si bien el uP 6800 dispone de diversos modos de direccionamiento, vamos a dejar ese tema para una discusión futura y nos limitaremos al modo de direccionamiento inmediato, es decir que luego de la instrucción pondremos un valor literal.

La instrucción LDAA permite cargar un valor en el ACUMULADOR A. Buscamos en la tabla de instrucciones que muestra que esta instrucción con direccionamiento inmediato tiene el código de máquina 86 exadecimal. También vamos a poner la instrucción HLT (halt o detener) que ordena al uP a detenerse. HLT que corresponde al código de máquina 3El.

Ahí vamos

Cargar el Acumulador A con un dato

1) Hacemos clic en el botón EXAM (letra E) e ingresamos 0000 (cuatro ceros), el emulador nos mostrará el contenido de la posición de memoria 0000.
2) Hacemos clic en el botón CHANGE (letra C).
3) Ingresamos el 86 que es el código de máquina de la instrucción LDAA.
4) Hacemos clic en el botón FORWARD (letra F) ahora estamos en 0001.
5) Hacemos clic en el botón CHANGE (letra C).
6) Ingresamos el valor FF (es el que queremos cargar en el Acumulador A).
7) Hacemos clic en el botón FORWARD (letra F) ahora estamos en 0003.
8) Hacemos clic en el botón CHANGE.
9) Ingresamos 3E que es el código de máquina de la instrucción HLT.
10) Hacemos clic en el botón DO (la letra D) que es la orden para ejecutar el programa.
11) Ingresamos 0000 que es la dirección de inicio de nuestro programa, y ¡voilá!

PERO...

¡SE PONE NEGRO EL DISPLAY!

Eso está bien ya que le dimos la instrucción HLT y el procesador (emulador) se detuvo.

12) Hacemos clic en el botón RESET y luego clic en el botón ACCA (el número 1).

Allí observamos en el display el valor "Acca FF"

¡El programa cumplió su cometido que era cargar el acumulador A con el valor FF!

Antes de despedirme me gustaría agradecer a Ricardo, por toda la información que me envió sobre la TK85 y sobre la revista Lúpin, hoy Ricardo es un ingeniero electrónico, pero recuerda la inspiración que le aportó la "revistucha". Ya voy a publicar algo sobre la TK que también inspiró a muchos en los inicios de la era informática.

Continuará...