7 - Capitulo 5

FUNDAMENTOS DE QBASIC
CAPÍTULO 5
PARA PROGRAMACIÓN DEL PUERTO PARALELO
(Vamos a programar en Qbasic...)
Los primeros pasos: Instalación del software. Grabado de programas.

Tipos de variables en Qbasic. Ingreso de datos por teclado. Sentencias
básicas de programación, lazos, derivaciones. Utilización de la ayuda de
Qbasic. Sentencias para manejo del puerto paralelo. Envío de datos por el
puerto paralelo desde la PC hacia el mundo exterior y viceversa.
OBJETIVOS:
Al completar este tema usted podrá:
Iniciar su programa de Qbasic en su propia computadora.

Hacer las operaciones de abrir, cerrar o guardar un programa.
Ingresar datos por teclado y mostrarlos en pantalla.
Utilizar las sentencias más comunes de programación para la
realización de programas sencillos de procesamiento de datos.
Recurrir a la ayuda de Qbasic para hacer programas más complejos.
Utilizar las sentencias de Qbasic ya sea para enviar datos desde la
PC hacia el mundo exterior, o para ingresar datos a la PC desde el
mundo exterior.
Capítulo 5: Programando el manejo del Puerto Paralelo: Fundamentos de Qbasic – 2001 1

Autor: Ing. Jorge J. Ferrero Bajado de: www.profesormolina.com.ar
Programando el manejo del Puerto Paralelo: Fundamentos de Qbasic
Hemos visto con bastante detenimiento aspectos que hacen al hardware de las PC,
así como una cantidad de detalles acerca de cómo podemos hacer para conectar la
PC con elementos externos a ella y que deseamos controlar.
Pero como ya sabemos, el hardware por sí sólo es completamente inútil, debiendo

ser de alguna manera manejado para que cumpla con los objetivos que nos hemos
propuesto. Para ello, debemos recurrir al software o programas en algún lenguaje
de nuestra elección, que nos permita usar el hardware conforme nuestras necesida-
des.
Cualquier lenguaje de alto nivel es apto para ello, o sea que podríamos usar Pascal,
C, Visual Basic, e inclusive (con mayor dificultad) lenguajes de bajo nivel como el
Assembler.
Entre todos ellos, hemos seleccionado el Qbasic, que es muy sencillo de entender,
muchos niños y jóvenes están familiarizados con él, y además porque viene
conjuntamente con el sistema operativo MS-DOS, de manera que, en muchos casos
sin saberlo, lo tenemos ya instalado en nuestras máquinas.
Otra ventaja del Qbasic, es que trabaja en el entorno DOS, de manera que no
necesitamos tener Windows instalado para usarlo (lo que nos habilita a usar
cualquier vieja PC) y además es perfectamente hábil para el manejo de puertos,
tanto el serie como el paralelo.
Finalmente, el Qbasic tiene muchas características e instrucciones que luego han

adoptado otros lenguajes de programación, de manera que cuando estamos
aprendiendo Qbasic, aprendemos también cosas que nos serán útiles en otros
lenguajes de programación, si luego deseamos estudiarlos.
Breve historia del Qbasic
El Qbasic se origina en el Basic, lenguaje desarrollado en 1975 por Bill Gates y

Paul Allen, cuando todavía faltaba mucho para la aparición de las IBM-PC. Basic
es una sigla que proviene de: Beginner's All-Purpose Symbolic Instruction Code,
que quiere decir, más o menos, "Código de instrucciones simbólicas de propósito
general para principiantes", y tenía aplicación en las primitivas Atari, Comodore y
otras computadoras antecesoras de la PC.
En marzo de 1982, IBM lanzó el primer compilador Basic para sus IBM-PC. Esta
versión fue escrita por Microsoft, usando códigos y métodos desarrollados por Bill
Gates, Greg Whitten, y otros.
El Basic original, por su sencillez y utilidad, tuvo una tremenda aceptación a nivel
mundial, lo que impulsó su posterior evolución. En 1986 nace el Quick Basic 1.0.
con características similares al Basic que tenía en uso IBM, pero esta vez lanzado
directamente por Microsoft. Tanto éxito tiene Microsoft con este lenguaje, que
lanza sucesivamente las versiones 2.0, 3.0, 4.0 hasta que en 1988 lanza el 4.5, que
muchos programadores utilizan aún en la actualidad. Finalmente en 1989
Microsoft saca el Quick Basic 7.0, que al igual que el VBDos (Visual Basic para
DOS), trabajan todos en ambiente DOS. El VBDos, lanzado en el mismo 1989,
utiliza exactamente el mismo código de programación que el Qbasic, pero ya tiene
su nueva interfase con el usuario, que lo hace muy atractivo y que rápidamente
desplaza al Qbasic.
Con el nacimiento del Windows, nace el Visual Basic para Windows, no saliendo
más versiones de Qbasic. En la actualidad se utiliza el Visual Basic 6.0 (para
Windows, obviamente), que tiene posibilidades de programación de interfases PC -
usuario casi inimaginables, pero que paralelamente ofrece algunas dificultades
para programar pues, como es lógico, más completos los programas, más complejo
es manejarlos.
El actual Visual Basic 6.0 tiene todavía muchos elementos del Qbasic, de manera
que eligiendo este lenguaje, quien desee después pasar al Visual Basic, lo podrá
hacer aprovechando los conocimientos adquiridos para el Qbasic.
Tutorial resumido para programación en Qbasic
Instalación
Hay libros completos dedicados a la programación en Qbasic, por lo que se

comprende fácilmente que con la extensión de este curso no podemos experimentar
demasiado con este lenguaje. No obstante, veremos algunos rudimentos como para
"perderle el miedo" y que posteriormente nos permitirán comprender el manejo del
puerto paralelo mediante las pocas sentencias que veremos.
Para comprender y estudiar los siguientes temas, se recomienda fuertemente

hacerlo sentado frente a la PC, e ir experimentando cada una de las lecciones. El
programa para Qbasic se llama Qbasic.exe (en su versión 1.0) y puede encontrarse
en el directorio raíz ó en el directorio del DOS (o en cualquier otro en que se
deseen instalar, ya que no tienen requerimientos especiales de instalación). Es
conveniente contar con estos dos archivos:
Qbasic.exe (195.288 bytes) y Qbasic.hlp (141.049 bytes)
Ambos archivos (Qbasic 1.0) están en castellano y el segundo corresponde a la

