Redes: Modelo OSI Entrega I

El Modelo de Referencia OSI de ISO

El Modelo de Referencia Sistema Abierto de Interconexión (OSI) de la Organización Internacional de Estándares (ISO) es un modelo de siete niveles o capas que describe como interconectar una combinación cualquiera de dispositivos con propósitos de comunicación. Este modelo describe las tareas en términos de estas siete capas y especifica las funciones que cada capa debe realizar.

Fig. 1 Esquema de transporte de paquetes OSI

Los principios en que se basó la Organización Internacional de Estándares para arribar al modelo de siete niveles son los siguientes:

- Un nivel distinto debe ser creado cuando se requiera un mayor nivel de abstracción.

- Cada nivel debe realizar una función bien definida.

- La función de cada nivel debe ser escogida con miras a la definición de protocolos estandarizados internacionalmente.

- Los límites del nivel deben seleccionarse para minimizar el flujo de información entre las interfaces.

- El número de niveles debe ser suficiente como para que distintas funciones no deban ser agrupadas en el mismo nivel por simple necesidad y tampoco debe ser excesivo para que la arquitectura no sea inmanejable.

Operación del Modelo

El concepto clave del modelo OSI es el de Paridad, esto implica que cada nivel jerárquico, cada capa de una máquina, se comunica con la misma capa de otra máquina. Dado que quienes establecen comunicación son capas equivalentes de diferentes máquinas, una aplicación en la máquina A se comunica con una aplicación en la máquina B. Del mismo modo, la capa de transporte de la máquina A se comunica con la capa de transporte de la máquina B.

Debido a que no existe una conexión directa entre capas pares, la comunicación debe tomar un camino indirecto. En la practica, ningún datos se transfiere directamente del nivel N de una máquina al nivel N de otra máquina (con excepción del nivel más bajo). En cambio, cada nivel pasa los datos y la información de control al nivel inmediatamente inferior, hasta alcanzar la capa física.

Observe en la Fig. 1 el esquema del modelo OSI y note que para comunicarse, la capa de aplicación de una máquina debe comunicarse con la capa de presentación de la misma máquina. La capa de presentación, a su vez, debe comunicarse con la capa de sesión, y así, hasta llegar a la capa física.

También podemos notar en la Fig. 1 que las capas agregan, al paquete recibido, elementos de control delante y detrás del paquete. Este tipo de proceso es similar al que sufren los tomates, que se almacenan en una lata, luego la lata en una caja, la caja en en un contenedor, etcétera.

En el nivel inferior se establece la comunicación física (mediante señales eléctricas) con otra máquina a diferencia de la comunicación virtual que se establece entre los niveles superiores.

Entre un nivel y el inmediato inferior existe una interfase. Esta interfase define que servicios y operaciones básicos ofrece el nivel inferior al superior. La definición clara de interfaces es fundamental no sólo para minimizar la cantidad de información que debe pasar de un nivel al siguiente, sino también para permitir el reemplazo de un nivel con uno completamente diferente (por ejemplo, el reemplazo de los cables telefónicos por canales satelitales), ya que todo lo que el modelo requiere es que la capa física de reemplazo ofrezca los mismos servicios que ofrecía el viejo a la capa superior.

Hasta la próxima entrega,

Sergio Otaño

Temporizador Deportivo

Motivación del proyecto

En Julio de 2007 sufrí un accidente mientras entrenaba unos saltos acrobáticos. Estuve más de un mes encerrado y alejado de todo tipo de entrenamiento físico, luego siguieron interminables e intensas sesiones de kinesiología. Uno de los entretenimientos en este período fue el de experimentar en el diseño de circuitos electrónicos simples por medio de un breadboard. Armaba un circuito, lo probaba, lo desarmaba y armaba otro.

Luego de dos meses me autorizaron a volver al gym, pero solamente para hacer bicicleta, elongación y movimientos simples. Como mi rodilla respondía bien al tratamiento, me indicaron comenzar a realizar trotes breves, el primero fue de 5 minutos alternando 1 minuto de trote y uno de caminata.

La primera vez que salí a los bosques de Palermo a "trotar", utilicé un reloj para controlar el tiempo y me di cuenta inmediatamente lo impráctico que era. La rutina en si misma era suficientemente triste como para sumarle la molestia del reloj:

¡Tenía que encontrar un temporizador práctico para realizar mi rutina!

Fig. 1 Circuito del Temporizador Deportivo

Como venía muy afilado en esto de armar y desarmar circuitos, se me ocurrió este proyectito (ver Fig. 1) que consiste en un temporizador que emite un pitido cada un minuto. Es bastante práctico para realizar múltiples actividades deportivas, por ejemplo: mantener posturas de yoga, realizar verticales, hacer cambios de ritmo durante el trote, y mucho más.

En mi caso, se trató, al menos por unas semanas de hacer 5 o 10 minutos de trote totales y cambios de ritmo de 1 minuto de trote suave con 1 minuto de caminata. Actualmente corro entre 40 y 60 minutos con un ritmo de entre 10 y 12 Km/h por lo que puedo usar un reloj convenientemente.

La idea era de un aparato pequeño que pudiera transportarse en el bolsillo del pantalón, colgarlo con una hebilla en el cinturón o dentro de una riñonera. También era importante el bajo consumo, la facilidad de uso y que emitiera un sonido audible en la calle.

Por suerte tenía todos los componentes a mano de modo que me puse a experimentar hasta que llegué al circuito que se observa en la Fig. 1. Como es un circuito RC (la constante de tiempo se establece por medio de la carga de un capacitor a través de una resistencia), los cálculos nunca resuelven todas las inconsistencias e imprecisiones implícitas en este tipo de componentes.

Para simplificar, en el 7555, R (entre el pin 7 y el positivo de la batería) es la combinación de una resistencia variable (preset) de 1M y una resistencia fija de 1M, lo que totaliza 2M. El capacitor (entre el pin 1 y el pin 2) es de 47uF.

Fig. 2 El Período y la Frecuencia de un circuito RC

En los papeles

Si calculamos en base a la fórmula de la Fig. 2, obtenemos lo siguiente:

R total = 2000000 (2M)

C = 47/1000000 = 0.000047

Entonces

0.693 R C = 65.142 Segundos

Lo que indica que el período será aproximadamente 60 segundos o 1 minuto.

En la realidad

Para llegar a los 60 segundos “exactamente” ajustamos la resistencia variable hasta comprobar que los pitidos se producen en el tiempo designado.

Construcción

Como se trató de algo que necesitaba con cierta urgencia y el circuito era bastante simple, utilicé los pines del 7555 como terminales y directamente soldé los componentes en los pines.

Para generar el pitido utilicé un oscilador pequeño de los que se utilizan en los portones de los garajes, en automóviles y demás, tiene un rango de alimentación entre 5 y 12 V, por lo que funciona perfectamente con los 9V de la batería.

Para alimentar el oscilador, utilicé un transistor BC557 que hace las veces de interruptor y toma la señal del pin 3 del 7555.

Para alojar los componentes, utilicé una cajita que tenía de un proyecto viejo y ya contenía un interruptor, un LED y la ficha para conectar la batería.

De todo el circuito, la batería de 9V es el componente más grande.

Resultado

El temporizador me resultó muy útil, tiene un sonido bastante potente, ocupa poco espacio, es liviano y tiene indicador de funcionamiento. Ahora lo utilizo para practicar verticales y malabares.

El primer pitido lo emite alrededor de los 90 segundos, a partir de allí es bastante preciso y emite pitidos cada 60 segundos que es lo que necesito.

Que tengan un gran día!

Sergio Otaño

Control Remoto por Internet

Introducción

*** NOTICIA ****** NOTICIA ****** NOTICIA ****** NOTICIA ***

Debido a la demanda, puse una copia para bajar en [Nueva Dirección]:

https://sites.google.com/site/guialtsen/archivos/ServHttp.rar

Fig. 1 El Programa HTTPSERV en ejecución

Controlar las instalaciones y empleados de su empresa desde Internet. Monitorear su casa desde cualquier parte del mundo. Encender, apagar y controlar artefactos a distancia. Verificar la temperatura y otros parámetros en lugares remotos. Todas estas cosas son posibles por medio de Internet. Sensores tales como termostatos, estaciones meteorológicas, cámaras de video y sistemas robotizados (actuadores) son ejemplos de dispositivos de control vía Internet.