ayuda (muy completa) a la que se puede acceder desde el menú principal de
Qbasic. Deben trabajarse desde DOS, aunque si se tiene instalado Windows, se
puede salir al DOS mediante el icono correspondiente y trabajar de esta forma sin
problemas.
Una vez situados en el directorio donde están los dos archivos citados, tecleo
"Qbasic<enter>" (sin comillas) y aparecerá una pantalla con fondo azul y un
mensaje de bienvenida, que me da dos opciones: <enter> para referencia básica
(ayuda) y <escape> para ir a la pantalla de edición. Se recomienda familiarizarse
con la ayuda, y siempre con <escape> podemos pasar a la pantalla de edición. En
este estado de cosas, tenemos la PC lista para comenzar a programar!

Mi primer programa...
Escriba el siguiente programa:
'Este programa ha sido escrito por Juan Perez

CLS 'Esta sentencia es para borrar la pantalla antes de que se escriban
'los resultados de mi programa
PRINT "Hola Juan!"
PRINT
PRINT "Este es mi primer programa!"
END
Ahora elegimos de la barra superior EjecutarÆIniciar <enter> (o lo que es lo

mismo mayúsc+F5) y aparecerá en la pantalla:
Hola Juan!
Este es mi primer programa!

..
..
..
presione cualquier tecla y continúe
Con este primer programa aprendemos algunas cosas interesantes:
En el primer renglón, luego del tilde (que se puede escribir también como
alt+039) hay un comentario que luego no tiene efecto sobre el programa
(podemos probar de borrarlo). Es decir, todo lo que se escriba después del tilde
es ignorado por el compilador. Esto es muy útil para hacer comentarios acerca
de quien o cómo se hizo un programa, qué criterios se usaron, aclaraciones
varias, etc. Además, el tilde se puede poner en el mismo renglón de una
sentencia ejecutable (como CLS), para hacer una aclaración, e igualmente todo
lo que se coloque después del tilde será ignorado por el compilador.
Para pasar de un renglón al siguiente, hay que dar <enter>.
La sentencia PRINT manda a imprimir en la pantalla del monitor todo lo que
se coloque entre las comillas, en forma textual.
La sentencia PRINT sin nada a continuación, manda a escribir un renglón
blanco.
Si se escribe Print ó print en lugar de PRINT, vemos que se cambia todo a
mayúsculas cuando doy el <enter>
Pero si escribo Pint en lugar de Print, no lo cambia a mayúsculas, porque Pint
no es una sentencia conocida para Qbasic, de manera que cuando hacemos un
programa, éste es un primer control para que no cometamos errores de "tipeo".
La sentencia END da por terminado el programa.
Luego que Qbasic ha ejecutado el programa, me da el aviso "Presione cualquier
tecla y continúe", como una forma de avisar que ha concluido con su trabajo.
Probar de colocar un tilde delante de CLS (o sea, hacer ignorar esta sentencia,
es como borrarla) y ejecutar nuevamente el programa un par de veces. Observe
cual es la diferencia. Saque el tilde y vuelva a ejecutar.
Qbasic no reconoce acentos, ni signos tales como ¡ y ¿.

Grabado de programas
Para comenzar un nuevo programa, se debe elegir: archivoÆnuevo <enter>

Tener presente que si se elige abrir un nuevo archivo, se perderá el programa que
en ese momento tengamos en pantalla. Para que esto no suceda, antes de abrir el
nuevo archivo, se debe grabar el que tengamos en pantalla (a menos que no nos
interese perderlo).
Para grabar el programa que tengamos en pantalla, se debe hacer

archivoÆguardar <enter>, o bien archivoÆguardar como <enter> . En ambos
casos, luego de dar <enter>, el programa me pregunta en qué directorio y con qué
nombre deseo guardar el archivo. La extensión por defecto, es .bas, de manera que
si solo escribo el nombre, p. ej. "pepe", en nombre del archivo guardado será
"pepe.bas". Puedo grabar el archivo con otras extensiones, como por ejemplo .txt o
.doc etc, pero cuando uno abre el programa en Qbasic, y se desea abrir un archivo
existente, aparecen en la lista sólo los que tienen extensión .bas. Mediante esta
operación se pueden guardar archivos tanto en el disco duro como en disquetes
Para traer nuevamente a la pantalla un archivo previamente guardado, debo

seleccionar archivoÆabrir <enter> apareciendo en esta oportunidad una lista de
todos los archivos .bas que tengo guardados en el directorio de Qbasic.
Seleccionando el archivo deseado, o haciendo doble click en él, lo traeremos a la
pantalla.
.........................................
Ya sabemos hacer un programa sencillo en Qbasic, y también como guardarlo. Se
recomienda explorar el menú de ayuda de Qbasic para familiarizarnos con su
funcionamiento y contenidos. En él se encuentran detalladas todas las sentencias
de programación de Qbasic, con explicaciones acerca de su utilidad y en muchos
casos con ejemplos de aplicación. Igualmente encontraremos en la ayuda detalle
acerca de todas las operaciones matemáticas y lógicas que se pueden hacer con
Qbasic, como así también las características de las variables que se pueden utilizar.
No es éste el momento de ponerse a estudiar todo el menú de ayuda (que no cunda
el pánico!); la sugerencia es sólo a los efectos de saber que si tenemos una duda,
hay un eficiente menú de ayuda que nos permitirá resolver nuestras dudas en la
gran mayoría de los casos.
Nota importante: Si la computadora que estamos usando no tiene instalado

mouse, o este no funciona por estar trabajando en DOS, para acceder a la barra
de menú del Qbasic, simplemente presionemos la tecla alt y veremos que
quedan resaltadas algunas letras de los títulos de la barra de menú; presionar
esa letra equivale a seleccionar esa parte del menú.
Sigamos con nuestro tutorial resumido:
Uso de variables e ingreso de datos por teclado
Las variables son espacios reservados en la memoria de datos de la computadora,

que nos permiten ir asignando valores y retenerlos durante la ejecución del
programa. Hay dos tipos principales de variables: las variables que pueden tomar
un valor numérico, y las variables string o cadena, que son variables en las que se
puede escribir un texto (por ejemplo, el nombre una persona, dirección, teléfono,
etc., o cualquier otro dato que se exprese en forma de texto)
A su vez, las variables numéricas, se subdividen en cuatro tipos, como se observa
en el cuadro siguiente:
Integer% : puede valer desde -32.768 hasta +32.767

Usadas en (Requiere 2 bytes de espacio de memoria)
números Long&: (entero largo) puede valer desde
enteros -2.147.483.648 hasta +2.147.483.647
(Requiere 4 bytes de espacio de memoria)
Variables Single!: (precisión sencilla) puede valer aprox. desde

Numéricas - 3,402823E+38 hasta 3,402823E+38
(Requiere 4 bytes de espacio de memoria)
VARIABLES Usadas
Qbasic números
decimales ó Double#: (precisión doble) puede valer aprox. desde
de punto - 1,79769313486231D+308 hasta 1,79769313486231D+308
flotante (Requiere 8 bytes de espacio de memoria)
Variables String$ (cadenas de texto) (Puede tener hasta 32.767 caracteres)
Nota1: Los símbolos %, &, !, # y $ suelen usarse como sufijos agregados al

final del nombre de cada variable, a los efectos de tener un código que nos
permita identificar en cada momento el tipo de variable que estamos
utilizando.
Nota 2: Importante Tener muy presente que en EEUU el punto es coma y la
coma es punto, es decir, tres mil se escribe 3,000 y dos coma cinco se escribe
2.5 y así están indicados en la ayuda. Sin embargo, para Qbasic, si deseo
ingresar tres mil como dato, deberé escribir 3000 (sin coma ni punto) y para
dos coma cinco, deberé escribir 2.5. De no proceder de esta forma, el
programa me dará error, o cometerá errores sin advertir.
Nota 3: Las variables se declaran con la sentencia DIM (ver ayuda de Qbasic),
pero si no declaro nada, se asume que todas las variables usadas son single, de
manera que en un programa donde no se hayan DIMensionado las variables,
puedo asumir que todas las variables usadas en él permiten números
decimales, positivos y negativos, con los rangos arriba descriptos.
Probablemente la pregunta que nos haremos sea ¿porqué complicar la cosa con las
distintas variables? (cuando podríamos usar directamente la más grande). La
respuesta está en que la capacidad de manejo de memorias Qbasic no es ilimitada,
por lo que a veces hay "que sacar cuentas" cuando los programas son muy grandes.
En nuestro caso, y para nuestras aplicaciones, podremos trabajar siempre
tranquilos en single, que es la opción por defecto, sin preocuparnos mucho por el
tamaño de nuestros programas.
Como todavía no debe estar muy claro qué son y como se usan las variables,
vamos a hacer algunos ejemplos:
Escribamos el siguiente programa:
CLS
numero = 123
PRINT numero
END

Qué aprendemos con este programa?
Si tenemos la precaución de escribir TODO con minúsculas, cuando demos

<enter> para pasar al renglón siguiente, verificaremos que CLS, PRINT y END
se pasan a mayúsculas (pues son sentencias de programación reconocidas por
Qbasic), mientras que "numero", ha quedado en minúsculas.
Al poner "numero" a la izquierda de un signo igual, Qbasic asume que se trata
de una variable single, por lo que le reserva en la memoria de datos un espacio
de 4 bytes (32 bits) para guardar el valor asignado a "número" a la derecha del
signo igual.
Al ordenar la impresión de "numero", Qbasic lee el valor almacenado para esa
variable (que en este caso puede ser entero o decimal, pues ha reservado
espacio para decimal, y en él se puede escribir un entero sin dificultad), y lo
manda a imprimir.
La sentencia END finaliza el programa
Si ejecutamos el programa, por ejemplo presionando F5 o mediante alguna de las

formas vistas, en la pantalla de la PC aparece: 123
Hagamos ahora este otro programa:
CLS
numero = 123.4567
PRINT numero
END
Si lo ejecutamos, tenemos como respuesta: 123.4567
Hagamos ahora este programa:
DIM numero AS INTEGER

CLS
numero = 123.4567
PRINT numero
END
Si lo ejecutamos, la respuesta es: 123, pues la variable "numero" ya no es

considerada como "single" sino como "integer", y como tal, no admite decimales.
Veamos ahora como puedo ingresar un dato, o lo que es lo mismo, un determinado

valor para una variable. Escribamos el siguiente programa:
CLS
INPUT numero
PRINT "El numero ingresado es "; numero
END
Si ejecutamos este programa, en la pantalla aparece: ? El programa me pide,

mediante este signo, que ingrese el valor que deseo asignar a la variable número,
que ha sido declarada por "INPUT", aunque en realidad esta es la sentencia que
indica que el valor de número va a ingresar por teclado.

Al lado de ? tecleo 123<enter> y aparece en la pantalla: "El numero ingresado es:
123".
Probar ingresando otros números, decimales o no, negativos o no.
¿Qué hemos aprendido?
Ahora podemos ingresar datos por el teclado, que pueden ser guardados por
variables de los tipos conocidos.
Tenemos una forma de verificar que los datos ingresados son correctos,
mediante su impresión en la pantalla.
Mediante la sentencia PRINT, podemos imprimir, además de los valores de las
variables, mensajes textuales, colocándolos entre comillas.
El punto y coma que separa el mensaje textual de la variable, se coloca para
imprimir ambos en el mismo renglón de la pantalla.
Nota importante: En Qbasic cualquier número se puede escribir en forma
decimal, hexadecimal o binario, ya sea para imprimir, ingresar como dato
programar, etc.. Para que Qbasic sepa en qué forma he decido ingresar el
número, se sigue la siguiente convención:
Si no se coloca ningún prefijo Æ el número ingresado o impreso es
decimal.
Si se antepone &H Æ el número ingresado o impreso es hexadecimal.
Si se antepone &O Æ el número ingresado o impreso es octal.
No existe prefijo para binario en Qbasic.
Finalmente escribamos este programa:
DIM nombre AS STRING*20

CLS
INPUT nombre
PRINT "Mi nombre es ";nombre
END
Ejecutando el programa, aparece en pantalla el ? al lado del cual escribo Juan