Serhttp.exe (o HTTPSERV) es un programa que desarrollé para demostrar la posibilidad de controlar cualquier tipo de dispositivo a través de Internet. Luego de ver numerosos equipos costosos que combinan software y hardware para realizar distinto tipo de tareas en forma remota, se me ocurrió que en realidad, se puede demostrar perfectamente la posibilidad de controlar y de recolectar datos sin gastar un centavo.

Fig. 2 Sensores, cámaras de video y robots controlados por Internet

La idéa detrás de este proyecto fué la de realizar un experimento significativo, es decir, que tenga relevancia en el terreno de la realidad y no una simple simulación imaginaria de un hecho. Además, como su destinatario son los alumnos, se trata de no tener que invertir en componentes para realizar las experiencias. Por eso vamos a trabajar con un esquema que permite comandar en forma bidireccional un puerto COM.

El puerto COM de la PC permite que conectemos dispositivos tales como cámaras, sensores, balanzas y actuadores que permiten encender y controlar cualquier clase de aparato. Todo depende de la cantidad de $ que podemos disponer para ello.

Esto significa que todo lo que un programa tiene que hacer es enviar un dato al puerto COM para virtualmente comandar cualquier aparato y que pueda leer un dato del puerto COM para conocer el estado de cualquier aparato conectado en dicho puerto. Esto significa que el programa debe “comprender” el protocolo RS232.

Eso en lo que atañe al puerto COM. Sin embargo el programa debe también reconocer los protocolos TCP/IP y HTTP para poder recibir instrucciones por medio de Internet. El servidor HTTP hace precisamente esto.

Al ejecutar el programa se presenta una pantalla con 7 elementos que nos permiten conocer su estado.

a) El botón que permite seleccionar el puerto COM1 al COM4.

b) El botón que permite iniciar y detener el servidor.

c) Los elementos gráficos que dan a conocer el estado del puerto seleccionado como del funcionamiento del loopback.
d) El puerto de enlace que esta preestablecido en 80 (aunque se puede cambiar por otro) que es como ya deben saber el puerto correspondiente al protocolo HTTP.

e) IP Local nos indica la dirección IP del servidor (la máquina en la que está funcionando). En caso de que estemos conectados a Internet nos mostrará la dirección IP de nuestra conexión.

Ya es suficiente introducción, la mayoría de los conceptos teóricos los pueden encontrar tanto en un texto sobre comunicación de datos o sobre el protocolo TCP/IP específicamente.

Test Run del Programa

Realicemos un recorrido del programa para probar su funcionamiento:

1) Arrancamos el servidor

Fig. 3 El programa luego de “darle arranque”

2) Si todo va bien, se verá el puerto de color verde, en el título de la ventana dirá “Habilitado” y la hora y en IP Local dirá cual es la IP de nuestra PC. En este caso, como tengo banda ancha, aparece la IP que hace varios meses tengo asignada por Fibertel.

3) Ahora abrimos el explorador de Internet y le ingresamos la dirección IP (en mi caso ingreso esta dirección: 200.126.252.9)

Fig.4 Acceso a la “página” del servidor

Si están al día con el material de estudio ya comprenderán que se trata de una dirección IP de uso EXTERNO o PUBLICA y es propia de MI máquina. Si se conectan a Internet por medio de una conexión telefónica, tendrán diferentes direcciones cada vez que se conecten. Ahora bien, como la dirección IP PRIVADA de mi máquina es 192.168.0.1 también podría acceder a través de ella. Y por supuesto que también podría utilizar 127.0.0.1 que es el LOCALHOST.

4) Probamos sin el LOOPBACK, es decir con el puerto COM abierto.

Fig. 5 Prueba de Loopback

Escribimos hola o cualquier texto que se nos ocurra y obtenemos como respuesta:

ENVIADO : 123456789
EL PUERTO COM NO RESPONDE

Esto significa que todo funcionó correctamente ya que el servidor es el que dio esa respuesta.

5) Muy bien, ahora vamos a probar el LOOPBACK.

Conectamos el PIN 2 o RXD o recepción con el PIN 3 o TXD o transmisión. El principio de funcionamiento es bien simple y responde a la capa física del modelo OSI. Se trata de señales eléctricas que salen del puerto COM a través de la línea TXD con rangos de voltaje

Señal = 0 > +3.0V
Señal = 1 < -3.0V

Debido a esta conexión lo que sale por la línea de transmisión o TXD es inmediatamente recibido por la línea de recepción o RXD.

Donde dice Texto escribo: hola e inmediatamente recibo hola. Esto significa que el loopback funcionó correctamente.

Fig. 6 Verificación del Control Remoto

Observen que esta vez puse 192.168.0.1 como dirección IP.

Fig. 7 El Servidor muestra el loopback activo

Además pueden ver que el indicador de Loopback se puso de color verde.

Experiencias prácticas a realizar

Además de reproducir las experiencias detalladas antes, se recomienda fervorosamente a los alumnos que realicen las siguiente experiencias:

1) La experiencia práctica más simple consiste en reproducir el experimento tal como se expuso.
2) Luego variar las direcciones, la dirección de LOCALHOST o 127.0.0.1
3) Si dispone de una IP privada pruebe realizar la conexión por esa vía.
4) Pruebe conectarse a Internet, activar el servidor HTTP y desde otra dirección acceder a la máquina remota.
5) Otra prueba que se puede realizar es la de modificar el puerto, por ejemplo le asignamos 1000 al puerto del servidor. Pero en este caso, para acceder al servidor debo escribir la siguiente dirección: http://200.126.252.9:1000/
6) Para aquellos que realmente quieren experimentar en forma completa los servicios de Internet pueden incluso obtener una dirección DNS gratuita en el sitio http://freedns.afraid.org/ En mi caso, asigné el DNS regi.wftp.org a la dirección IP 200.126.252.9 que tenía asignada en ese momento de manera que puede acceder al servidor por medio de una dirección. El servicio permite cambiar la IP en forma rápida por lo que se adapta perfectamente para cualquier usuario que dispone de acceso a Internet y no tiene IP fija.

Fig. 8 Prueba Remota por medio de DNS

7) Finalmente, prueben algunas direcciones de Internet en la que invirtieron algunos o muchos dólares y observen el funcionamiento del control con dispositivos reales.

Enlaces de Interés

Los enlaces de abajo corresponden a dispositivos que se pueden controlar por Internet, el primero es muy interesante ya que es un brazo robotizado con 6 grados de libertad que permite acomodar objetos en un tablero.

http://telerobot.mech.uwa.edu.au/Telerobot/index.html
http://www.cs.cmu.edu/afs/cs.cmu.edu/Web/People/Xavier/
http://www.hellspark.com/dm/index.html
http://ranier.hq.nasa.gov/telerobotics_page/realrobots.html


Que tengan un gran día!

Sergio Otaño

Ensamblador (Entrega 5)

Implementación de Procedimientos

En términos muy groseros, un PROCEDIMIENTO es simplemente una dirección de la memoria que contiene una secuencia de instrucciones y termina con una instrucción RET. A partir de este punto, comienzan a aparecer “detalles”, tales como los PARAMETROS, el mantenimiento de los REGISTROS y BANDERAS en la “PILA” o “STACK”, el mantenimiento de VARIABLES en la pila, el retorno de valores (para implementar las funciones), etcétera. Todas estas cuestiones son importantes al implementar compiladores ya que en los lenguajes de alto nivel, se toman en cuenta minuciosamente.

Fig. 1 Implementación de un “procedimiento” en assembler

En la Fig. 1 observamos el código de un procedimiento que comienza en la línea 108 y que consiste de una rutina que permite mostrar un carácter por la pantalla, es el código que vemos a continuación:

0DE3:0108 MOV AH,2
0DE3:010A MOV DL,31
0DE3:010C INT 21
0DE3:010F RET

El “Programa Principal” es el siguiente:

0DE3:0100 CALL 108
0DE3:0103 MOV AX,4C
0DE3:0106 INT 21

Como vemos, el “programa” completo no es mucho mas que esto, ya que lo único adicional es que tiene las instrucciones de “salida” de DOS. Sin embargo, muestra dos conceptos importantes:

1) El procedimiento es simplemente una DIRECCION de memoria.

2) La instrucción RET devuelve el puntero de instrucciones, o, en términos simples, el control del programa a la instrucción siguiente a la del llamado.

En este ejemplo, el LLAMADO del procedimiento se realiza en la dirección 100 y el RETORNO se produce en la dirección 103.

El Programa en Ejecución

Fig. 2 El Programa y la Subrutina en acción

Observen la Fig. 2:

1) El programa muestra la ejecución de la primera instrucción que es la llamada al procedimiento (CALL 108).