Perez<enter>. Aparece entonces en pantalla: "Mi nombre es Juan Perez"
Con este programa vemos la forma de ingresar textos, DIMensionando la

variable como STRING (cadena). El *20 le indica a Qbasic cuantos caracteres
tendrá la variable STRING que voy a ingresar (incluyendo los espacios), que en
este caso no podrá ser superior a 20
Sentencias básicas para efectuar programas sencillos en Qbasic
El Qbasic tiene numerosas sentencias para ejecutar programas de distinta variedad,

pero hay algunas pocas que son muy sencillas y de uso frecuente para los fines que
nos hemos propuesto.
Lazos o Loops (FOR...NEXT; GOTO; IF...THEN; DO...LOOP)
Un loop o lazo se utiliza cuando es necesario repetir un conjunto de instrucciones

una determinada cantidad de veces, o en forma indefinida (para siempre).

La primera sentencia para realizar lazos que veremos es FOR...NEXT
Este comando repite todo lo que esté entre el FOR y el NEXT hasta que se cumpla
una determinada condición:
CLS
FOR i = 1 TO 100
PRINT i
NEXT i
END
Si lo ejecutamos, veremos que este programa va a imprimir todos los valores que
tome i desde 1 hasta 100, de uno en uno. Igualmente, si hubiese una serie de
cálculos, con distintos valores de i después del FOR y antes del NEXT, el
programa los ejecutaría uno a uno para cada valor de i. Luego esta sentencia hace
tantos lazos como sean necesarios, incrementando i en uno cada vuelta de lazo,
hasta que se cumple la condición de que i = 100.
El primer valor de i puede ser distinto de uno, y el último distinto de 100.

Igualmente el incremento puede tener cualquier valor entero, positivo o negativo.
Escribamos este otro programa:
CLS
FOR i = 90 TO 100 STEP 2
PRINT i
NEXT i
END
y ejecutémoslo. El resultado nos indica que i comenzó en 90 y se incrementó de

dos en dos hasta llegar a 100. Probar con incrementos negativos (STEP -2) y
veamos qué sucede. Importante: El último valor del contador i que ejecuta el lazo
es menor o igual al límite, o sea que en el ejemplo anterior, el último valor de i
será 100, y después el programa continua con la sentencia inmediata posterior (en
este caso END). Si el ejemplo hubiese sido este:
CLS
FOR i = 91 TO 100 STEP 2
PRINT i
NEXT i
END
el último valor de i hubiese sido 99, pues 99 + 2 = 101, que supera al límite 100.
El lazo FOR...NEXT se utiliza para hacer algo, una determinada cantidad de

veces. Hay otro lazo de uso muy frecuente que es el GOTO, que se utiliza para
lazos infinitos, como veremos más abajo.
El GOTO es de muy fácil utilización y muy bueno para resolver diferentes

situaciones de programación. El único requerimiento es el de rotular (poner rótulo)
la o las líneas hacia donde deseo transferir el flujo del programa con el GOTO. Por
ejemplo, escribamos y ejecutemos el siguiente programa:

CLS
infinito:
PRINT "Este es un lazo infinito"
GOTO infinito
Aquí vemos que el rótulo "infinito:" puede tener en realidad cualquier nombre;
queda identificado como rótulo para Qbasic por el hecho de agregarle los dos
puntos al final.
El inconveniente es que el programa no se detiene nunca, lo cual puede ser útil
en algunos casos, por ejemplo en el relevamiento de datos. Para detener la
ejecución del programa en estos casos, se puede apretar simultáneamente las
teclas Ctrl-Pausa o Ctrl-Break del teclado.
La sentencia GOTO es muy fácil de entender, aunque probablemente no

comprendamos aún su gran utilidad. Para comprender esto, debemos usarla
conjuntamente con la sentencia IF...THEN, que se utiliza en la "toma de
decisiones" del programa. Esto permite la progresión lógica del programa basada
en una condición. IF...THEN es también muy fácil de usar, ya que hace
exactamente lo que significa su traducción (si...entonces). Veamos un ejemplo:
PRINT "Mi primer Menu"

PRINT "Presiona 1 para borrar la pantalla, o 2 para decir Hola!"
INPUT "Qué quieres hacer?"; opcion
IF opcion = 1 THEN GOTO borrar
IF opcion = 2 THEN GOTO hola
borrar:
CLS
PRINT "Terminado."
END
hola:
PRINT "Hola, hola, hola!"
END
Bueno, en este caso son pocas líneas, pero hay mucho que aprender. Analicemos:
Hasta este momento hemos utilizado la sentencia INPUT para ingresar valores
de una variable por teclado, pero no habíamos enviado mensaje a la pantalla
mediante INPUT. Cuando ejecutamos este programa, vemos primero que en la
pantalla aparece el interrogante Que quieres hacer?? con dos signos de
interrogación, dado que el primero es el de la frase que hemos mandado a
imprimir, y el segundo corresponde a la pregunta del valor de la variable
opcion que debemos ingresar (1 ó 2). O sea que INPUT funciona muy parecido
a PRINT, ya que podemos imprimir un mensaje e imprimir (ingresar) el valor
de una variable.
A continuación podemos ver claramente la decisión condicionada que implica
la sentencia IF...THEN, ya que si la variable opcion vale 1 hace saltar el flujo
del programa al rótulo borrar y la sentencia CLS, mientras que si vale 2, salta
al rótulo hola y luego manda a imprimir hola!...etc.
Aunque no se desprende del programa ejemplo, vale advertir que después del
THEN puede colocarse cualquier sentencia válida de Qbasic en lugar del
GOTO. Igualmente puede reemplazarse el "=" (signo igual) por cualquier
símbolo matemático tal como ">" (mayor que), "<" (menor que), "<>" (distinto
a).
Como ejercicio, se sugiere ejecutar el siguiente programa:
CLS
PRINT "Programa Ejemplo-01"
PRINT "Trata de adivinar el numero que estoy pensando, entre 1 y 10."
PRINT "Solo tienes tres oportunidades."
INPUT "Primera oportunidad"; numero
IF numero = 3 THEN GOTO lapegaste
PRINT "Lo lamento!"
INPUT "Segunda oportunidad"; numero
IF number = 3 THEN GOTO lapegaste
PRINT "Vas mal!"
INPUT "Ultima oportunidad"; numero
IF numero = 3 THEN GOTO lapegaste
PRINT "Lastima! El numero era 3!"
END
lapegaste: PRINT "Bravo! Ganaste!"
END
Desafío:
Escriba un programa de adivinanza que le de tres oportunidades para adivinar un