2) Luego aparece un 1 en la pantalla que es lo que imprimió la subrutina. En este punto, es interesante notar que el IP = 103 (puntero de instrucciones) esta dirección es la del retorno del procedimiento.

3) Desde la dirección 103 el programa TERMINA

¡Esto es todo por ahora!

Sergio Otaño

Ensamblador (Entrega 4)

Mas Ejemplos

En esta ocasión veremos algunos ejemplos prácticos de instrucciones típicas del lenguaje ensamblador, tales como INC y DEC. También notaremos los efectos que pueden producirse en las BANDERAS (flags) y, finalmente, cómo se puede implementar un sencillo ciclo WHILE en lenguaje ensamblador.

Fig. 1 El programa PRU.COM en ejecución

Ejemplo de la instrucción DEC

a) Se inicia el comando A para ENSAMBLAR el código
b) MOV AX,FF (carga el registro AX con FF = 255)
c) Usamos INTRO para volver a la línea de comandos de DEBUG
d) Con el comando G 100 ejecutamos el código que comienza en la posición 100 de la memoria. Luego con el comando P vemos la ejecución del comando en custión. Si observamos el registro AX, notamos que contiene FF tal como le instruimos a la CPU.
e) Nuevamente aplicamos el comando A para ensamblar código
f) DEC AX (decrementa el valor de AX)
g) Usamos INTRO para volver a la línea de comandos de DEBUG
h) Con el comando G 103 ejecutamos el código que comienza en la posición 103 de la memoria. Luego con el comando P vemos la ejecución del comando en custión. Nuevamente observamos el registro AX y notamos que su contenidos es FE, es decir que disminuyó en 1 su valor.
i) Finalmente con Q salimos de DEBUG.

-A
0DE3:0100 MOV AX,FF
0DE3:0103
-G 100
AX=0000 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0DE3 ES=0DE3 SS=0DE3 CS=0DE3 IP=0100 NV UP EI PL NZ NA PO NC
0DE3:0100 B8FF00 MOV AX,00FF
-P
AX=00FF BX=0000 CX=0000 DX=0000 SP=FF
EE BP=0000 SI=0000 DI=0000
DS=0DE3 ES=0DE3 SS=0DE3 CS=0DE3 IP=0103 NV UP EI PL NZ NA PO NC
0DE3:0103 45 INC BP
-A
0DE3:0103 DEC AX
0DE3:0104
-G 103
AX=00FF BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0DE3 ES=0DE3 SS=0DE3 CS=0DE3 IP=0103 NV UP EI PL NZ NA PO NC
0DE3:0103 48 DEC AX
-P
AX=00FE BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0DE3 ES=0DE3 SS=0DE3 CS=0DE3 IP=0104 NV UP EI PL NZ NA PO NC
0DE3:0104 122A ADC CH,[BP+SI] SS:0000=CD
-Q


Ejemplo de la instrucción INC


-A
0DE3:0100 MOV AX,00
0DE3:0103
-G 100
AX=0000 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0DE3 ES=0DE3 SS=0DE3 CS=0DE3 IP=0100 NV UP EI PL NZ NA PO NC
0DE3:0100 B80000 MOV AX,0000
-P
AX=0000 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0DE3 ES=0DE3 SS=0DE3 CS=0DE3 IP=0103 NV UP EI PL NZ NA PO NC
0DE3:0103 45 INC BP
-A
0DE3:0103 INC AX
0DE3:0104
-G 103
AX=0000 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0DE3 ES=0DE3 SS=0DE3 CS=0DE3 IP=0103 NV UP EI PL NZ NA PO NC
0DE3:0103 40 INC AX
-P
AX=0001 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0DE3 ES=0DE3 SS=0DE3 CS=0DE3 IP=0104 NV UP EI PL NZ NA PO NC
0DE3:0104 122A ADC CH,[BP+SI] SS:0000=CD
-Q

Explicación:

En este ejemplo comenzamos cargando 0 en AX, luego aplicamos la instrucción INC AX y verificamos que efectivamente AX = 1

Pero veamos que ocurre en el siguiente ejemplo de la instrucción INC

a) Cargamos el registro AX con FFFF (el valor máximo que admite el registro, 65.535)

b) Incrementamos el contenidos de AX por medio de la instrucción INC…

c) Observamos que el registro AX quedó en 0. También se notan que el flag de cero está en ZR, es decir que cambió de NZ a ZR, esto significa que la operación tuvo por resultado cero. También cambió el flag de acarreo, que estaba en NA y pasa a AC lo que significa que hay un bit de acarreo.

-A
0DE3:0100 MOV AX,FFFF
0DE3:0103
-G 100
AX=0000 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0DE3 ES=0DE3 SS=0DE3 CS=0DE3 IP=0100 NV UP EI PL NZ NA PO NC
0DE3:0100 B8FFFF MOV AX,FFFF
-P
AX=FFFF BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0DE3 ES=0DE3 SS=0DE3 CS=0DE3 IP=0103 NV UP EI PL NZ NA PO NC
0DE3:0103 40 INC AX
-A
0DE3:0103 INC AX
0DE3:0104
-G 103
AX=FFFF BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0DE3 ES=0DE3 SS=0DE3 CS=0DE3 IP=0103 NV UP EI PL NZ NA PO NC
0DE3:0103 40 INC AX
-P
AX=0000 BX=0000 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0DE3 ES=0DE3 SS=0DE3 CS=0DE3 IP=0104 NV UP EI PL ZR AC PE NC
0DE3:0104 122A ADC CH,[BP+SI] SS:0000=CD
-Q

Ejemplo de la implementación de un ciclo WHILE

Crearemos un archivo de texto con EXACTAMENTE lo siguiente:

NPRU.COM
A
MOV AH,01
INT 21
CMP AL,0D
JNE 100
MOV AX,004C
INT 21

RCX
F
W
Q

Lo ensamblamos con el procedimiento explicado en entregas previas:


Observe la Fig. 1 que muestra el programa PRU en ejecución.

Explicación:

La opción AH=1 de la interrupción 21 permite leer un carácter tomado del teclado y mostrarlo por pantalla y guarda el carácter leído en AL.

El ciclo WHILE está implementado en la secuencia siguiente:

MOV AH,01
INT 21
CMP AL,0D
JNE 100

Básicamente la instrucción CMP permite comparar si el contenido de AL es igual a 0D (o 13 decimal que es INTRO).

La instrucción JNE significa “si no es igual, saltar” y el 100 es la posición a la que saltará el programa.

De este modo el ciclo se repite hasta que se teclea INTRO. Al teclear INTRO, el programa continúa con las instrucciones siguientes:

MOV AX,004C
INT 21

¡Y de ese modo finaliza el programa!

Sergio Otaño

VBA en Access - I

¿Cómo utilizar distintos controles?

Para adquirir destreza en el diseño de programas, hay que mantener una dinámica de trabajo que permita conocer particularidades de estos controles que nos sirvan para resolver el problema que nos planteamos.

Una de las actividades típicas es la de emplear las flechas (arriba, abajo, derecha e izquierda) para desplazarnos por un documento, mover algún tipo de personaje en un juego de video, etc.

En este ejemplo vamos a producir un cambio interactivo en nuestro formulario.

Paso 1

a) En un formulario nuevo insertar 12 etiquetas y asignarles un color de fondo determinado.

b) Asignarle un color distinto a la primer etiqueta.

Fig.1 Formulario y sus etiquetas

Paso 2

Vamos a emplear un EVENTO del formulario (recuerde que los eventos son los acontecimientos que le ocurren a un formulario, tales como que se haga clic, doble clic, se oprima una tecla, y demás).

Miren el listado de EVENTOS que dispone el formulario y encuentren el que corresponde al teclado. Básicamente van a encontrar 3 KeyDown, KeyUp y KeyPress. Les dejo como tarea el estudiar y ANOTAR las características de estos eventos.

¿Cómo sabe el formulario que tecla se oprimió?

El EVENTO asigna un valor numérico (que les recomiendo que estudien por medio de la AYUDA) en una variable.

Ahora bien, tenemos 3 posibles eventos a utilizar y usan 2 variables distintas KeyAscii y KeyCode.

Seleccionen uno de estos eventos y apliquen el conocido MsgBox para ver que código devuelve el evento al oprimir las teclas.

Recuerden que necesitamos los valores correspondientes a las flechas del teclado.

Paso 3

Una vez que determinaron qué evento van a utilizar, vamos a definir el código necesario para “navegar” por estas etiquetas.

Nuevamente van a apelar a MsgBox para ver que número corresponde a los colores de fondo (BackColor) que asignaron a las etiquetas. Recuerden que es un entero largo.

Para navegar necesitamos definir los LIMITES del territorio a navegar. En este caso es bastante sencillo ya que se trata de FILAS y COLUMNAS, son 4 columnas y 3 filas.

Vamos a definir 4 constantes para evitar salirnos del territorio.

El límite inferior FilaMin contendrá el valor 1 que es la primera fila
El límite superior FilaMax contendrá el valor 3 ya que son tres filas
El límite izquierdo contendrá el valor 1 que es la primer columna
El límite derecho contendrá el valor 4 ya que se trata de 4 columnas

Luego vamos a necesitar 2 variables que contengan la posición presente de nuestra navegación que va a comenzar en Fila = 1 y Columna = 1.

Paso 4

EL MANEJO DE LOS CONTROLES

Ahora vamos a introducirnos al uso concreto de los controles. En este ejemplo voy a utilizar el control Barra de Desplazamiento y les dejaré a ustedes la tarea de desarrollar la misma operatividad pero con el uso de las flechas.

Uno de los problemas que encontramos es el de cambiar la misma propiedad de un control QUE CAMBIA DE NOMBRE. Entonces, el primer paso es ver qué nombres tienen los controles, y luego, como lograr por medio del código acceder a todos los controles con sus nombres.

Recuerden que los nombres los pueden poner ustedes y cambiarlos cuando así lo deseen.

En este caso los nombres que tengo son: Label1, Label2 … Label12.

Por lo tanto, en todos los controles se repite el texto “Label” y cambia el número final.

Ustedes saben muy bien cómo acceder a un control para cambiarle alguna propiedad. Por ejemplo si queremos cambiar el color de fondo de la etiqueta 1 simplemente escribimos la línea Label1.BackColor = 255 u otro valor que corresponda a un color.

El problema con esto es que para nuestro ejemplo tendríamos que realizar un esquema de tipo If Then Else o Select Case de 12 instancias para cada cambio de valor de propiedad. Muchas veces los elementos no son 12 sino 200 por lo que esta forma de resolver la cuestión es absolutamente impráctica.

Recuerden que los controles están dentro del formulario y forman una colección que se desprende del mismo: por lo tanto si nuestro formulario se denomina Form1, entonces, Form1.Controls hará referencia a los controles de nuestro formulario.

Los controles o ITEMS que agregamos a nuestro formulario quedan numerados por orden de aparición, así que si al formulario vacío le agregamos un botón, este botón será el Item 0 de nuestro formulario, si luego agregamos un cuadro de textos, este será el Item 1, y así sucesivamente. Entonces ya tenemos Form1.Controls.Item(0) que nos hace referencia al botón.

¿Pero cómo se accede a las propiedades de ese botón?

Es fácil, si Form1.Controls.Item(0) es una referencia al control, por ejemplo Boton1, entonces Form1.Controls.Item(0).Name será lo mismo que escribir Boton1.Name

Veamos en nuestro ejemplo:

MsgBox (Form1.Controls.Item(0).Name)

La respuesta es: Label1

Pero recuerden que si no saben el nombre del formulario siempre pueden usar el nombre reservado Me. Me es lo mismo que decir el nombre del formulario actual. Por lo tanto, podemos escribir lo siguiente:

MsgBox (Me.Controls.Item(0).Name)

La respuesta es: Label1

De manera que si yo quisiera poner el color de fondo azul a todas las etiquetas de mi formulario podría simplemente escribir:

For i=0 to 11
Me.Controls.Item(i).BackColor=VbBlue
Next

Noten la porción de línea Item(i) que permite acceder sucesivamente a cada una de las etiquetas.

¡Prueben esto en sus PC!

Ahora vamos a ver una forma más directa de acceder a los controles

La colección de controles se puede acceder así:

Form1(“Label1”).BackColor = BvRed

En este caso, parece más fácil la solución, pero recuerden que se trata de poder manipular cualquiera de los controles, de modo que habrá que modificar el “Label1” para acomodarlo a los nombres de las distintas etiquetas.

En mi ejemplo voy a mostrarles el código completo para trabajar con una barra de desplazamiento. Pero como no se trata de que repitan como loros todo esto, la idea es que ustedes realicen el ejemplo pero que en lugar de usar una barra de desplazamiento, empleen las flechas del teclado de la PC.

Le agrego a mi formulario el control “Barra de desplazamiento” y escribo el siguiente código.

Fig. 2 El formulario en operación

En la sección general de nuestro código (donde como ya saben van las variables globales y demás) definimos estas variables y constantes:

Dim Etiq As Integer
'Definimos las constantes para los colores uno es el
'color que se repite y el otro es unico
Const colgeneral = &H80FFFF
Const colunico = 255

Luego, en el evento Change del control le agregamos el siguiente código:

Private Sub ScrollBar1_Change()
'asigno el color general a la etiqueta "vieja"
Me("label" & Etiq).BackColor = colgeneral
'cambio el valor de la etiqueta actual
Etiq = ScrollBar1.Value
'cambio el color de la etiqueta actual
Me("label" & Trim(Str(ScrollBar1.Value))).BackColor = colunico
End Sub

Noten que la variable Etiq recibe el valor (un número de 1 a 12) de nuestra barra de desplazamiento. Y observen que para poder decir Label1 o label3 o lo que fuera, debo concatenar el texto “Label” con el número correspondiente CONVERTIDO a texto por medio de la función Str().

Bueno, aquí tienen el ejemplo completo y espero que lo realicen, lo analicen, lo desmenucen hasta que lo comprendan completamente. Luego, realicen lo mismo pero con las flechas del teclado.

Hasta la próxima entrega!

Sergio Otaño

Torre de Brahma - I

Es Leyenda

Dicen que en la India, en un lugar secreto de la ciudad de Benares, oculto bajo la tierra, hay un templo que está precisamente localizado en el centro del mundo. Allí, desde el principio de los tiempos, aún antes que se dieran a conocer los relatos védicos, hay un grupo de devotos que guardan su existencia y sus rituales en el más profundo secreto.

A este templo solamente llegan aquellos devotos que han demostrado un profundo compromiso y son dueños de una fe inquebrantable y una precisión absoluta en sus movimientos. Todo lo que harán por el resto de sus vidas, es participar en el traslado de la Torre de Brama. La torre consiste de tres varas dispuestas en paralelo y representan los tres modos o polaridades de la energía.

En el principio, en una de las varas, estaban colocados 64 discos de oro, dispuestos de menor a mayor, y la misión de los monjes es la de trasladar estos discos hasta la tercer varilla, la varilla correspondiente al neutro o el perfecto equilibrio de los dos polos opuestos. Al hacer esto, deben mantener siempre los discos mas pequeños encima de los grandes. Este dispositivo es un reloj cósmico que marca el tiempo del mundo, porque al terminar de pasar todos los discos de oro, el mundo entero se disolverá.

Fig. 1 El juego de La Torre de Hanoi

Es Matemáticamente Posible

El matemático Edouard Lucas creó esta leyenda romántica para presentar un juego: La Torre de Hanoi. Lucas trabajó mucho en la teoría del número y estudió las series de Fibonacci, incluso desarrolló sus propias series: Las Series de Lucas. Lo que La Torre de Hanoi y la leyenda nos enseña, es que con un número pequeño de objetos, se puede generar un número extraordinariamente grande de movimientos.

En el caso de las “torres”, 2 ^ N – 1, es decir, si contamos con 3 discos:

2 ^ 3 – 1 = 7 movimientos.

En el caso de la torre de 64 discos:

2 ^ 64 – 1 = 18.446.744.073.709.551.615 movimientos.

Si los monjes realizaran un traslado completo de disco en 1 segundo, para desplazar los 64 discos, tardarían casi: ¡600 Billones de años!

Es Educativo Hacerlo en Excel

El algoritmo de las torres me resultó siempre interesante por su simpleza y por las implicancias que tiene. En una ocasión, lo implementé en un microprocesador 6800 donde tuve que ensamblar en el papel el código de máquina y luego cargarlo en la memoria con un teclado hexadecimal. ¿Un algoritmo recursivo en lenguaje de máquina? Por supuesto que sí. Tal vez haga una versión en lenguaje ensamblador 8086 y lo publique aquí en el futuro.

Para los alumnos, la implementación del algoritmo de Las Torres de Hanoi es interesante como ejercicio práctico del uso de los recursos de Excel. Es una forma de hacer que los gráficos interactúen con los programas de Visual Basic, además de tener que "animar" la secuencia de desplazamientos por lo que hay que considerar el manejo del tiempo.