número predeterminado entre 1 y 10. Después de cada oportunidad, si la
adivinanza es incorrecta, haga que el programa le diga al jugador si el número
elegido es muy alto o muy bajo. (Diviértase!!)
Cómo usar la ayuda de Qbasic (Ejemplo con DO...LOOP)
Esta es otra instrucción muy útil, pero como ya tenemos "cierta experiencia" en
programación Qbasic, lo que haremos ahora será reproducir exactamente lo que
dice el menú de ayuda de Qbasic, de manera que no familiaricemos con él y de esta
forma podamos consultar cualquier otra sentencia que no sepamos usar.
Bien, el menú de ayuda dice respecto de DO...LOOP:
Repite un bloque de instrucciones mientras una condición tenga el

estado verdadero, o hasta que una condición adquiera el estado
verdadero.
DO [{WHILE | UNTIL} condición]

[bloqueinstrucciones]
LOOP
DO
[bloqueinstrucciones]
LOOP [{WHILE | UNTIL} condición]
condición Una expresión numérica que Basic evalúa como

verdadero (no cero) o falso (cero).
Ejemplo:
i% = 0
PRINT "El valor de i% al principio del bucle es "; i%
DO WHILE i% < 10
i% = i% + 1

LOOP
PRINT "El valor de i% al final del bucle es "; i%
Vea también <EXIT> <FOR...NEXT> <WHILE...WEND>
Analicemos ahora toda la información que nos da esta ayuda:
Lo que veremos a continuación, lo encontraremos también en el menú de

ayuda, pero como el mismo está en hipertexto, estos apuntes nos servirán de
guía para sacar mayor provecho a tal menú. En el menú de ayuda, si buscamos
en su parte superior, encontraremos tres opciones:
<contenido> <índice> <regresar>
Si damos doble click en la palabra "contenido" (o llevamos hasta ella el cursor

con las flechas y luego damos <enter>) encontraremos en el siguiente menú
cuatro cuadros, uno de los cuales se llama "orientación", y en él,
"convenciones de sintaxis". En este punto encontraremos más información de
lo que veremos a continuación.
Pero volvamos a nuestro DO...LOOP: primero encontramos su definición, o
explicación: "Repite un bloque de instrucciones mientras una
condición tenga el estado verdadero, o hasta que una condición
adquiera el estado verdadero". El "bloque de instrucciones" se refiere a
la porción de programa que se encuentra entre el DO y el LOOP; puede tener
un renglón o muchos, inclusive la misma condición para salir del lazo.
Lo que está entre corchetes [...] ya sea a continuación del DO o del LOOP
(puede ser cualquiera de los dos casos), es un opcional o sea un elemento que
puede o no ir. En caso de ir, tiene dos posibilidades (solo puede usarse una de
las dos) WHILE (mientras) y UNTIL (hasta).
Estas condiciones deben interpretarse conjuntamente con la condición que se
coloca a continuación, que por lo general es una expresión numérica.
Luego se agrega un ejemplo, que siempre es sencillo y aclaratorio. Estos
ejemplos se pueden, mediante el menú de edición, copiar y pegar como
programa en la pantalla de programación, para luego ejecutarlos y ver su
resultado.
Notemos que el "%" después del i, nos indica que esta variable es integer.
Finalmente, al final de cada pantalla de ayuda, se coloca entre <...>, los temas
relacionados al presente y que pueden ser interesantes de ver, aunque no
imprescindible.
Y para terminar, volvamos a nuestro DO...LOOP. Probablemente nos preguntemos

cual es la diferencia entre el DO...LOOP y el FOR... NEXT, siendo que ambos son
lazos. Bueno, el FOR...NEXT se usa cuando conocemos exactamente cuantas
veces debemos repetir una determinada acción del programa, mientras que el
DO...LOOP se repite hasta que se cumple la condición, sin importar cuantas veces
debe repetirse el lazo hasta que esa condición se cumpla.
Analicemos el siguiente ejemplo:
DO UNTIL a = 10
prueba = prueba + 1
PRINT "Prueba numero"; prueba
PRINT
PRINT "Adivina el numero supersecreto!"
INPUT "Arriesga:"; a
LOOP
En este programa se seguirán pidiendo números indefinidamente hasta que se

ingrese el número 10.
Por supuesto, hay siempre al menos dos caminos para hacer todo en cualquier
lenguaje de programación. En el caso de nuestro programa anterior, se podría
haber puesto, en lugar de "DO UNTIL a = 10", "DO WHILE a <> 10", y las cosas
hubiesen funcionado exactamente igual.
Un uso interesante del DO...LOOP es para hacer el clásico "presione una tecla para
continuar" que tantas veces hemos visto. Esto se puede hacer con la sentencia de
Qbasic INKEY$, que me devuelve la tecla presionada en el teclado (ver ayuda de
Qbasic), como se ve en el siguiente ejemplo:
DO WHILE INKEY$ = ""

PRINT "Presione una tecla para continuar"
LOOP
PRINT "Terminado"
END
Y hasta aquí llega nuestro tutorial de Qbasic; no olvidemos que este no es un curso
de Qbasic!! Lo que hemos visto es menos de lo que vamos a usar, pero la idea ha
sido tomar un primer contacto con este lenguaje de programación, y en particular,
tomar conciencia que cualquier sentencia que encontremos en un determinado
programa de Qbasic, podemos saber perfectamente para qué sirve y cómo se usa
mediante el uso de la ayuda. De ahora en más esto haremos cuando tengamos
dudas acerca de un programa, de manera que volvemos entonces al manejo de
nuestro puerto paralelo mediante Qbasic.
Sentencias para manejo del puerto paralelo. Sentencias PEEK, OUT, INP
Lo primero que debemos hacer cuando vamos a utilizar un determinado puerto, es