Fig. 2 Implementación de “Las Torres de Hanoi” en Excel

En entregas futuras vamos a explorar el proceso de implementación de este algorítmo.

Que tengan un gran día!

Sergio Otaño

Ensamblador (Entrega 3)

El lenguaje ensamblador y las interrupciones

Al estudiar la estructura de la unidad central de procesos CPU, los alumnos aprenden el concepto de interrupción relacionado con el procesador, esta interrupción es de “hardware”, se trata de una señal eléctrica que recibe el procesador a través del bus de la PC (o una conexión directa en el caso de los microcontroladores).

Hay otro tipo de interrupciones, denominadas “de software” que en realidad son rutinas programadas y almacenadas en la memoria de la computadora. Para comprender esto, pensemos en un estado inicial en el que el procesador ejecuta un programa, al ocurrir una interrupción, el procesador abandona la tarea que lo ocupa y pasa a ejecutar otra.

Sintéticamente, lo que ocurre es lo siguiente:

1) El procesador almacena ciertos datos, tales como el contador de programa (que señala la dirección de memoria que está ejecutando)
2) Carga la dirección de memoria de la rutina de interrupción ISR correspondiente
3) Ejecuta la rutina de interrupción ISR y retorna de la interrupción.
4) Restablece los datos.

Una vez que el procesador completa su servicio al acontecimiento que originó la interrupción, retorna a la ejecución del programa en el punto en el que lo abandonara.

El lenguaje ensamblador dispone de una instrucción específica para “llamar” las interrupciones, se denomina INT. Int se utiliza para llamar a rutinas que realizar tareas genéricas y que vienen como servicios en el BIOS y en el DOS por lo que el programador no necesita programarlas por si mismo. Por ejemplo, para abrir un archivo el programador usará una rutina de interrupción de DOS, para establecer el modo de pantalla, mover el cursor y otras tareas similares, usará una rutina de BIOS. En general, la subrutina que se utilizará se especifica en AH (la porción alta del registro AX).

Por ejemplo, para imprimir un mensaje en la pantalla, se usará el servicio 9 de la interrupción 21. Si contáramos con un programa ensamblador simbólico, tal como el MASM, podríamos escribir algo así:

MSG DB 'CADENA$'
MOV DX, OFFSET MSG
MOV AH, 9
INT 21

En este caso, MSG es una variable, es decir, representa una posición de memoria. Este tipos de opciones facilitan mucho la tarea del programador. Sin embargo, con debug no contamos con esos lujos y debemos hacer estas cosas “a mano”, como vemos en el siguiente ejemplo:

Fig. 1 Ejemplo del uso del servicio 9 de la interrupción 21

El procedimiento que ejecuta el procesador para atender una interrupción se denomina ISR (Interrupt Service Routine en inglés) o rutina de servicio de interrupción. Esta rutina, es simplemente un programa que fué diseñado especialmente para atender el tipo de interrupción de que se trate. El vector de interrupción permite establecer la dirección que tendrá esta rutina.

El disparador de una interrupción puede tener origen en el hardware o en el software. Los vectores de interrupción de hardware se denominan IRQ. Las interrupciones de software se generan mediante la instrucción INT. El vector de interrupción se indica mediante un operando que sigue a la instrucción y puede tener un valor entre 0 y FF (0 y 255).

La computadora personal, al arrancar, carga un conjunto de rutinas de servicio de interrupción en la memoria. El primer programa en cargar rutinas es el BIOS que, como ya señalamos, está grabada en una memoria ROM (ROM-BIOS).

Además, los sistemas operativos disponible en el ambiente de la computadora personal tales como el DOS y OS/2, instalan rutinas de servicio de interrupción. De esta forma, el programador de lenguaje ensamblador dispone de un conjunto de servicios listos para ser utilizados. Uno de los servicios de interrupción típicos de BIOS es INT 10 que ofrece numerosos servicios de video. El DOS dispone de una interrupción muy versátil INT 21.

Generar un archivo .COM con Debug

El siguiente ejemplo muestra como se genera una interrupción de software. En este caso, utilizaremos el servicio 2 de la interrupción 21 de DOS. Para realizar este ejemplo, cree un archivo con el nombre EJ1.TXT utilizando un procesador de textos que genere código ASCII (EDIT de DOS o NOTEPAD de Windows). Luego, ingrese el conjunto de instrucciones tal como figuran en el ejemplo, sin cambiar nada.

Nej1.com
A
MOV AH,02
MOV DL,53
INT 21
MOV AX,004C
INT 21

RCX
B
W
Q

Recuerden que todos los números con los que trabaja el programa DEBUG son hexadecimales.

Explicación

Mediante el comando N le indicamos a DEBUG que cree un archivo con el nombre “ej1.com”. Luego, mediante el comando A le ordenamos que convierta las instrucciones que siguen (a dicho comando) en código de máquina (binario), luego de las instrucciones escritas en lenguaje ensamblador, hay una línea en blanco. Esta línea debe estar en blanco. Luego, está el comando RCX que permite cargar un valor en el registro CX, en este caso B hexadecimal (11 decimal). Luego, el comando W ordena a DEBUG grabar en el archivo ej1.com la cantidad de bytes que se indicaron en el registro CX, en nuestro caso B bytes. Finalmente el comando Q le orden a DEBUG salir.

Uso del programa

Para ensamblar el programa usaremos el comando debug seguido por el signo "<" y luego el nombre del archivo que creamos previamente, es decir ej1.txt. Observe la Fig. 2 en la cual se muestra la ejecución de este paso, y el despliegue en pantalla que realiza debug.

Fig. 2 Proceso de ensamblado y prueba del programa ej1

El caracter "<" simplemente redirecciona la entrada, en lugar de tomar datos desde el teclado, toma los datos del archivo de textos.

Para probar el "programa" ej1.com que acaba de crear, en la carpeta de trabajo en que se encuentra (C:\DOCUME~1\NUEVA>) teclee el nombre ej1 INTRO y el programa mostrará una S por la pantalla.

Análisis detallado del ejemplo

Pasaremos ahora a analizar el ejemplo anterior, paso a paso, para comprender algunos conceptos de programación en lenguaje ensamblador así como también, la forma en la que trabaja el programa DEBUG.

Preste suma atención a las líneas que exponemos a continuación:

- Línea 1: Nej1.com

El comando N instruye a DEBUG para que cree un archivo con el nombre que aparece a continuación del propio comando N. En nuestro caso, el nombre del archivo es “ej1.com” (es decir, un programa ejecutable).

- Línea 2: A

El comando A ordena a DEBUG convertir a lenguaje de máquina las instrucciones mnemotécnicas propias del lenguaje ensamblador (Ver figura Esquema del proceso de ensamble).

Recordemos que las instrucciones de lenguaje ensamblador se denominan mnemotécnicas por el hecho de que son fáciles de memorizar debido a la similitud que tienen con términos del idioma inglés. Por ejemplo, la instrucción MOV que permite “mover” un valor hacia un registro de la CPU, es claramente reconocible como MOVE (mover en inglés).

- Línea 3: MOV AH,02

Esta es la primera instrucción en lenguaje ensamblador, es decir es una instrucción para el procesador y no para DEBUG. Como previamente debug recibió la instrucción A, al leer el código de la línea 3, si es un código válido, lo convertirá a lenguaje de máquina y lo guardará en memoria.

El procesador de la computadora personal, dispone de un conjunto de registros que utiliza para almacenar, en forma temporal, los datos que procesa. Todos los programas, desde el humilde manejador del ratón hasta Windows Vista terminan convertidos en instrucciones de máquina y valores en los registros del procesador. Los registros disponibles son los siguientes: AX, BX, CX y DX. Estos son registros de 16 bits, que corresponde a 2 bytes o también a 4 números hexadecimales (recuerde que un número hexadecimal corresponde a 4 bits, o sea 1/2 byte).

El procesador, permite además acceder a registros 1 byte que en realidad corresponden al desdoblamiento de los registros de 16 bits que mencionamos antes. Así, el registro AX puede ser manejado también mediante los registros AH y AL. La H de AH indica que el byte es de orden superior; por su parte, la L de AL señala que el byte es de orden inferior. Para entender esto, veamos el siguiente ejemplo: Luego de realizar la instrucción MOV BX,7F5C, tenemos BX=7F5C, entonces BH=7F y BL=5C.

- Línea 4: MOV DL,53

En este caso, la instrucción (a la CPU) indica mover el valor 53 hexadecimal (83 decimal) al registro DL. Incidentalmente, el valor 53 hexadecimal corresponde al carácter S (de Sergio) en código ASCII.

- Línea 5: INT 21

Esta es la instrucción que realiza la interrupción de software. INT 21 es una interrupción de DOS que tiene múltiples aplicaciones o servicios, estos servicios, dependen de los valores contenidos en el registro AH. Veamos los servicios que presta la interrupción para los siguientes valores de AH:

Si AH=0

El sistema ingresa un carácter por el teclado, lo pone en el registro AL y lo muestra por la pantalla.

Si AH=1

Muestra por pantalla el carácter que está en el registro DL. En nuestro ejemplo, DL=53, 83 decimal es decir, la letra S.

- Línea 6: MOV AX,004C

Aquí tenemos un ejemplo del uso de un registro de 16 bits. Observe que lo cargamos con el valor 004C.

- Línea 7: INT 21

Nuevamente la interrupción 21 de DOS, en este caso, el servicio es AX= 004C que sirve para terminar el programa y hacerle saber a DOS que finalizó en forma exitosa. Esta línea y la anterior deberían incluirse siempre en los programas con la excepción de los programas residentes que utilizan un procedimiento diferente.

- Línea 8:

Esta línea se dejó en blanco intencionalmente ya que sirve para sacar a DEBUG del comando A (ensamblar), el cual debe concluir ya que la última línea para ensamblar fue la línea 7.

- Línea 9: RCX

El comando R le indica a debug preparar el registro, en este caso el registro CX para ingresarle un valor. DEBUG utiliza el registro CX para guardar un valor que sirva, en este caso, para indicar la cantidad de bytes en lenguaje de máquina (esta cantidad tuvo que determinarla el autor).

- Línea 10: B

Este es el valor que se cargará en CX. El valor B hexadecimal es igual a 11 decimal y corresponde a la cantidad de bytes que DEBUG grabará como código en lenguaje de máquina (que está en la memoria) en el archivo ej1.com.

- Línea 11: W

El comando W ordena a DEBUG a escribir la cantidad de bytes que indica el registro CX y cerrar el archivo.

- Línea 12: Q

El comando Q ordena a debug termnar su operación y retornar a DOS.

Realicen los ejemplos y en próximas entregas veremos cómo crear nuestros propios servicios de interrupción y cómo dejar programas “residentes” en memoria.

Hasta la próxima entrega,

Sergio Otaño

Ensamblador (Entrega 2)

Lenguaje Ensamblador y Debug

Para comprender las tareas que realizamos en nuestros ejemplos, tomemos en cuenta brevemente las características y funciones del programa DEBUG. Este programa, fue creado para verificar errores en los programas. El término bug en inglés significa bicho y en informática significa errores de programa, debug es entonces, un quitabichos o quitaerrores. Sin embargo, por ser un programa que permite realizar operaciones de bajo nivel (es decir, trabaja sobre la arquitectura del sistema) ya que reconoce la estructura del microprocesador, los registros, posiciones absolutas de memoria, etcétera, puede ser usado en una variedad de aplicaciones. Normalmente, DEBUG se usa en forma interactiva, o sea que se ingresa la línea de comando DEBUG o DEBUG [nombre del programa] y luego se introducen las órdenes a debug desde dentro del programa, a continuación del símbolo - (un guión).

Por ejemplo podríamos escribir el comando DEBUG EDIT.COM con lo que podríamos observar, DEBUG mediante, el código de máquina del programa EDIT. Para iniciar la sesión, ingresamos el comando DEBUG y luego oprimimos ENTRAR. El primer comando de debug que usaremos será el signo de interrogación ?. Mediante este comando obtenemos por pantalla una lista de los comandos disponibles en debug y la descripción de su aplicación.

Fig. 1 Comandos de Debug

En nuestra entrega anterior presentamos el Ejemplo 1, en esta oportunidad incluiremos una nueva instrucción de debug y veremos como cargar un registro desde una posición de memoria.

Ejemplo 2: Cargar un registro desde una posición de memoria

C:\WIND>DEBUG
-E 104 5
-A 100
3902:0100 MOV AL,[104]
3902:0103
-G 100

AX=0000BX=0000CX=0000DX=0000SP=FFEEBP=0000SI=0000DI=0000
DS=3902ES=3902SS=3902CS=3902IP=0100 NV UP EI PL NZ NA PO NC
3902:0100 A00401 MOV AL,[0104]
-P

AX=0005BX=0000CX=0000DX=0000SP=FFEEBP=0000SI=0000DI=0000
DS=3902ES=3902SS=3902CS=3902IP=0103 NV UP EI PL NZ NA PO NC
3902:0103 3005 XOR [DI],AL
-

El primer comando que utilizamos es E (introducir) que permite cargar una posición de memoria con un valor (cargamos el valor 5 en la dirección 104). Luego, utilizamos el comando A (ensamblar) indicandolé la dirección 100 porque debug está posicionado en la dirección 104 y comenzaría a ensamblar en la dirección siguiente. Luego, ingresamos nuestra instrucción MOV AL,[104] que carga el contenido de la dirección 104 en el registro AL (observe que la dirección debe indicarse entre corchetes). Luego de ingresar la instrucción oprimimos INTRO para retornar al guión de debug. Utilizamos el comando G 100 para ir a la dirección 100 y detener la ejecución.

AX=0000BX=0000CX=0000DX=0000SP=FFEEBP=0000SI=0000DI=0000
DS=3902ES=3902SS=3902CS=3902IP=0100 NV UP EI PL NZ NA PO NC
3902:0100 A00401 MOV AL,[0104]

Luego utilizamos el comando P (continuar) para ejecutar nuestra instrucción.

AX=0005BX=0000CX=0000DX=0000SP=FFEEBP=0000SI=0000DI=0000
DS=3902ES=3902SS=3902CS=3902IP=0103 NV UP EI PL NZ NA PO NC
3902:0103 3005 XOR [DI],AL

Observe la última línea que muestra la dirección actual (103), ignore la instrucción XOR (es “basura”). Observe ahora el estado del registro AX y notará el valor 5, es decir que nuestra instrucción fue ejecutada exitosamente. Otro detalle a tomar en cuenta es que la dirección de comienzo en este ejemplo es 3902:0100 y si observa en detalle DS, que es el segmento de datos dice DS=3902. Mas aún, si realizan este ejemplo es sus PC notarán que el DS es diferente de 3902 (si obtienen el mismo número, corran hasta el bingo mas cercano...).

Note que en el Ejemplo 1, la instrucción MOV se convirtió en B8, mientras que en este caso, se convirtió en A0. La razón de esta diferencia radica en el hecho que se trata de dos instrucciones de máquina distintas, la primera consiste en un MOV de un valor consecutivo al registro AX, mientras que en este ejemplo, se trata de un MOV desde una posición de memoria RAM hacia el registro AX. Sin embargo, a pesar de estas diferencias, el programador solamente tiene que usar una sola instrucción mnemotécnica, el MOV.

Ejemplo 3: Cargar un registro desde otro registro

C:\WIND>DEBUG
-A
3902:0100 MOV DX,567
3902:0103 MOV AX,DX
3902:0105
-G 100

AX=0000BX=0000CX=0000DX=0000SP=FFEEBP=0000SI=0000DI=0000
DS=3902ES=3902SS=3902CS=3902IP=0100 NV UP EI PL NZ NA PO NC
3902:0100 BA6705 MOV DX,0567
-P

AX=0000BX=0000CX=0000DX=0567SP=FFEEBP=0000SI=0000DI=0000
DS=3902ES=3902SS=3902CS=3902IP=0103 NV UP EI PL NZ NA PO NC
3902:0103 89D0 MOV AX,DX
-P

AX=0567BX=0000CX=0000DX=0567SP=FFEEBP=0000SI=0000DI=0000
DS=3902ES=3902SS=3902CS=3902IP=0105 NV UP EI PL NZ NA PO NC
3902:0105 8BFF MOV DI,DI
-

En este ejemplo comenzamos por cargar un registro (DX) con un valor constante (567), en la segunda línea ingresamos la instrucción que carga un registro (AX) desde otro registro (DX). Luego mediante el comando P vemos como se modifican los contenidos de los registros, primero el registro DX y luego el registro AX.

Tomen como guía estos ejemplos, los continúen el recorrido por los demás registros.

En la próxima entrega, estudiaremos el uso de interrupciones y cómo estas facilitan la tarea del programador.

Hasta la próxima,

Sergio Otaño