averiguar su dirección en la RAM de la PC que estamos usando.
Cuando vimos cómo está constituida una PC, hemos analizado uno de los caminos
para averiguar las direcciones de los puertos, mediante Assembler (Ver "Cómo se
averiguan las direcciones de los puertos?" en "Arquitectura interna de una
computadora", pág. 9). Esta forma de hacerlo, aunque sencilla, no puede encararse
desde Qbasic. Si yo quiero manejar puertos desde Qbasic, es necesario que el
mismo programa de manejo de puertos me averigüe las direcciones de los puertos
disponibles, y en todo caso que el programa me interrogue acerca de cual usar, si
hubiese más de un puerto disponible.
Para ello se usan las sentencias DEF SEG y PEEK
DEF SEG define la dirección de segmento de la memoria convencional o de base

(ver pág. 10 de "Arquitectura...") que va a usar las sentencia PEEK para averiguar
una dirección cualquiera. En particular, en el segmento 40h, están las direcciones

de los puertos, tanto serie como paralelo; los bytes 8º y 9º del segmento 40h, me
dan la dirección del LPT1. En consecuencia, si yo programo:
DEF SEG = &H40

adr = PEEK(8) + 256 * PEEK(9)
PRINT adr
END
entonces la pantalla me devuelve 888 = 0378h (o la dirección del LPT1, que puede
no ser esa). Notar que este programa es idéntico a este otro:
DEF SEG = 64
adr = PEEK(8) + 256 * PEEK(9)
PRINT adr
END
dado que 40 hexadecimal = 64 decimal.

Este otro programa también funciona de manera idéntica:
DEF SEG = 0
adr = PEEK(1032) + 256 * PEEK(1033)
PRINT adr
END
Esto se comprende teniendo en cuenta que, como antes se dijo, cada segmento
tiene 16 bytes. Luego, hasta el segmento 40h = 64d hay 64 segmentos (desde el 0
hasta el 63) de 16 bytes cada uno, lo que hace 64 x 16 = 1024 bytes. Pero el LPT1
está en el 8º y 9º byte del 64º segmento, luego en PEEK debo poner 1024 + 8 =
1032 y el siguiente, 1033. De esta manera PEEK me devuelve la dirección del
LPT1.
En todos los casos anteriores, la respuesta era en decimal. Si la quiero en hexadeci-

mal, simplemente debo hacer:
DEF SEG = 0
adr = PEEK(1032) + 256 * PEEK(1033)
PRINT HEX$(adr)
END
y en este caso tendré la respuesta en hexadecimal (devuelve 378). Notar que en la

pantalla aparece 888 en un caso y 378 en el otro. Si el hexadecimal tiene letras
incluidas (desde la A a la F) es fácil reconocerlo, pero no es éste el caso, por lo
que es conveniente sacar por pantalla una aclaración, tal como "La dirección del
LPT1 en hexadecimal es....."
Se recomienda hacer todos estos ejemplos en cualquier PC, por obvios que nos
parezcan!
Finalmente nos queda ver OUT e INP

Estas dos sentencias de Qbasic, son las que nos permiten enviar y recibir datos por
el puerto paralelo. Por supuesto, OUT se utiliza para enviar datos fuera de la PC, e
INP para ingresar datos dentro de la PC.
Tal como hemos dicho en "Arquitectura interna....", pág. 17 (Anatomía del puerto
paralelo), si bien identificamos al LPT1 como 0378h, éste en realidad es el primero
de los 8 registros de 8 bit cada uno que tiene reservados el puerto LPT1. De estos
ocho registros, en nuestro curso sólo utilizaremos los tres primeros, el 0378h,
0379h y 037Ah (o, lo que es lo mismo, si igualamos la variable adr = 888, los tres
registros usados serán adr, adr+1 y adr+2). Notar que adr = 888 es lo mismo que
adr = &H378 para Qbasic.
Estas tres direcciones de registros son las mismas a las que hicimos referencia
como Dirección Base, Dirección Base + 1 y Dirección Base + 2 en los tres
cuadros vistos en las páginas 17 y 18 de "Arquitectura interna....", donde el
primero (Dirección Base) corresponde al Registro de Datos, y como tiene su
origen en la PC, es para enviar datos fuera de ella. El Registro de STATUS
(Dirección Base + 1) tiene su origen en el mundo exterior y se podrá usar para
ingresar datos dentro de la PC, y finalmente el Registro de Control (Dirección
Base + 2), tiene su origen en la PC y por lo tanto sirve también para enviar datos
fuera de ella. NOTA: Cuando decimos "tiene su origen en...", está claro que nos referimos al origen del
sentido del flujo de información, que obviamente puede ser desde PC hacia fuera de ella y viceversa, desde
el mundo exterior hacia la PC).
Luego, en el puerto SPP tomado como unidireccional, usaremos la dirección base y

la dirección base + 2 con la sentencia OUT, para enviar datos fuera de la PC, y la
dirección base + 1, con la sentencia INP, para ingresar datos dentro de la PC.
Envío de datos desde la PC mediante OUT
Para comprender perfectamente este tema, es altamente recomendable disponer de