Ensamblador (Entrega 1)

En el principio, era el cable

Las computadoras primitivas se programaban mediante el cambio de las conexiones (cables) en un panel dispuesto a tal efecto. Este cambio de conexiones modificaba la lógica del sistema y permitía “resolver” problemas de baja complejidad en forma repetida. Como podrán notar, este tipo de programación se realizaba mediante el hardware y era un proceso bastante complejo, lento e ineficiente que requería por parte del “programador” un conocimiento pleno de los circuitos de la computadora. Crear o modificar un programa constituían emprendimientos mayores por el tiempo y la dedicación de los “programadores”.

El primer salto cualitativo se produjo con la evolución de los dispositivos de almacenamiento, en principio las memorias de núcleo y luego, con la miniaturización, los circuitos integrados o “chips”. En forma paralela, muchos usuarios (oficinas gubernamentales, universidades, institutos de investigación, etcétera) percibieron la necesidad de resolver un amplio conjunto de problemas en forma relativamente rápida. Estas dos fuerzas dieron nacimiento al lenguaje ensamblador que se caracteriza por mantener una estrecha relación con el lenguaje de la máquina

El conjunto de códigos de instrucción del lenguaje de máquina forma parte de la arquitectura de la unidad central de proceso y consiste de un conjunto de valores binarios que señalan operaciones específicas. Estas instrucciones son reconocidas por el procesador por el código binario (o exadecimal) correspondiente, por ejemplo la instrucción B4 significa cargar la parte alta del registro AX (o sea AH) con el valor que sigue. La particularidad del lenguaje ensamblador consiste en tener una instrucción con un nombre simbólico fácil de recordar, para cada instrucción o conjunto de instrucciones de máquina. Las instrucciones del lenguaje ensamblador se denominan mnemotécnicas debido a que pueden memorizarse con facilidad.

La CPU (PC 8088, etcétera)

Fig. 1 Arquitectura simplificada de la CPU

Recorrido de los registros

La mejor manera de entender la estructura de la unidad central de proceso o CPU, consiste en meterse en el interior y explorar sus registros y su unidad de aritmética y lógica o ALU. Y la forma de meterse y espiar estas cosas está al alcance de cualquier usuario de PC, por medio del programa Debug.

Fig. 2 Esquema del proceso de ensamble del lenguaje simbólico al código de máquina

Las primeras prácticas estarán dirigidas a recorrer todos los registros (8) disponibles en la CPU y, para facilitar las cosas, realizaremos tres ejemplos completos que les servirán de guía, con el empleo del programa debug.


En estos ejemplos se mostrarán tres modalidades de la instrucción MOV, la primera consistirá en la carga de un registro con un valor constante, luego veremos la carga de un registro desde una dirección de memoria (previamente inicializada) y, finalmente mostraremos la carga de un registro desde otro registro.

A las cosas como decía Ortega y Gasset

Pasemos directamente a un simple ejemplo para comprender de qué estamos hablando.

Ejemplo 1: Mover un valor constante a un registro.

Para ejecutar Debug, hay que iniciar una sesión DOS. Esto se consigue por medio del menú Inicio:

Inicio/Ejecutar/

Fig. 3 Cuadro de diálogo "Ejecutar" (command)

Una vez en DOS (no se alarmen si aparece “parado” en otra carpeta que no sea C:\WIND)

El programa debug muestra un guión –

Detrás de ese guión deben escribir los comandos (en este caso son cuatro: a, g 100, p y q)

a le dice a debug que ensamble las instrucciones que siguen

g 100 le dice que “vaya” a la posición 100 (que es donde comienza el programa)

p le dice que “avance” un paso

q le dice que “salga” (quit)

Sesión completa de Debug

C:\WIND>debug
-a
3902:0100 MOV AX,123
3902:0103
-g 100

AX=0000BX=0000CX=0000DX=0000SP=FFEEBP=0000SI=0000DI=0000
DS=3902ES=3902SS=3902CS=3902IP=0100 NV UP EI PL NZ NA PO NC
3902:0100 B82301 MOV AX,0123
-p

AX=0123BX=0000CX=0000DX=0000SP=FFEEBP=0000SI=0000DI=0000
DS=3902ES=3902SS=3902CS=3902IP=0103 NV UP EI PL NZ NA PO NC
3902:0103 3028 XOR [BX+SI],CH
-q

Explicación

Al ejecutar DEBUG, se presenta un guión (-) que permite ingresar los comandos para realizar diversas tareas. El primer comando que utilizamos es A (ensamblar) que nos presenta la dirección actual (3902:0100). Nosotros ingresamos la instrucción MOV AX,123 que carga el registro AX con la constante 123 y oprimimos INTRO. Luego, debug presenta la próxima dirección disponible (0103), en esta dirección, no ingresamos ninguna instrucción, sino que oprimimos INTRO para retornar al guión de debug.

Hasta aquí, tenemos nuestra instrucción lista en la memoria para ser ejecutada, por lo tanto, empleamos el comando G (ir) que permite ejecutar el programa, dando comienzo en la dirección que se indica a continuación. El programa consiste de una línea, simplemente le indicaremos a debug que vaya a la dirección 100 y que se detenga allí (g 100). Debug, entonces, se detiene en 100 y aún no ha ejecutado la intrucción MOV. Sin embargo, debug nos muestra el estado de los registros en las dos primeras líneas, mientras que la tercer línea muestra la dirección actual seguido por el código de máquina generado y la intrucción en lenguaje ensamblador:

AX=0000BX=0000CX=0000DX=0000SP=FFEEBP=0000SI=0000DI=0000
DS=3902ES=3902SS=3902CS=3902IP=0100 NV UP EI PL NZ NA PO NC
3902:0100 B82301 MOV AX,0123

Como podemos observar, el registro AX contiene el valor 0, es decir, aún no está cargado con la constante 123. Para ejecutar la línea 100 utilizamos el comando P (continuar) que pasa a la siguiente dirección.

AX=0123BX=0000CX=0000DX=0000SP=FFEEBP=0000SI=0000DI=0000
DS=3902ES=3902SS=3902CS=3902IP=0103 NV UP EI PL NZ NA PO NC
3902:0103 3028 XOR [BX+SI],CH

Observe la tercer línea que muestra la dirección actual (103), ignore la instrucción XOR ya que es lo que se denomina “basura” (garbage en inglés) que consiste en contenidos arbitrarios de esa posición de memoria. Observe ahora el estado del registro AX y notará el valor 123, es decir que nuestra instrucción fué ejecutada exitosamente.

¡Listo!

Realice el ejemplo y pruebe con otros valores y otros registros, tales como BX, CX, DX, etcétera.

Hasta la próxima entrega,

Sergio Otaño

Diseño, Imaginación y Realidad

La Imaginación y la Realidad

El diseño, ya sea que se trate de objetos funcionales, modelos operativos o procesos informáticos (incluyendo desde procesos de control en tiempo real hasta juegos de video), se nutre de la imaginación. Sin imaginación, no hay objeto, no hay modelo y no hay software.

Sin embargo, hay una enorme diferencia entre la imaginación pura, tal como se presenta en la poesía o incluso en la novela (sin dejar de reconocer que aún en estas artes aparecen restricciones formales como el lenguaje, los símbolos, la cultura, etcétera) y aquella imaginación que puede plasmarse en términos de una realidad tangible, ya sea como objeto material, formal o lógico.

Una de las dificultades radica en las limitaciones que impone “la realidad” en cuanto a leyes físicas, tiempos tecnológicos, recursos materiales y demás cuestiones. Estas restricciones que se imponen sobre el diseñador, implican un marco limitante de la discrecionalidad que puede ejercer. En alguna medida tendrá que encajar, literalmente meter en una caja la nube imaginativa de su proyecto.

Tal vez los más creativos a la hora de experimentar sus nubes imaginativas en el mundo real hayan sido los físicos, desde la mítica manzana de Newton hasta el logro de la fisión nuclear son espectaculares muestras de imaginación aplicada. En el caso de la informática, la restricción la impone el modelo computacional disponible que, a su vez, depende de los recursos económicos y humanos.

Para los alumnos, es muy útil experimentar las ideas con distintas plataformas y, de este modo, explorar los límites, tanto propios como de las plataformas en cuestión. Como me gusta ejemplificar estas cosas, vamos a realizar un sencillo ejemplo en una plataforma muy amigable y fácil de usar como es el Excel.

Reloj Analógico

Fig. 1 Relój Analógico implementado en un gráfico Excel

Ventajas

Entre las ventajas que nos ofrece Excel, está la ubicuidad y la facilidad de uso. Hay millones de PC en el mundo que disponen de este producto y millones de usuarios que saben como utilizarlo.

La representación gráfica del reloj también es fácil de lograr con el uso de los gráficos que provee y que no requieren esfuerzos por parte del usuario. Asimismo, la relación entre el gráfico y la hoja con los datos es directa y no requiere de ningún tipo de “programación”.

Los cálculos también presentan una gran ventaja ya que no requieren de “programación” sino que, simplemente, se agregan fórmulas en las celdas de la hoja Excel.

Desventajas

Una de las restricciones que presenta el Excel es que no dispone de un control Timer como el que disponen los formularios de Access, las plataformas de Visual Studio y otras. En lugar de la versatilidad del control Timer, podemos utilizar la función Time() de Visual Basic.

Manos a la obra

El primer paso consiste en armar la hoja con los datos y las fórmulas.

En el rango A3:A14 ponemos los grados en grupos de 30° que cubren los 360° (0° coincide con 360°).

Fig. 2 Tabla con datos y fórmulas para el Reloj Analógico

En la columna B solamente vamos a determinar la posición del círculo con respecto al eje x, para ello emplearemos la función (correspondiente a B3): =SENO(RADIANES(A3))

Nota: la función Radianes() convierte del sistema exadecimal a arco o radianes que es el sistema que entiende Excel.

En la columna C solamente vamos a convertir la posición del círculo con respecto al eje y, para ello emplearemos la función (correspondiente a C3): =COS(RADIANES(A3))

Estas dos columnas (B y C) se emplean para ubicar los diamantes en forma circular y equidistante y dar la idea de un dial de reloj.

Corresponden a la serie de datos:

=SERIES(;Reloj!$B$3:$B$14;Reloj!$C$3:$C$14;1)

En la columna D ponemos valores del 1 al 12 para usarlos en las etiquetas del gráfico

Los Segundos

El segundero se implementa por medio de la serie:

=SERIES(;Reloj!$E$3:$E$4;Reloj!$F$3:$F$4;2)

En esta serie, E3 y F3 tiene el valor 0, es decir x=0 e y=0 (el centro del círculo).

E4 =SENO(RADIANES(G1*6))

F4 =COS(RADIANES(G1*6))

Los Minutos

Exactamente igual que los segundos pero toman el valor de H1 en lugar de G1.

Las Horas

Queda como ejercicio para aquellos alumnos que les interese.

La Programación Visual Basic

Tal como dije al comienzo, en este ejemplo hay muy poca programación ya que Excel se encarga de casi todo el problema con sus funciones y gráficos. El código se requiere para permitir que el usuario pueda ver al reloj en funcionamiento. Para esto le agregaremos a la hoja un botón que permita arrancarlo y detenerlo a voluntad.

El Código

Private Sub CommandButton1_Click()
Dim cambio As Integer
If CommandButton1.Caption = "Fin" Then
CommandButton1.Caption = "Inicio"
End
Else
CommandButton1.Caption = "Fin"
Do
Range("g1").Value = Second(Time())
[h1] = Minute(Time())
DoEvents
Loop
End
End If
End Sub

Observen que hay dos modalidades para actualizar las celdas de la hoja de Excel, en un caso se emplea la función Range(): Range("g1").Value = Second(Time()) en el otro, se utiliza [h1] = Minute(Time()).

Importante: ¡No se olviden de DoEvents!
Sergio Otaño

Circuito de Radio Híbrido (LU9BSO)

Introducción

A 100 Años del nacimiento (1907) de la Electrónica, valga un pequeño circuito como homenaje al ingenio de muchos hombres y mujeres que contribuyeron a su desarrollo.

Fig. 1 Implementación del circuito en breadboard

En este caso se trata se una radio híbrida que combina tecnologías termiónicas (válvulas de vacío) y transistores. La válvula es un pentodo 12BA6 empleado en RF de la década de 1940/50 y los transistores de germanio son AC127 correspondientes a la década de 1960. Puede observar el circuito en la Fig. 2, pero antes veamos un poco de historia.

Un poco de historia...

Podemos rastrear el nacimiento de la electrónica, a partir de la publicación del artículo de Lee De Forest "THE AUDION: A NEW RECEIVER FOR WIRELESS TELEGRAPHY" (Scientific American Supplement No. 1665, 30 de Noviembre de 1907, páginas 348-350). En este artículo, De Forest presenta los resultados de sus experimentos realizados con un dispositivo incandescente al vacío de tres elementos.

Precisamente este dispositivo de tres elementos que posteriormente fué denominado triodo, por primera vez se pudo controlar el flujo de electrones, lo que establece el nacimiento de esta nueva disciplina. El triodo de De Forest era muy ineficiente, pero lograba amplificar la señal, hecho que hasta ese momento no había sido posible.

Circuito y descripción

Fig. 2 Esquema del circuito

La etapa de audio del circuito es una modificación de un circuito típico de los años 1960 en los que se empleaban transistores PNP (AC128 o similares) pero que por razones de costo los reemplacé por NPN que son mas baratos. En la etapa de RF, en lugar de un transistor (usualmente un AF116 o similar) le incorporé un circuito regenerativo valvular también clásico que proviene de la década de 1920 (aunque la válvula es mucho mas "moderna").

Que tengan un gran día!

Sergio Otaño (LU9BSO)

El estudio de los Algorítmos Fundamentales

Herramientas para visualizar los algorítmos

Además de las estructuras abstractas de datos, una de las áreas de estudio básicas en Informática, son los modelos de algoritmos(*) de búsqueda y ordenamiento. En la actualidad, el estudiante dispone de numerosas herramientas muy atractivas para estudiar, analizar y experimentar con estos algoritmos.

(*) Algorítmo deriba del vocablo árabe alkhowarizmi, seudónimo de un matemático y astrónomo árabe que escribió un tratado sobre manipulación de números de sistema indú y ecuaciones en el siglo IX.

Planilla de Cálculo

Para ilustrar esto, vamos a utilizar la planilla de cálculos Excel y el lenguaje Visual Basic con el algoritmo denominado Bubble Sort u Ordenamiento de Burbuja. Para estudiar los detalles de este y otros algorítmos, les recomiendo que lean algún texto como: “The Art of Computer Programming: Fundamental Algorithms” de Knuth o "C Programming Language" de Kernigan y Ritchie. O alguno similar.

Generación de un conjunto de valores aleatorios

Para la generación de valores aleatorios crearemos un procedimiento llamado "Aleatorios" que completara el rango de celdas A1:A100.

Sub Aleatorios() Dim i As Integer Randomize For i = 1 To 100 Range("A" & Trim(Str(i))).Value = Int(Rnd * 1000) + 100 Next End Sub

Para la representación gráfica, emplearemos columnas y estableceremos dos series, una con los valores aleatorios generados por nuestro procedimiento “Aleatorios” correspondiente al rango A1:A100 y una serie que simplemente reproducirá el mismo valor absoluto pero con signo negativo. Esta última serie corresponde al rango B1:B100.

El Gráfico Inicial

Fig. 1 Valores Aleatorios Desordenados.

El algoritmo más elemental e ineficiente de ordenamiento es el denominado “Bubble Sort” u ordenamiento de burbuja, y recibe este nombre porque al cambiar la posición de los valores, da la impresión de que suelta burbujas.

El método de burbuja

En el método de burbuja, se cuenta con dos bucles que permiten comparar dos valores adyacentes y en caso de que estén fuera de orden, los intercambia. Por cada comparación puede ordenar solamente dos elementos adyacentes. La eficiencia que presenta es n^2 o n en el mejor de los casos (cuando la lista está previamente ordenada).

La subrutina BubbleSort

Sub BubbleSort() Dim i As Integer Dim j As Integer Dim AUX As Integer Dim inicio Range("G1").Value = 0 For i = 2 To 100 For j = 100 To i Step -1 If Range("A" & Trim(Str(j - 1))).Value > Range("A" & Trim(Str(j))).Value Then AUX = Range("A" & Trim(Str(j - 1))).Value Range("A" & Trim(Str(j - 1))).Value = Range("A" & Trim(Str(j))).Value Range("A" & Trim(Str(j))).Value = AUX Range("G1").Value = Range("G1").Value + 1 End If DoEvents ‘Utilizar DoEvents para permitir que Excel actualice el gráfico en "tiempo real" Next Next End Sub

Gráfico Resultante

Fig. 2 El mismo conjunto de valores ordenados.

Hasta la próxima entrega,

Sergio Otaño