una PC con su puerto paralelo conectado a 8 leds externos (Registro de datos,
pines 2 a 9 de la ficha DB-25, de la manera y con las precauciones que se han
explicado anteriormente. De esta forma podrá verificarse, mediante el encendido
del led correspondiente, que nuestro programa está funcionando bien.
La ayuda de Qbasic define claramente como se utiliza OUT:
OUT puerto%, datos%
donde puerto% es un número entre 0 y 65.535 que identifica el puerto por donde
quiero sacar los datos de la PC, y datos% es un número entre 0 y 255, que es el
número que saldrá por el puerto cada vez que se ejecute la sentencia OUT.
Y eso es todo! Complicado? Realmente creo que no!! Y para qué sirve? Veamos...
A esta altura es de suponer que todos conocemos la dirección del puerto de la PC

que estamos usando. Como deseo usar el registro de datos, es sólo la dirección de
base, por ejemplo 888d ó 378h (reitero, pueden ser otras según la máquina).
Escribamos este programa:
OUT &H378,255
END
Al ejecutarlo, verificaremos que los 8 leds conectados a los pines 2...9 (o sea el
registro de datos) han encendido, y permanecen encendidos.
Escribamos ahora este otro programa:
OUT &H378,0
END
Al ejecutarlo, se apagan todos los leds y permanecen apagados.

Escribamos ahora este otro programa:
OUT &H378,170
END
Al ejecutarlo, vemos que prenden los leds 2º, 4º, 6º y 8º. Ya nos estamos
imaginando lo que sigue: El número 255d = 1111 1111b; el 0d = 0000 0000b y el
170d = 1010 1010b. O sea que a través del registro de datos del puerto paralelo
puedo sacar de esta manera, en forma binaria, cualquier número comprendido entre
0 y 255 (ya que solo estoy usando 8 bits). De esta forma es que se puede enviar,
por ejemplo, cualquier letra (mediante su correspondiente código ASCII), por
ejemplo, a la impresora (que es para lo que fue creado el puerto paralelo).
Pero más importante aún, para nosotros que queremos controlar el mundo, es que
de esta manera podemos enviar una señal eléctrica (un 1 lógico) o un conjunto de
señales, como consecuencia de la medición de un evento y una determinada
programación (que se puede hacer en Qbasic) para controlar una acción
determinada. Para poder medir un evento, necesitamos saber ingresar datos a la
PC, y esto lo haremos mediante la sentencia INP.
Envío de datos a la PC mediante INP
La sentencia INP es de la forma
INP puerto%
donde puerto% es un número entre 0 y 65535 que indica la dirección del registro
que se debe leer. Como ya estamos imaginando, en nuestro caso, la única dirección
posible que vamos a leer, es la dirección de base + 1 (por ejemplo, &H379), por
ser la única que ingresa datos desde el mundo exterior con la configuración de
puerto SPP unidireccional.
El primer inconveniente con que nos encontramos, es que no tenemos 8 líneas

disponibles(*) para ingresar 8 bits simultáneos, tal como se sacaban los datos
mediante OUT, pero esto no nos debe preocupar pues hay varios caminos para
solucionar este problema, como ya veremos.
(*)
Los bits disponibles en la dirección de base + 1 (Registro de Status), son el 3, 4,
5, 6 y 7 en los pines 15, 13, 12, 10 y 11, respectivamente, como se puede observar
en la tabla correspondiente del registro de Status, pág. 18 de "Arquitectura
interna...."

Nuevamente se recomienda especialmente, para lograr una comprensión completa
de este tema, conectar algunos de los pines arriba mencionados del puerto paralelo,
a interruptores externos de la forma y con las precauciones vistas anteriormente,
para simular la entrada de 1´s y 0´s lógicos a la PC, para poder verificar que
estamos usando correctamente la sentencia INP.
Supongamos entonces que hemos conectado 4 interruptores externos a los pines

10, 11, 12 y 13 de la ficha DB-25 de puerto paralelo, o sea que tendré acceso a los
bits 6, 7, 5 y 4 respectivamente del registro de Status (pág. 19 de "Arquitectura
interna...."). Recordemos que si estos interruptores están abiertos, ponen un 1
lógico en el pin correspondiente, y si están cerrados, un cero lógico. (Páginas 12 y
13 de "Electrónica Básica...")
Aquí las cosas se complican un poco, (pero no desesperen!!). Analicemos: usemos

INP para ver que hay en el registro de Status mediante el siguiente programa:
denuevo:
x = INP (&H379)
PRINT x
goto denuevo
Ejecutando este programa, tendremos un resultado más bien decepcionante, ya que

no podremos explicar el número devuelto en la pantalla (que seguramente será
distinto en distintas máquinas). Sólo podemos verificar que ese número está
comprendido entre 0 y 255 y que presionando algunos de los interruptores que
tenemos conectados (o varios simultáneos), veremos que el número devuelto varía.
¿Y porqué no podemos explicar estos números? Pues simplemente porque ése es el

número de 8 bits que se encuentra en el registro de Status &H379 en el que hay 3
bits, el 0, 1 y 2 que no tienen salida al puerto y que no podemos modificar ni
conocer su valor (al menos, en forma sencilla). Si miramos nuevamente la tabla
del registro de Status (pág. 18 de "Arquitectura interna..."), vemos en ella que no
tenemos acceso a los tres primeros bits. También vemos que los bits 3 a 7 salen por
pines de la ficha DB-25 no correlativos. Todo esto se debe a lo que antes se dijo: el
puerto paralelo se creó para manejar impresoras, y se hizo "a medida". Pero
igualmente sirve perfectamente bien para nuestros fines, como veremos a
continuación.
La solución del problema simplemente consiste en "levantar" bit por bit lo que
ingrese al registro de status, y esto es muy fácil hacerlo mediante la sentencia
AND del álgebra booleana. Después mediante programación, componemos los bits
levantados en función de nuestra conveniencia. Veamos como se hace:
Recordemos que
20 = 1 = 0000 0001 = bit 0 del Reg. de Status

21 = 2 = 0000 0010 = bit 1 del Reg. de Status No interesan, pues no salen al puerto!
22 = 4 = 0000 0100 = bit 2 del Reg. de Status
23 = 8 = 0000 1000 = bit 3 del Reg. de Status (pin15 de la DB-25)
27 = 128= 1000 0000 = bit 7 del Reg. de Status (pin11 de la DB-25)
entonces, haciendo el número levantado del registro AND 8, 16, 32, 64 o 128,
obtendré el estado del bit 3, 4, 5, 6 o 7 correspondiente. Veámoslo haciendo el
siguiente programa:
denuevo:
x = INP (&H379) AND 64
PRINT x
goto denuevo
Si ejecutamos este programa (y si todo anduvo bien), la pantalla me devuelve 64 si

no presiono el interruptor conectado al pin 10 y 0 si lo mantengo presionado. Por
supuesto, si presiono alguno de los otros interruptores, no apreciaré ningún
cambio, ya que este programa sólo releva el pin 10, o sea el bit 6 del registro
&H379.
Aquí se debe interpretar que "64" significa 0100 0000, es decir 1 lógico en el bit 6.
Si me interesa mostrar en la pantalla el 1 lógico o el 0 lógico, simplemente uso este
programa:
denuevo:
x = (INP (&H379) AND 64)/64
PRINT x
goto denuevo
En este caso vemos en la pantalla el 1 sin presionar el interruptor conectado al pin

10 de la DB-25, y el 0 si lo presionamos. Por supuesto, en este caso debemos ver el
programa para saber cual es el pin de entrada que me está dando este resultado.
Tratemos de animarnos de hacer un programa para relevar el estado del pin 13 de

la DB-25, o sea el bit 4 del registro de status (u otros que queramos hacer). Si no
podemos (debemos poder!!!) hacerlo, veámoslo a continuación.
denuevo:
x = INP (&H379) AND 16
PRINT x
goto denuevo
Es obvio que para verificarlo, debemos tener un interruptor conectado al pin 13 de

la DB-25. Como es de esperar, la pantalla nos devuelve 16 (interruptor sin apretar)
ó 0 (interruptor apretado). Y si queremos ver en la pantalla 1 ó 0:
denuevo:
x = (INP (&H379) AND 16)/16
PRINT x
goto denuevo

Actividades Propuestas para el Laboratorio - Taller del
Capítulo 5
El presente capítulo desarrolla todas las actividades conjuntamente con la teoría,
de manera que se recomienda especialmente hacer todos los ejemplos dados, por
obvios que éstos parezcan, a medida que se va avanzando con la teoría.
Advertencia: Para hacer los ejemplos de entrada y salida de datos de la PC, es

necesario conectar el hardware externo. En realidad se pueden programar y correr
todos los programas, pero sin el hardware externo conectado no podremos verificar
los resultados en algunos de ellos.


7 - Capitulo 5

Cargado por

Copyright:

Formatos disponibles

7 - Capitulo 5

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

7 - Capitulo 5

Cargado por

Copyright:

Formatos disponibles

FUNDAMENTOS DE QBASIC

(Vamos a programar en Qbasic...)

Los primeros pasos: Instalación del software. Grabado de programas.

 Iniciar su programa de Qbasic en su propia computadora.

Capítulo 5: Programando el manejo del Puerto Paralelo: Fundamentos de Qbasic – 2001 1

Pero como ya sabemos, el hardware por sí sólo es completamente inútil, debiendo

Finalmente, el Qbasic tiene muchas características e instrucciones que luego han

Breve historia del Qbasic

El Qbasic se origina en el Basic, lenguaje desarrollado en 1975 por Bill Gates y

Tutorial resumido para programación en Qbasic

Hay libros completos dedicados a la programación en Qbasic, por lo que se

Para comprender y estudiar los siguientes temas, se recomienda fuertemente

Qbasic.exe (195.288 bytes) y Qbasic.hlp (141.049 bytes)

Ambos archivos (Qbasic 1.0) están en castellano y el segundo corresponde a la

Capítulo 5: Programando el manejo del Puerto Paralelo: Fundamentos de Qbasic – 2001 3

Escriba el siguiente programa:

'Este programa ha sido escrito por Juan Perez

Ahora elegimos de la barra superior EjecutarÆIniciar <enter> (o lo que es lo

Este es mi primer programa!

Con este primer programa aprendemos algunas cosas interesantes:

Capítulo 5: Programando el manejo del Puerto Paralelo: Fundamentos de Qbasic – 2001 4

Para comenzar un nuevo programa, se debe elegir: archivoÆnuevo <enter>

Para grabar el programa que tengamos en pantalla, se debe hacer

Para traer nuevamente a la pantalla un archivo previamente guardado, debo

 Nota importante: Si la computadora que estamos usando no tiene instalado

Sigamos con nuestro tutorial resumido:

Uso de variables e ingreso de datos por teclado

Las variables son espacios reservados en la memoria de datos de la computadora,

Integer% : puede valer desde -32.768 hasta +32.767

Variables Single!: (precisión sencilla) puede valer aprox. desde

Variables String$ (cadenas de texto) (Puede tener hasta 32.767 caracteres)

 Nota1: Los símbolos %, &, !, # y $ suelen usarse como sufijos agregados al

Escribamos el siguiente programa:

Capítulo 5: Programando el manejo del Puerto Paralelo: Fundamentos de Qbasic – 2001 6

 Si tenemos la precaución de escribir TODO con minúsculas, cuando demos

Si ejecutamos el programa, por ejemplo presionando F5 o mediante alguna de las

Hagamos ahora este otro programa:

Si lo ejecutamos, tenemos como respuesta: 123.4567

Hagamos ahora este programa:

DIM numero AS INTEGER

Si lo ejecutamos, la respuesta es: 123, pues la variable "numero" ya no es

Veamos ahora como puedo ingresar un dato, o lo que es lo mismo, un determinado

Si ejecutamos este programa, en la pantalla aparece: ? El programa me pide,

Capítulo 5: Programando el manejo del Puerto Paralelo: Fundamentos de Qbasic – 2001 7

Probar ingresando otros números, decimales o no, negativos o no.

¿Qué hemos aprendido?

Finalmente escribamos este programa:

DIM nombre AS STRING*20

Ejecutando el programa, aparece en pantalla el ? al lado del cual escribo Juan

 Con este programa vemos la forma de ingresar textos, DIMensionando la

Sentencias básicas para efectuar programas sencillos en Qbasic

El Qbasic tiene numerosas sentencias para ejecutar programas de distinta variedad,

Lazos o Loops (FOR...NEXT; GOTO; IF...THEN; DO...LOOP)

Un loop o lazo se utiliza cuando es necesario repetir un conjunto de instrucciones

Capítulo 5: Programando el manejo del Puerto Paralelo: Fundamentos de Qbasic – 2001 8

El primer valor de i puede ser distinto de uno, y el último distinto de 100.

Escribamos este otro programa:

y ejecutémoslo. El resultado nos indica que i comenzó en 90 y se incrementó de

El lazo FOR...NEXT se utiliza para hacer algo, una determinada cantidad de

El GOTO es de muy fácil utilización y muy bueno para resolver diferentes

Iniciar su programa de Qbasic en su propia computadora.

Nota importante: Si la computadora que estamos usando no tiene instalado

Nota1: Los símbolos %, &, !, # y $ suelen usarse como sufijos agregados al

Si tenemos la precaución de escribir TODO con minúsculas, cuando demos

Con este programa vemos la forma de ingresar textos, DIMensionando la

Lo que veremos a continuación, lo encontraremos también en el menú de

En este programa se seguirán pidiendo números indefinidamente hasta que se