Apuntes Informática II - Año 2001

' Dibujar divisiones de ejes y valores.
DrawWidth = 1
' Ejes Y
For i = 0 To 100 Step 2
CurrentY = i
Line (-2, i)-(0, i), RGB(0, 0, 150)
CONTENIDOS TEORICOS - PRACTICOS DE

If i Mod 10 = 0 Then
Line (-3, i)-(0, i), RGB(0, 0, 150)
INFORMÁTICA II
CurrentX = -14
CurrentY = i + 2
ForeColor = QBColor(2)
Print Format(i /20, "0.0")
End If
(Incluye parte de Informática III)
Line (150, i)-(152, i), RGB(0, 0, 150)
PRELIMINAR Setiembre 2001
Line (150, i)-(153, i), RGB(0, 0, 150)
If i <> 0 And i <> 100 Then
DrawStyle = 2
Line (1, i)-(149, i), QBColor(7)
DrawStyle = 0
End If
CurrentX = 153
CurrentY = i + 2
ForeColor = QBColor(2) Ing. Juan Carlos Ansaldi
Print Format(i / 20, "0.0")
End If
Next i
' Eje X
CurrentX = i
Line (i, -2)-(i, 0), RGB(0, 0, 150)
If i Mod 10 = 0 Or i = 0 Then
Line (i, -3)-(i, 0), RGB(0, 0, 150)
UADER
DrawStyle = 2
Line (i, 1)-(i, 100), QBColor(7)
DrawStyle = 0
End If
CurrentY = -4
CurrentX = i - 3
Print i / 10
End If
Next i
CurrentY = -4: CurrentX = 155: Print "t [Seg]"
' Origen de Coordenadas (0;0) de las curvas a representar
Facultad de Ciencias y Tecnología

CurrentX = 0: CurrentY = 0
Año 2001
Informática II UADER
INDICE
Diagramación lógica: Conceptos..........................................................................5

Introducción................................
Introducción................................................................
................................................................................................
..................................................................................
.................................................. 5
Concepto de Algoritmo y Resolución de Problemas................................
Problemas....................................................
.................................................... 6
Descripción de los algoritmos................................
algoritmos................................................................
.......................................................................................
....................................................... 7
Descripción narrada................................................................................................................. 7
Diagramas de lógica o de flujo ............................................................................................... 7
Los diagramas de flujo y los programas de computación................................
computación ...........................................
........................................... 7
Simbología para diagramación ................................
................................................................
...................................................
................................................... 8
Metodología para el desarrollo de diagramas de flujo................................
flujo ..............................................
.............................................. 11
Prueba de Escritorio ................................................................
................................................................................................
....................................................................
.................................... 11
Ejercicios ................................................................
................................................................................................
.....................................................................................
..................................................... 13
Ambientes de programación visual......................................................................15
Introducción................................
Introducción................................................................
................................................................................................
................................................................................
................................................ 15
Los Ambientes de Desarrollo................................
Desarrollo ................................................................
.......................................................................................
....................................................... 15
Visual Basic, su entorno de trabajo ................................................................
.............................................................................
............................................. 15
Desarrollo de aplicaciones en VB ................................................................
...............................................................................
............................................... 16
Desarrollo de aplicaciones utilizando Visual Basic ................................
......................................................
...................... 19
1. Crear la Interfase ................................................................................................................ 19
2. Configurar las Propiedades ................................................................................................ 20
3. Escribir el Código................................................................................................................ 22
Ejercicios ................................................................
................................................................................................
.....................................................................................
..................................................... 24
Variables y Constantes: Declaración, Tipos, Ámbito y Duración...........................25
Ambito de las Variables en Visual Basic ................................................................
......................................................................
...................................... 25
Ejemplo................................
Ejemplo................................................................
................................................................................................
.......................................................................................
....................................................... 26
Tipos Definidos por el Usuario ................................................................
......................................................................................
...................................................... 26
Funciones y Procedimientos ................................
................................................................
.......................................................
....................................................... 27
Paso de Parámetros................................
Parámetros................................................................
................................................................................................
....................................................................
.................................... 28
Ejercicios ................................................................
................................................................................................
.....................................................................................
..................................................... 28
Convenciones de codificación. Denominación de Variables y Objetos .............29
Por qué existen las convenciones de codificación?................................
codificación?...................................................
................................................... 29
Convenciones de codificación mínimas ................................................................
...................................................................
................................... 29
Directrices para la Denominación de Variables y Objetos .........................................
......................................... 29
Convenciones de nombres de objetos (controles)................................
(controles).....................................................
..................................................... 31
Sugerencias para elegir nombres .......................................................................................... 32
Convenciones de codificación estructurada .............................................................
............................................................. 33
Convenciones de comentarios al código ............................................................................. 33
Dar formato al código............................................................................................................ 34
1 Juan Carlos Ansaldi - Sept. 2001

Estructuras de Selección .......................................................................................35
Estructura Si...Entonces...Sino (If.. Then... Else) .............................................................
............................................................. 35
Select Case ................................................................
................................................................................................
................................................................................
................................................ 36
Estructuras Repetitivas ...........................................................................................38
Introducción................................
Introducción................................................................
................................................................................................
................................................................................
................................................ 38
Tipos de estructuras repetitivas ................................................................
...................................................................................
................................................... 39
1- Ciclo 0-n, Mientras, While-Wend (o Do While) .........................................................
......................................................... 39
2- Ciclos 1-n - Repeat - Do-Until................................
Do-Until ................................................................
..................................................................................
.................................................. 40
3- Ciclo Exacto - For ................................................................
................................................................................................
...................................................................
................................... 41
Ejercicios ................................................................
................................................................................................
.....................................................................................
..................................................... 42
Estructuras de datos: Arrays...................................................................................43
Tipos de Arrays ................................................................
................................................................................................
............................................................................
............................................ 43
Los vectores: arrays unidimensionales ................................................................
........................................................................
........................................ 44
Distintas formas de representación de un vector................................................................... 44
Lectura/Salida de Datos ......................................................................................................... 45
Matrices: arrays de dos dimensiones................................
dimensiones ................................................................
..........................................................................
.......................................... 45
Lectura/Salida de datos ......................................................................................................... 46
Arrays multidimensionales ................................................................
...........................................................................................
........................................................... 46
Declaraciones de arrays. Sintaxis utilizadas en Visual Basic ................................
........................................
........ 46
Array Estáticos......................................................................................................................... 47
Array Dinámicos...................................................................................................................... 47
Métodos de Ordenamiento................................
Ordenamiento ................................................................
........................................................................................
........................................................ 47
Ordenamiento por Selección................................................................................................. 48
Diagrama de Flujo.................................................................................................................. 48
Ejercicios ................................................................
................................................................................................
.....................................................................................
..................................................... 49
Explicación y Resolución Ejercicio 10 - Filtro Promedio Móvil................................................. 50
Archivos en Visual Basic.........................................................................................54

Introducción................................
Introducción................................................................
................................................................................................
................................................................................
................................................ 54
Tipos de Acceso a Archivos ................................................................
........................................................................................
........................................................ 54
Archivos de Acceso Secuencial ................................
................................................................
.................................................
................................................. 55
Abrir archivos secuenciales .................................................................................................... 55
Cerrar archivos secuenciales ................................................................................................. 55
Escribir en archivos secuenciales ........................................................................................... 55
Leer de archivos secuenciales ............................................................................................... 56
Archivos de Acceso Aleatorio ................................................................
.....................................................................................
..................................................... 57
Abrir y cerrar archivos aleatorios............................................................................................. 57
Leer y escribir de archivos aleatorios...................................................................................... 57
Detalle de las Instrucciones y Funciones Utilizadas con Archivos..........................58

1. Open (Instrucción)
(Instrucción)................................
................................................................
................................................................................................
...................................................................
................................... 58
2. Close (Instrucción)................................
(Instrucción)................................................................
................................................................................................
...................................................................
................................... 59

3. Print # (archivo secuencial) ................................................................
....................................................................................
.................................................... 59
4. Write # (archivo secuencial) ................................................................
...................................................................................
................................................... 60
5. Input # (archivo secuencial) ................................................................
...................................................................................
................................................... 61
6. LineInput # (archivo secuencial)................................
secuencial) ................................................................
.............................................................................
............................................. 62
7. Put (archivo secuencial)................................
secuencial) ................................................................
..........................................................................................
.......................................................... 62
9. Get (archivo secuencial)
secuencial)................................
................................................................
.........................................................................................
......................................................... 64
10. Seek (Función)
(Función)................................
................................................................
................................................................................................
.......................................................................
....................................... 66
11. Seek (Instrucción) ................................................................
................................................................................................
..................................................................
.................................. 67
12. LOF (Función) ................................................................
................................................................................................
........................................................................
........................................ 68
13. FileLen (Función) ................................................................
................................................................................................
...................................................................
................................... 68
14. EOF (Función)
(Función)................................
................................................................
................................................................................................
........................................................................
........................................ 68
Acceso a una Base de Datos ...............................................................................68
El Control Datos................................
Datos................................................................
................................................................................................
...........................................................................
........................................... 68
Utilidades Adicionales ................................................................
................................................................................................
.................................................................
................................. 69
Bibliotecas Dinámicas. Comunicaciones DDE. Comunicación entre Aplicaciones
OLE2 ......................................................................................................................71
Enlaces Dinámicos y Comunicaciones DDE................................
DDE ...............................................................
............................................................... 71
Crear Enlaces DDE Durante el Diseño (Utilización del Portapapeles) ..................................... 72
Los Sucesos DDE .................................................................................................................... 72
Los Métodos DDE.................................................................................................................... 72
Incrustación y Comunicación entre Aplicaciones. OLE2 ............................................
............................................ 72
Terminología OLE .................................................................................................................... 73
Ejemplo (Crear un objeto durante el diseño) ......................................................................... 73
Ejemplo (Crear un objeto durante la ejecución).................................................................... 74
¿Qué es un control ActiveX? ................................................................
.......................................................................................
....................................................... 74
Aplicaciones de control automático basadas en Visual Basic.............................75
Introducción................................
Introducción................................................................
................................................................................................
................................................................................
................................................ 75
Nuestra primer aplicación orientada al control ..........................................................
.......................................................... 75
Desarrollo de la aplicación................................
aplicación ................................................................
.........................................................................................
......................................................... 75
1. Crear la Interfaz ................................................................
................................................................................................
......................................................................
...................................... 76
2. Configurar las propiedades ................................................................
....................................................................................
.................................................... 77
3. Escribir el código ................................................................
................................................................................................
....................................................................
.................................... 77
Configuración de la placa de adquisición ................................................................
................................................................ 80
Alarma configurable de máxima y mínima temperatura................................
temperatura...........................................
........................................... 80
Control ON-OFF
ON-OFF................................
................................................................
................................................................................................
...........................................................................
........................................... 82
Gráfico en tiempo real de la temperatura ................................................................
.................................................................
................................. 84
Curva de temperatura a graficar........................................................................................... 86
Guardar la configuración en un archivo
archivo................................
................................................................
.....................................................................
..................................... 87

Archivo de datos que permita registrar la variación de variables de entrada y salida88
salida88
Comunicaciones Serie. El Control Communications ............................................90
Introducción................................
Introducción................................................................
................................................................................................
................................................................................
................................................ 90
Fundamentos de la comunicación serie............................................................................... 90
Establecimiento de la conexión serie ................................
................................................................
.........................................
......................................... 90
Apertura del puerto serie ........................................................................................................ 90
Establecimiento de las propiedades de los búferes de transmisión y de recepción en
tiempo de diseño ................................................................
................................................................................................
.......................................................................
....................................... 91
Asignación de memoria de búfer.......................................................................................... 91
Las propiedades RThreshold y SThreshold............................................................................... 91
Las propiedades InputLen y EOFEnable................................................................................. 91
Administración de los búferes de recepción y transmisión ................................
.........................................
......... 91
El búfer de recepción............................................................................................................. 91
El búfer de transmisión............................................................................................................ 92
Protocolo ................................................................
................................................................................................
....................................................................................
.................................................... 92
El evento OnComm y la propiedad CommEvent ......................................................
...................................................... 92

Diagramación lógica: Conceptos
Introducción
Veamos el siguiente problema cuyo enunciado es el siguiente:
Tenemos un mazo de cartas y deseamos encontrar el “ancho de espadas”. Cuál sería la “forma
lógica” de hacerlo?
Como estamos hablando de una forma lógica, tendríamos que describir una secuencia de pasos que
nos permita llegar al resultado deseado. Esto es lo que haremos a continuación:
1 Comenzar
2 Contar que haya 40 cartas en el mazo
3 Decidir si hay cartas a sacar
Si la respuesta es SI, ir a 4
Si la respuesta es NO, mostrar que no se encontró la carta e ir a 6.
4 Tomar una carta
5 Decidir si es el ancho de espadas
Si la respuesta es SI, mostrar la carta e ir a 6
Si la respuesta es NO, restar 1 a la cantidad de cartas e ir a 3
6 Fin
Lo que tenemos en los 6 pasos anteriores es la solución del problema en forma de un algoritmo, el
cual ha sido descrito de manera narrada que es una de las formas más antiguas y de más fácil
redacción, dado que no requiere mayor entrenamiento previo. Sin embargo, el lenguaje natural es
impreciso, y puede dar lugar a confusiones, sobre todo por la capacidad de síntesis y de
“organización mental” que pueda o no tener quien confecciona tal descripción.
Por lo tanto, hay otro tipo de herramienta que nos permite resolver el mismo problema pero ahora
en forma gráfica y que es el diagrama de flujo.
El diagrama de flujo o de lógica muestra a través de símbolos gráficos, el desarrollo lógico de un
algoritmo. Esta forma permite representar información y operaciones; y su visualización y
seguimiento con mayor facilidad.
A continuación se representa en la Figura 1 el algoritmo narrado en los seis pasos anteriores, por
medio de un diagrama de flujo.
A la derecha, encerrados entre círculos, se indican los pasos que corresponden, numerados del 1 al
6, a la “receta” narrada anteriormente.
Vemos que ahora nos independizamos de la características propias que tiene cada uno de nosotros
para expresar los pasos a seguir y “normalizamos” la representación por medio de símbolos
gráficos.
Otra manera de representación de un algoritmo, es por medio de pseudocódigo, que lo podríamos
definir como una descripción narrada normalizada, en la cual estaríamos utilizando siempre las
mismas palabras claves para representar las operaciones de acción y/o decisión.

1 Comienzo
Numero
2
de Cartas = 40
Hay más
cartas para
No sacar ?
4 Si
Tomar
una
No salió carta Numero de
el ancho Cartas <- Nro de
de espada Cartas - 1
No
Es el ancho
5 de
espadas ?
Si
Mostrar la
carta
6 Fin
Figura 1 - Diagrama de flujo del problema anterior
Concepto de Algoritmo y Resolución de Problemas

“Un algoritmo es una secuencia de pasos que deben desarrollarse observando un orden
rigurosamente preestablecido, a los efectos de lograr la solución de un problema dado”.
Es necesario enfatizar, que los pasos integrantes de un algoritmo, para que éste cumpla su misión,
deben ser expresados con claridad y exentos de ambigüedades.
El desarrollo de un algoritmo, en las condiciones mencionadas más arriba, constituye una de las
etapas preliminares fundamentales para la preparación de un programa de computación. En
general, las computadoras pueden resolver problemas en la medida en que los elementos
componentes del mismo sean identificados con precisión y que las instrucciones que se le
proporcionen no contengan ambigüedades o definiciones imprecisas o alternativas no
contempladas y de posible presentación.

Descripción de los algoritmos
Al explicar el concepto de algoritmo, se enfatizó en la necesidad de que los pasos del mismo deben
ser expresados con claridad, precisión y sin ambigüedades. El cumplimiento de estas premisas
repercutirá directamente en la preparación del programa de computación, del cual el algoritmo es
una etapa previa. Por otra parte, será también un elemento importante de la carpeta de
documentación del sistema al cual pertenezca el programa en cuestión.
Existen distintas maneras de descripción de algoritmos. Nos referiremos a continuación a la
descripción narrada y luego a los diagramas de flujo.
Descripción narrada
Es una de las formas más antiguas y de más fácil redacción, dado que no requiere mayor
entrenamiento previo. Sin embargo, el lenguaje natural es impreciso, pues quien lo ejerce presume
que aquel que está capacitado para interpretar el sentido del texto que se transmite a través de la
narración y que en caso de duda, sabrá utilizar su capacidad de raciocinio y encontrar la magnitud
o el término preciso a aplicar.
La forma de descripción narrada, en razón de las imprecisiones señaladas en el párrafo anterior,
genera el peligro de mal interpretación o de omisión de información, todo lo cual concluye en
errores en el momento de la programación.
Diagramas de lógica o de flujo

La expresión gráfica siempre ha sido un auxilio importante para el buen entendimiento de
instrucciones que deben ser cumplidas para arribar a una solución.
El diagrama de flujo o de lógica muestra a través de símbolos gráficos, el desarrollo lógico de un
algoritmo. Esta forma permite representar información y operaciones y su visualización y
seguimiento con mayor facilidad.
El diagrama de flujo expresa el comienzo y fin de un proceso, la entrada de datos y salida de
información, y también todas las operaciones aritméticas y lógicas que se efectúan, en la secuencia
en que todas esas funciones se deben cumplir.
Como el diagrama de flujo expresa el comienzo y fin del proceso, se suele utilizar en el lenguaje
en que hablan los expertos de sistemas la expresión “lógica del proceso”.
Se refieren, en este caso, a la totalidad de la lista de instrucciones componentes de un programa,
que prevea todas las posibilidades o alternativas que puedan presentarse, y que deben ser
contempladas dentro de este proceso. El diagrama de flujo, evidentemente gráfica la lógica de este
proceso.
Los diagramas de flujo y los programas de computación

Deseamos insistir en hacer resaltar la relación entre estos dos conceptos, alguno de cuyos
elementos ya fueron expuestos. Un diagrama de flujo es una representación gráfica de las
operaciones lógicas que deberá desarrollar un programa. y un programa es un conjunto de
instrucciones que indica a la computadora que operaciones se deberán realizar para poder convertir
la entrada en salida. Los diagramas de lógica se formulan antes que los respectivos programas,
porque ayudan al programador en la organización del flujo de los datos que es necesario para crear
el programa. En realidad, una vez completado el diagrama de lógica, el programador procede a
codificar el programa, esto es, escribir instrucciones codificadas.
Generalmente, las instrucciones que componen un programa indican la manera en que se deben
operar los campos de datos. El contenido de la entrada y de la salida es variable, por lo tanto no
está especificado dentro del programa: cambia según se valla leyendo cada nuevo registro o se
vaya creando cada nuevo registro de salida.
En general, los programas se formulan para tratar datos variables. No obstante debe preverse que
existen situaciones en las que, para obtener una determinada salida, debe recurrirse, dentro del
programa, a valores constantes. Una constante es, entonces un valor previamente definido,
incorporado a un programa, necesario para la obtención de la salida, pero no integra los datos de
entrada.

El diagrama de flujo, cuando se lo utiliza en operaciones de computación, permite obtener las
siguientes ventajas:
1- Lograr mayor claridad expositiva, principalmente cuando los algoritmos a los cuales representa
gráficamente poseen cierto grado de complejidad.
2- Habilitar al programador para desarrollar la solución de un problema en forma ordenada, paso a
paso, secuencialmente.
3- Trazar un plan para la instrucción de la computadora y para facilitar la comunicación de dicho
plan a las personas.
4- Disponer de un panorama total de la solución del problema que se intentó resolver.
5- Verificar si han sido completadas, al diseñar el diagrama, todas las alternativas de posible
presentación.
6- Posibilitar el análisis (prueba de escritorio) y detectar errores de lógica.
7- Servir de elemento fundamental de apoyo para efectuar la codificación de las instrucciones. Así
como un arquitecto diseña un plano antes de iniciar la construcción de un edificio, un programador
dibuja un diagrama de flujo antes de codificar las instrucciones de un programa.
8- Integrar la carpeta de documentación de programas para consultas en caso de modificaciones o
correcciones de los mismos.
En síntesis, el empleo de la táctica de diagramación lógica permite la integración lógica de las

diversas etapas de procesamiento electrónico de datos.
El éxito en la formulación del procesamiento con computadoras no depende tanto del
conocimiento de las reglas de programación (codificación), sino de la interpretación precisa del
flujo lógico de datos. Así como un plano muestra la disposición de las unidades que componen o
compondrán un edificio y de las relaciones entre ellas, un diagrama de flujo expone, dentro de un
programa, las funciones que este debe ejecutar y sus interrelaciones lógicas.
Simbología para diagramación

Un diagrama de flujo contiene dos tipos de elementos:
Los bloques, que indican pasos del proceso o funciones de los programas.
Las líneas de dirección o flechas que comunican los bloques y determinan el orden secuencial en
que deben ser considerados.
Los bloques pueden representar acción o decisión. Los bloques de acción representan una
actividad: efectuar una operación aritmética entre dos números, convertir un valor en cero, etc.
Su descripción implica siempre un verbo (hacer algo): sumar, transferir, borrar, etc.
Un bloque de decisión es una forma de expresar una consulta acerca del cumplimiento o no de una
determinada condición o alternativa. Según sea la respuesta que se dé a dicha consulta (cierto o
falso) se seguirán diferentes caminos.
Un diagrama de flujo para programación se lee de arriba hacia abajo; sin embargo, esa dirección
puede alterarse cuando se representa una decisión, la que podría provocar un cambio en la
secuencia.
Veamos a continuación la simbología que se utilizan en la confección de los diagramas.

Nos basaremos en la norma IRAM Nº 36002 “Procesamiento electrónico de datos: Símbolos para
la representación Gráfica”, la cual reconoce como antecedente el documento ISO 1 028-1973.
Terminal ó Extremos de Interrupción: Representa los pasos de comienzo y fin o un punto en

que el proceso se interrumpe para tomar una acción.
En la práctica éste será el primer y último símbolo a dibujar en cada diagrama de flujo.

Decisión: Representa la situación en que el proceso puede seguir diferentes caminos, que
dependen del resultado de una prueba, una comparación o la existencia de alguna condición. El
símbolo de decisión debe utilizarse cuando durante el procesamiento de un programa es necesario
elegir entre alternativas, de acuerdo a condiciones lógicas. Por lo general, las decisiones surgen de
efectuar comparaciones.
Proceso: Representa cualquier función de procesamiento, por ejemplo la función de ejecución de

una operación definida o grupo de operaciones que dan por resultado un cambio de valor, forma o
ubicación de la información.
En los diagramas de flujo, el símbolo de proceso admite representar una o más operaciones: sumar,
restar, dividir, multiplicar, transferir. Se trata de operaciones que no implican decisiones.
Entrada/Salida: Representa la función de entrada de datos o salida de información,

indistintamente.
Entrada manual: Representa una función de entrada en la cual la información se introduce

manualmente cuando lo requiera el procesamiento.
Proceso predefinido: representa un proceso que consiste en una o más operaciones o pasos de
programa que se especifican en otro lugar. Puede estar en la forma de procedimiento, función
definida por el usuario, subrutina, etc.
Operación Manual: representa cualquier proceso fuera de línea realizado a la velocidad del
operador.
Almacenamiento en línea: Representa una función de entrada / salida que utiliza información
almacenada que se encuentra bajo el control directo de la unidad de procesamiento.
Disco magnético: Representa una función de entrada salida en la cual el medio es un disco
magnético.
Operación auxiliar: Representa una operación fuera de línea, realizada con equipos que no se
encuentran bajo el control de la unidad de procesamiento central.

Terminal (Comienzo o Fina
Decisión (Salto Condiciona
Proceso (Operación
Operación de Entrada / Salid
Entrada Manua
Salida en forma de documen
Salida por pantal
Proceso Predefinido
(Procedimiento, función
subrutina)
Conecto
Operación manual
realizada fuera de líne
Proceso de Ordenamien
Función de Entrada /Salid

por Disco Magnetico
Almacenamiento en líne
Operación Auxilia
Figura 2 - Simbología para la diagramación

Metodología para el desarrollo de diagramas de flujo
Veamos a continuación una sencilla metodología que sirva de orientación para la resolución de
planteos que impliquen el desarrollo de diagramas de flujo.
1. Todo problema se presenta a través de la exposición de un planteo. Leer todo el planteo, desde
el principio hasta el final.
2. Interpretar con precisión que es lo que se pretende como resultado: en cuanto a salidas impresas,
grabadas, etc. y en cuanto a procesamiento aritmético y lógico.
3. Detectar la existencia de omisiones o contradicciones notorias. Subsanar esas falencias.
4. Identificar todos los elementos que constituyen salidas.
5. Identificar todos los elementos que constituyen entradas (datos variables).
6. Identificar todos los elementos que constituyen datos fijos de entrada: aquellos que figuran
como constantes en el planteo del problema.
7. Identificar y analizar procedimientos y fórmulas a través de los cuales se intenta la
transformación de las variables y constantes intervinientes en el planteo en salidas.
8. Verificar que todos los elementos de salida sean obtenibles a partir de los registros de entrada o
de los archivos y de los datos fijos o constantes de entrada.
9. Ubicar el planteo del problema dentro del módulo correspondiente según el esquema
metodológico presentado en el texto, a fin de facilitar la elección del curso de acción a seguir para
alcanzar su resolución.
10. Definir si es necesario establecer uno o más campos en el almacenamiento interno para
utilizarlos como contadores y/o acumuladores.
11. Agrupar las funciones que se realizan por única ves al comienzo del proceso. Por ejemplo:
lectura de parámetros, puesta a cero de acumuladores y contadores, etc.
12. Agrupar las funciones que se realizan por única ves al final del proceso. Por ejemplo: calcular
totales finales, impresión de resultados, etc.
13. Agrupar las funciones que constituyen un ciclo principal, el o los elementos que establecen la
cantidad de veces que deberá ejecutarse.
14. Agrupar las funciones que constituyen ciclos secundarios, definiendo el o lo elementos que
establecen la cantidad de veces que deberán ejecutarse.
15. Ordenar las funciones de una secuencia lógica.
16. Verificar que todos los conectores o líneas de unión de símbolos se encuentran debidamente
sincronizados.
17. Efectuar la prueba de escritorio. Verificar que el diagrama realizado cumple con lo solicitado
en el planteo, utilizando para ello datos de prueba. Analizar cómo van evolucionando los
contadores y acumuladores a medida que se computan los datos de prueba.
18. Verificar que se han contemplado, en el desarrollo, todas las alternativas posibles de datos de
entrada, sin olvidar excepciones.
Prueba de Escritorio
Los puntos 17 y 18 de la metodología anterior, están basados en la prueba de escritorio.
Luego de finalizado el diagrama de flujo, existe una manera, sin utilizar la computadora, de
determinar si el mismo es correcto o si adolece de errores de lógica u omisión de alternativas de
posible representación, y que no fueron contempladas en el diagrama: la prueba de escritorio.
Esta prueba consiste en simular un proceso utilizando el diagrama formulado, sobre el cual se
aplican sucesivamente diferentes datos y comprobamos las transformaciones que se realizan sobre
ellos, verificando los resultados obtenidos.

Ejemplo: “Ingresar tres números enteros diferentes y mostrarlos en orden decreciente en la
pantalla.”
Veamos la resolución del problema:

El planteo del problema está bastante acotado, ya que se identifican claramente las entradas y el
tipo de dato de entrada a utilizar. También quedan definidos en forma implícita el tipo de datos de
la salida. No se detalla la manera de ingresar los datos, asumiendo por la sencillez del problema
que se ingresarán a través del teclado. En casos más complejos, en los cuales se presenten este tipo
de omisiones, se debe especificar el origen de los datos. En cuanto a la salida, se especifica
claramente que los resultados se deben mostrar por pantalla.
Las entradas que se identifican son 3 números enteros diferentes. Como veremos más adelante, es
necesario tener un criterio para nombrar variables y constantes. En nuestro caso se trata de tres
variables de tipo enteras que llamaremos iNum1, iNum2 e iNum3 (la i al comienzo del nombre de
la variable, indica que se trata de una variable entera “integer”). Se han definido tres variables de
salida que se las ha llamado menor, medio y mayor.
La resolución adoptada para el problema, plantea la comparación de dos números a la vez.
1
Comienzo
menor
medio
mayor
iNro1<-
iNro2<-
iNro3<-
Fin
F
iNro1<iNro2?
V F
iNro2<iNro3?
F
iNro1<iNro3? menor<-iNro3
V medio<-iNor2
mayor<-iNro1
V menor<-iNro3
medio<-iNor1
mayor<-iNro2 1
1
F
F
iNro2<iNro3?
iNro1<iNro3?
menor<-iNro2
V menor<-iNro1 medio<-iNor3
medio<-iNor3 V mayor<-iNro1
mayor<-iNro2
menor<-iNro1 menor<-iNro2
medio<-iNor2 medio<-iNor1 1
mayor<-iNro3 mayor<-iNro3
1
Figura 3 - Diagrama de flujo del ejemplo

Veamos los elementos utilizados en el desarrollo del diagrama. La lectura de los datos no se
realiza directamente, sino que se ha indicado previamente la transferencia de los mismos a una
zona de lectura. Esto es debido a que se ha utilizado el símbolo que
iNro1<- representa una operación de entrada/salida y no el símbolo de entrada
iNro2<- manual, y por lo tanto se deja expresado de que se trata de un ingreso de
iNro3<-
datos. Dicha transferencia se representa por medio de una flecha (<-). Esta
modalidad también se utiliza para la asignación de datos, como en el
menor<-iNro3
siguiente ejemplo: iCont <- 0 En este ejemplo, asignamos (transferimos) el
medio<-iNor2 valor 0 a la variable iCont. En una notación matemática equivaldría a
mayor<-iNro1 iCont=0.
En nuestro ejemplo también se dan procesos de asignación de datos entre
Figura 4
variables, los cuales se han representado por medio de una flecha.
Los conectores 1 se han utilizado en el diagrama para obtener una presentación más
ordenada y menos confusa.
El diagrama de la figura 3, es una de las opciones de resolución al problema planteado. Veremos
ahora si funciona utilizando la denominada prueba de escritorio. Utilizaremos tres números
enteros 1, 2 y 3 y los probaremos en las 6 combinaciones posibles.
Nro de Variables de Entrada Variables de Salida Impresió

n
Prueba iNum1 iNum2 iNum3 menor medio mayor
1 1 2 3 iNum1=1 iNum2=2 iNum3=3 123
2 1 3 2 iNum1=1 iNum3=2 iNum2=3 123
3 2 3 1 iNum3=1 iNum1=2 iNum2=3 123
4 2 1 3 iNum2=1 iNum1=2 iNum3=3 123
5 3 1 2 iNum2=1 iNum3=2 iNum1=3 123
6 3 2 1 iNum3=1 iNum2=2 iNum1=3 123
En este caso, la prueba de escritorio resulta muy sencilla, ya que a no existir variables intermedias,
ciclos ni operaciones, solamente se debe recorrer uno de los caminos posibles y comprobar la
salida.
Ejercicios
Realizar los algoritmos que nos permitan resolver los problemas planteados en los enunciados que
se dan a continuación. Realizar la prueba de escritorio para comprobar el funcionamiento del
algoritmo planteado.
1- Ingresar un número natural y clasificarlo como par o impar.
2- Ingresar veinte números naturales. Contar cuantos son pares, cuál es el mayor valor ingresado y
en que posición se ingreso.
3- Crear una tabla de conversión de grados Fahrenheit a grados Centígrados que incluya
temperaturas negativas.
4- Realizar un algoritmo que muestre todos los números divisibles comprendidos entre cero y un
número de tres cifras que se debe ingresar.
5- Escribir un algoritmo que calcule el factorial de un número. Evaluar posibles errores del
operador.
6- Ingresar un número natural y mostrar en forma creciente todos los anteriores a él.
7- Escribir un algoritmo que obtenga los números pares hasta el dos mil inclusive.
8- Escribir un algoritmo que muestre todos los números divisibles por trece entre cero y un número
de tres cifras a ingresar por el teclado.
9- Representar el algoritmo de Euclides por medio de un diagrama de flujo. Comprobarlo
realizando la prueba de escritorio para determinar el mcd(8069,5209) y el mcd(1651,2353).


Ambientes de programación visual
Introducción
Desde los inicios de la informática a gran escala, cuando las primeras computadoras personales
ingresaron en la vida de las universidades, empresas y algunos hogares, el acceso a este mundo
estuvo vedado a la gran mayoría de la gente común. Hace poco más de 15 años comenzamos a ver
la aparición de computadoras de distintas marcas y tipos, Sinclair Spectrum, TK, TI-99,
Commodore y muchas otras, entre ellas la PC de IBM. De la mano de IBM llegó Microsoft, cuyo
sistema operativo Windows, corriendo sobre una PC, se ha transformado en el estándar indiscutido
del mercado. La combinación PC + Windows permitió el ingreso de la informática a todos los
hogares y escuelas, convirtiendo a un artículo de lujo en una necesidad.
Aún así, hasta hace pocos años, existió una clara división entre la gente que utilizaba una
computadora: Por un lado estaban los programadores, y por el otro, los usuarios; unos haciendo
programas que los otros utilizaban. La división fue clara desde el principio y el desarrollo de
aplicaciones estuvo siempre vedado a los usuarios, dado que siempre requirió una gran experiencia
y mucho tiempo de trabajo arduo.
Pero la historia volvió a cambiar, y lo hizo nuevamente de la mano de Microsoft. A comienzos de
los 90 apareció Visual Basic (desde ahora, VB), un nuevo tipo de lenguaje de programación. Se le
llamó Desarrollo Visual, o Ambiente de Desarrollo Visual para bautizar un estilo de programación
desconocido hasta entonces, consistente más que nada en arrastrar y soltar, configurar y... bueno sí,
también tipear algo de código. Inmediatamente esta nueva filosofía ganó adeptos, no sólo entre el
público sino en el mercado de herramientas de desarrollo, y así aparecieron varios Ambientes de
Desarrollo que emularon la fórmula del éxito.
Gracias a estas nuevas herramientas, cualquier persona sin experiencia en programación está en
condiciones de crear aplicaciones vistosas y potentes en cuestión de horas.
Los Ambientes de Desarrollo

VB de Microsoft, Delphi de Borland, PowerBuilder de PowerSoft y muchos otros, son Ambientes
de Desarrollo (AD). En VB el lenguaje utilizado es Basic, en Delphi es Pascal, pero más allá del
lenguaje de programación, lo que estos ambientes tienen en común es la filosofía de orientación a
objetos y a eventos. En todos ellos, usted puede crear rápidamente y sin mucho esfuerzo
aplicaciones atractivas y útiles que se ven y se sienten como Windows; justamente debido a la
velocidad con que permiten obtener resultados también se les suele llamar Sistemas RAD (Rapid
Application Development). Utilizando un AD es sencillo explotar cualidades importantes de
Windows, como interfases gráficas al usuario (GUI) amigables, acceso a bases de datos, OLE
(Object Linking and Embedding), DDE (Dynamic Data Exchange), soporte de redes, acceso a
Internet, etc. Pero por encima de todo, la ventaja de los AD que se destaca es su posibilidad de
incorporar controles personalizados (custom controls) del tipo ActiveX u OCX; por este motivo a
menudo se los denomina también “contenedores”. Esta prestación expande notablemente su
potencia y los convierte en herramientas ideales para tareas que a veces aparentar ser muy
disímiles.
Visual Basic, su entorno de trabajo

El ejemplo de Ambiente de Desarrollo por excelencia es, por supuesto, VB; en adelante lo
tomaremos como referencia sabiendo que el 95% de lo que se indique es válido para otros
ambientes.
Luego de ejecutar VB se inicia su entorno de trabajo como se observa en la Figura 5:

Figura 5 - Ambiente de Trabajo de V Basic

Este entorno está compuesto de varias ventanas, todas ellas independientes entre sí excepto
respecto de la principal (aquella que contiene el menú) ya que al minimizar ésta o cerrarla, el
efecto se propaga en las demás.
Barra de herramientas y barra de menú: Brinda un acceso rápido a comandos de uso común en el
AD. Los botones representados en la barra de herramientas tienen su equivalente en la barra de
menú y en algunos casos, tienen atajos de teclado (hot-keys).
❏ Formulario: Es la ventana en donde se desarrolla la interfase de la aplicación. En ella se

disponen los controles gráficos e imágenes que le brindan al programa sus prestaciones y
apariencia final.
❏ Caja de herramientas: Provee los controles que en tiempo de diseño se colocan sobre el
formulario.
❏ Ventana de proyecto: Contiene la lista de los archivos que componen el proyecto.
Normalmente estos archivos son de tipo formulario (.FRM) o módulos de procedimientos
(.BAS).
❏ Ventana de propiedades: En esta ventana se pueden leer y modificar las propiedades de los
objetos incluidos en el proyecto.
Desarrollo de aplicaciones en VB
Construir la primera aplicación en VB toma sólo unos minutos. El procedimiento para el desarrollo
de aplicaciones se resume siempre en estos tres pasos:
❏ Desarrollo de la interfase gráfica, casi siempre sólo arrastrando y soltando o “dibujando” con
el mouse. En esta etapa se incorporan los objetos (controles) que se utilizarán en la aplicación.
❏ Configuración de propiedades de los objetos, que definen su apariencia y comportamiento.
❏ Programación de los eventos de la aplicación, que le permiten a la interfase gráfica responder
al usuario y a otros tipos de sucesos.
Una vez concluido el desarrollo de la aplicación el último paso consiste en compilarla; el resultado
es esta operación es un archivo .EXE en el cual está contenido todo el programa. Este archivo
ejecutable, junto a muy pocos archivos auxiliares (DLL, OCX y otros) es lo que se debe distribuir
en caso de que se desee entregar la aplicación a otra persona.
Antes de continuar conviene aclarar algunos conceptos que se utilizan permanentemente y que
definen la filosofía de programación dentro de VB:

Proyecto: Para crear una aplicación en VB, el usuario trabaja con proyectos. Un proyecto es el
conjunto de todos los archivos que componen una aplicación. Existen varios tipos de archivos,
pero los de uso más frecuente son:
❏ Formularios, listado de procedimientos en formato de texto (.FRM)
❏ Formularios, imágenes en formato binario (.FRX)
❏ Módulos de procedimientos (.BAS)
❏ Archivo de proyecto (.VBP). Este archivo sólo contiene una lista referencias al resto de los
archivos asociados al proyecto. Generalmente está acompañado con otro archivo de extensión
.VBW que contiene información sobre las opciones de entorno y posiciones de las ventanas
elegidas por el usuario.
Tiempo de diseño y tiempo de ejecución: Cuando el usuario construye su aplicación, trabaja

alternativamente en diseño (configurando propiedades y escribiendo código) y en ejecución
(probando el correcto funcionamiento del programa). El paso de uno a otro estado se realiza
usualmente por medio de los botones “Inicio” y ”Terminar” ubicados en la barra de herramientas.
Cuando la aplicación se prueba en tiempo de ejecución, su comportamiento es exactamente igual al
del programa resultante de la compilación final.
Controles: Los controles que se observan en la “caja de herramientas” son componentes que se
disponen sobre los formularios para diseñar la interfase de usuario y llevar a cabo las tareas
propias de la aplicación. Existen dos clases de controles: controles estándar y controles
personalizados. Los controles estándar proveen los servicios básicos que son utilizados
normalmente por cualquier aplicación; no pueden ser removidos de la caja de herramientas y se
dice que “pertenecen” al AD. Los controles personalizados se agregan al AD (incorporándolos a la
caja de herramientas) para realizar tareas más específicas y de cierta complejidad. Estos controles
son normalmente de formato ActiveX y se los puede ver almacenados en el disco rígido como
archivos con extensión .OCX. La posibilidad de los AD de utilizar objetos estándar de tipo
ActiveX que ofrecen una funcionalidad bien definida con sólo incorporarlos en un formulario es lo
que permite al desarrollador completar aplicaciones vistosas y potentes en cuestión de días.
Objetos: Todos los elementos que componen una aplicación de VB pueden ser vistos como
objetos. Esto es válido tanto para los formularios como para los controles estándar y
personalizados. Los objetos tienen una funcionalidad bien definida, pueden verse como “cajas
negras” que se comunican entre sí por medio de tres caminos o interfases: propiedades, métodos y
eventos.
Propiedades: Las propiedades de un objeto definen su apariencia y comportamiento. Cada objeto

tiene su conjunto de propiedades que serán modificadas durante tiempo de diseño por medio de la
ventana de propiedades y en tiempo de ejecución por medio de instrucciones en código Basic. Por
ejemplo, si se desea modificar en tiempo de ejecución el texto de un control de tipo botón, la
sintaxis a utilizar es la siguiente:
Command1.Caption = "Salir"
...en donde se observan claramente los elementos que componen la instrucción: nombre de objeto
+ punto + nombre de propiedad = nuevo valor de la propiedad. El punto actúa como un separador
de elementos.
Métodos: Los métodos sirven para “ordenarle” al objeto que ejecute determinadas tareas. Estos
“disparadores” sólo se utilizan en tiempo de ejecución y deben ser incluidos en la aplicación como
código Basic. Un método de uso frecuente en varios tipos de objetos es “SetFocus”; que transfiere
el foco a ese objeto:
Command1.SetFocus
Eventos: Los eventos son el camino utilizado por los objetos para notificar a la aplicación sobre la
ocurrencia de algún suceso en particular. Cualquier acción del usuario puede desencadenar un

evento que afecte a uno o más controles de la aplicación; estos controles deben estar preparados
para responder al disparo del evento.
Los eventos no son únicamente producidos por el usuario de la aplicación, a veces el
procesamiento de una operación interna del programa puede disparar un evento, también a veces
un evento se dispara por la finalización de un período de tiempo especificado.
Para que cada evento pueda ser atendido por la aplicación debe crearse una subrutina que contenga
código Basic específico; esta subrutina se ejecutará automáticamente ante la aparición de dicho
evento.
A modo de ejemplo, se demuestra el funcionamiento de un evento típico:
Private Sub Command1_Click()
Beep
End Sub
...el nombre del evento es Command1_Cllick y está compuesto por el nombre del objeto, el
separador ”_“ (underscore) y el nombre del evento genérico. El formato de los eventos es el típico
de las subrutinas (procedimientos) de VB. La acción que el evento ejecutará es emitir un sonido
por los parlantes de la PC.
Subrutinas y funciones: Las subrutinas y funciones, al igual que los eventos, son subtipos de una
categoría más global llamada procedimientos. Todo el código de una aplicación está contenido en
procedimientos; se dice también que se encuentra segmentado en procedimientos. Cada uno de
estos procedimientos se programa para realizar una tarea concreta de manera que cuando la
aplicación necesita ejecutar dicha tarea, lo que debe hacer es disparar el procedimiento correcto.
La estructura de los procedimientos está formada por dos instrucciones que identifican el
comienzo y el final del procedimiento y un conjunto de instrucciones contenidas entre las dos
primeras, que se denominan cuerpo del procedimiento. En el ejemplo de evento citado
anteriormente, las instrucciones de comienzo y final del procedimiento son las siguientes:
Private Sub Command1_Click()
End Sub
... en tanto que el cuerpo del procedimiento es la instrucción:
Beep
A continuación se explican las diferencias entre los tipos de procedimientos:
❏ Eventos Se disparan automáticamente ante la ocurrencia de un suceso. Su nombre es estándar y

su uso es opcional. Si el programador desea que el evento sea “sensible”, debe introducir el
código correspondiente en el cuerpo del procedimiento. Su estructura es la siguiente:
Private Sub NombreDeEvento(Parámetros opcionales)
...
End Sub
❏ Subrutinas Son bloques de código diseñados por el programador que cumplen una tarea
específica. Pueden o no recibir parámetros (variables) y no retornan ningún valor. Su estructura
es la siguiente:
Private Sub NombreDeSubrutina(Par. opcionales)
...
End Sub
❏ Funciones Son muy similares a las subrutinas y su principal diferencia consiste en que retornan
un valor. Su utilidad principal es procesar las variables recibidas y devolver una respuesta; esta
respuesta debe ser asignada al final del cuerpo del procedimiento a el nombre de la función, que
se comporta como la variable de retorno. Más adelante se ejemplificará el uso de las funciones.
Su estructura es la siguiente:
Private Function NombreDeFuncion(Par.) As TipoDeDato

...
End Function
Los procedimientos pueden escribirse “dentro” de un formulario, y esto se hace generalmente

cuando se pretende que sean llamados únicamente desde otros procedimientos de ese mismo
formulario. Sin embargo, cuando se escriben procedimientos de uso general para que puedan ser

llamados desde cualquier parte del programa, se los suele incluir dentro de un módulo. Los
módulos son archivos que contienen solamente subrutinas y funciones de uso general.
Desarrollo de aplicaciones utilizando Visual Basic

Como se señaló anteriormente, el desarrollo de aplicaciones en VB consta siempre de los
siguientes pasos:
1. Crear la interfase
2. Configurar las propiedades
3. Escribir el código
Para ver cómo se hace esto, crearemos a continuación una aplicación sencilla: una calculadora
capaz de realizar las cuatro operaciones fundamentales sobre dos operandos. Durante el desarrollo
de este ejemplo se introducirán algunos conceptos adicionales que deberán ser tomados como guía
al desarrollar todo tipo de aplicaciones, sobre todo si son grandes o complejas.
1. Crear la Interfase
El primer paso para generar una aplicación de Visual Basic consiste en crear los formularios que
van a ser la base de la interfase de su aplicación. Puede usar formularios para agregar ventanas y
cuadros de diálogo a la aplicación.
Si se comienza desde la opción
de menú Archivo - Nuevo
Proyecto, se crea por defecto un
formulario vacío llamado
Form1. En caso de necesitar
más adelante formularios
adicionales, se los puede
incorporar utilizando la opción
de menú Proyecto – Agregar
Formulario o haciendo click
sobre el icono correspondiente
en la barra de herramientas.
Figura 6 -Formulario vacío en Visual Basic
Es posible observar los archivos que componen la aplicación en la ventana de proyecto: en ella
están listados todos los formularios y módulos incluidos en el proyecto (por el momento, sólo
existe el formulario principal):
Como primera medida se debe dar un nombre y un destino en el

disco rígido a este proyecto. Lo ideal sería crear un directorio
separado para contener todos los archivos que pertenecen a el
proyecto. Utilice el Explorador de Windows para crear a
continuación del directorio raíz, un directorio de nombre
Aplicaciones, y como una rama que se desprende de él, el
directorio del proyecto. Suponiendo que el proyecto se
Figura 7 - Ventana de proyecto
denominase Calcular, la estructura quedaría como sigue:
Dentro de este directorio, utilizando la opción de menú Guardar
formulario como... guarde el formulario con el nombre
Calcular1; la extensión .FRM será asignada automáticamente por
VB. A continuación, utilizando la opción de menú Guardar
proyecto como... guarde guarde el proyecto con el nombre
Calcular; también VB asignará automáticamente a este archivo la
Figura 8 -Estructura de directorios extensión .VBP.
para el proyecto Calcular

Ahora está en condiciones de dibujar los objetos que van a componer la interfase en el formulario
que ha creado. Para esta primera aplicación, usará tres controles del cuadro de herramientas.
Botón Control Nombre por defecto

Caja de texto (TextBox) Text1
Botón de comando (CommandButton) Command1
Etiqueta (Label) Label1
Incorpore dos cajas de texto, cuatro botones y una etiqueta al formulario para que aparezca como
se observa en la Figura 9:
Figura 9 - La interfaz modificada de la aplicación Calcular
2. Configurar las Propiedades

Una vez definida la ubicación de los controles que componen la aplicación (que por supuesto
pueden posteriormente cambiarse de tamaño y posición), es el momento de configurar sus
propiedades.
Dicha configuración se realiza en la ventana de propiedades, a la cual se puede llegar rápidamente
presionando F4. Esta ventana muestra por defecto las propiedades del control activo (aquél que
tiene los indicadores cuadrados de movimiento y cambio de tamaño), sin embargo también posee
una caja de opciones que permite seleccionar el objeto cuyas propiedades se desean modificar.
En la figura se observa que el objeto seleccionado posee el

nombre “Command1” y pertenece a la categoría
“CommandButton”. La propiedad que aparece resaltada,
denominada Caption es la que indica el texto que aparece
en la superficie del botón.
Si se cambia este texto puede observarse que la
modificación es inmediatamente aceptada por el control.
La mayoría de los controles que muestran un texto poseen
una propiedad denominada Caption en la que se asigna
dicho texto. La excepción más notable a esta regla es la del
control caja de texto, cuya propiedad principal se
denomina Text.
Figura 10 - Ventana de propiedades

Figura 11 - Nueva modificación de la aplicación Calcular
La imagen del formulario que se muestra fue obtenida modificando las propiedades mencionadas
de acuerdo a la siguiente tabla:
Objeto Propiedad Valor

Form1 Caption “Calcular”
Text1 Text “Primer operando”
Text2 Text “Segundo operando”
Label1 Caption “Resultado”
Command1 Caption “Sumar”
Command2 Caption “Restar”
Command3 Caption “Multiplicar”
Command4 Caption “Dividir”
Las propiedades Text y Caption pueden ser modificadas durante la ejecución de la aplicación
mediante instrucciones en código Basic. De hecho, la propiedad Caption de la etiqueta Label1 es la
que se utilizará en esta aplicación para mostrar el resultado de las operaciones matemáticas. La
sintaxis para acceder a las propiedades de los objetos desde el código es la siguiente:
NombreDeObjeto.NombreDePropiedad = NuevoValor
...en donde se observan los elementos que componen la instrucción (el punto actúa como un
separador de elementos):
En la figura de la ventana de propiedades se observa la propiedad Name; esta propiedad debe
modificarse siempre en todos los controles. Los nombres de los controles son únicos y no pueden
repetirse en la aplicación. VB le asigna a cada control un nombre por defecto asociado al tipo de
control, por ejemplo Form1, Form2 para los formularios o Command1, Command2 para los
botones, etc. Cuando el proyecto comienza a crecer estos nombres se tornan confusos y es difícil
determinar quién es quién.
Por lo tanto, cada vez que agregue un objeto a su aplicación, modifique su nombre en base a algún
criterio claro y fácil de entender.
Siguiendo el criterio de la sugerencia, los nombres de los controles incorporados en la aplicación
quedan como se indica en la tabla a continuación:

Nombre anterior Nombre actual De este modo, con sólo mirar un control sobre el
Form1 frmCalcular formulario, se está en condiciones de deducir su
Text1 txtPrimer nombre.
Text2 txtSegundo
Label1 lblResultado
Para concluír con la configuración de propiedades,
Command1 cmdSumar
Command2 cmdRestar asigne nuevos valores a las propiedades Font y
Command3 cmdMultiplicar ForeColor del objeto etiqueta (cuyo nuevo nombre
Command4 cmdDividir es lblResultado):
3. Escribir el Código
Si en este momento ejecutamos la aplicación, presionando el botón o F5 el programa comienza a
correr, con botones que, aún cuando no hacen nada, tienen la inteligencia suficiente para responder
al click del mouse hundiéndose y elevándose.
Para detener la aplicación presione la cruz de cerrar ventana o terminar en la barra de
herramientas.
Bien, justamente lo que

deseamos es que esos
botones de operaciones
matemáticas sí estén en
condiciones de
responder al click del
mouse ejecutando la
tarea que corresponda
(sumar, restar, etc.).
Para que esto suceda
debemos elegir entre
los eventos que ofrece
el objeto botón aquél
que mejor se adapta a la
tarea que debe
ejecutarse, e incorporar
dentro de ese evento
Figura 12 - Ventana de código correspondiente al formulario frmCalcular nuestras instrucciones
en código Basic. Ha llegado el momento de escribir algunas líneas de programa.
La ventana de código es donde usted escribe el código Basic para su aplicación. Para abrir la
ventana de código, haga doble-click sobre el botón de la aplicación que indica “Sumar”, o en la
ventana de proyecto presione el botón Ver código
La ventana de código incluye los siguientes elementos:
❏ Caja de objetos: Muestra el nombre del objeto seleccionado. Haciendo click en la flecha a la
derecha de la caja se descuelga la lista de todos los objetos asociados al formulario.
❏ Caja de procedimientos: Lista todos los procedimientos de eventos disponibles para el objeto
seleccionado. En la figura el evento seleccionado es el evento Click. Todos los controles
brindan una gran cantidad de eventos de los cuales normalmente se utilizan pocos. En nuestro
caso, necesitamos que los botones sean sensibles al “Click” del usuario.
Como ya se aclaró con anterioridad, el código de una aplicación VB se divide en pequeños bloques
denominados procedimientos. Un procedimiento de evento, o sencillamente evento, como el que

está creando en este momento, contiene código que se ejecuta cuando un determinado evento o
suceso ocurre (tal como el click del usuario sobre el botón).
El evento Click del botón cmdSumar está limitado por dos instrucciones que identifican el
comienzo y el final del procedimiento:
Private Sub cmdSumar_Click()
End Sub
El nombre del evento está compuesto por el nombre del objeto al que éste pertenece, un separador
”_“ (underscore) y el nombre del evento genérico.
Entre estas dos instrucciones se debe insertar el bloque de código con que se desea que el evento
responda. En este caso la tarea es sencilla: se debe sumar el valor de las cajas de texto y mostrar el
resultado en la etiqueta. El evento final queda como sigue:

lblResultado.Caption = txtPrimero.Text + txtSegundo.Text
End Sub
Del mismo modo se configura el evento correspondiente a los restantes botones:
Private Sub cmdRestar_Click()

lblResultado.Caption = txtPrimero.Text - txtSegundo.Text
End Sub
Private Sub cmdMultiplicar_Click()
lblResultado.Caption = txtPrimero.Text * txtSegundo.Text
End Sub
Private Sub cmdDividir_Click()
lblResultado.Caption = txtPrimero.Text / txtSegundo.Text
End Sub
Luego de llenar los cuatro eventos con el código correcto, guarde y ejecute la aplicación
presionando F5 o el botón Iniciar. Al momento de probarla, utilice números en las cajas de texto,
ya que si introduce texto que no pueda ser interpretado como números, el resultado probablemente
no será el esperado.
De hecho, el primer resultado “inesperado” que obtendrá está relacionado con la operación de
suma. Como puede observar, el operador de suma (+) interpreta que, dado que está trabajando con
datos de tipo string, intenta concatenarlos. La solución para este problema consiste en obtener el
valor numérico de la cadena de texto contenida en la propiedad Text de las cajas de texto; esto se
hace aplicándoles el operador Val(), a partir de lo cual pueden ser consideradas como números
válidos.

lblResultado.Caption = Val(txtPrimero.Text) + _
Val(txtSegundo.Text)
End Sub

Figura 13 - Ventana de código resultante de configurar los eventos Click
El programa que se acaba de realizar no es todavía todo lo bueno que puede ser. No posee la
inteligencia suficiente para darse cuenta de que no debe dividir en cero y tampoco se dá cuenta si
en lugar de números el usuario ingresó letras.
Figura 14 - Resultado de ejecutar la aplicación Calcular
Ejercicios
Codificar los algoritmos realizados en el Trabajo Práctico anterior, generando aplicaciones en
Visual Basic.

Variables y Constantes: Declaración, Tipos, Ámbito y Duración
Las variables en Visual Basic no necesitan ser declaradas, en el momento en que se precisan se
pueden incluir en el código. Sin embargo, puede ser útil el exigir la declaración de todas las
variables que aparezcan en el código, que es lo que nosostros haremos. Para ello, se utilizará la
instrucción:
Option Explicit
en la sección de declaraciones del formulario. Una vez procesada esta instrucción, no se permitirán
variables no declaradas. Para declarar una variable la instrucción adecuada es:
Dim Nombre_Variable [As Tipo]
donde Tipo puede ser:
TIPO DESCRIPCIÓN TAMAÑO OCUPADO IDENTIFICADOR

String Carácter 1 Byte por carácter $
Integer Entero 2 Bytes %
Long Enterolargo 4 Bytes &
Single Realsimple 4 Bytes !
Double Realdoble 8 Bytes #
Currency Moneda 8 Bytes @
Byte Byte 1 Byte (ninguno)
Boolean Booleano 2 Bytes (ninguno)
Date Fecha 8 Bytes (ninguno)
Object Objeto 4 Bytes (ninguno)
Variant Variante Cualquiera de los anteriores
Para declarar una constante se necesita la instrucción:
Const Nombre_Constante = Expresión
Hay dos tipos de constantes:
Intrínsecas o definidas por el sistema, proporcionadas por Visual Basic o cualquier otra aplicación
que provee una librería de objetos. Para ver una lista de estas constantes, se accederá a
Ver/Examinador de Objetos. En la lista desplegable superior, se seleccionará VB-Objects and
Procedures. De la lista de la izquierda se hará doble clic en cualquier opción acabada en Constants.
Simbólicas o definidas por el usuario. Es una buena idea el declarar las constantes simbólicas con
el prefijo con, p.e. Const conPi = 3,141592
Ambito de las Variables en Visual Basic

Se entiende por ámbito de una variable el espacio de la aplicación donde la variable es visible y
por tanto se puede utilizar. Los distintos alcances que puede tener una variable declarada en Visual
Basic son:
❏ Las variables declaradas con Dim o utilizadas directamente en un procedimiento, son variables
locales, es decir, accesibles solamente desde el procedimiento que las declara.
❏ Si las variables se declaran en la sección de declaraciones del formulario o del módulo, son
variables a nivel de formulario o de módulo. Una variable declarada a nivel de formulario es
accesible desde cualquier procedimiento del formulario y lo mismo para las variables a nivel de

módulo: una variable declarada a nivel de módulo es accesible desde cualquier procedimiento
de ese módulo, pero no desde otros módulos. Estas variables se declaran con Dim o Private.
❏ Las variables públicas son declaradas en la sección de declaraciones de un módulo con la

sentencia Public y, podrán ser accesibles desde cualquier módulo.
Ejemplo
Crear un formulario con dos botones de comando (cmdInicio y cmdParada), tres etiquetas
(lblHInicio; lblHParada y lblTTranscurrido) y, tres cajas de texto (txtHInicio, txtHParada,
txtTTranscurrido). Inicialmente, el botón cmdParada estará desactivado. Se pretende que, cuando
el usuario pulse el botón cmdInicio, en la caja de texto asociada a la etiqueta lblHInicio, aparezca
la hora actual y, al mismo tiempo, se active el botón cmdParada y se desactive el de cmdInicio. Al
pulsar el botón cmdParada, se mostrará la hora de parada, el tiempo transcurrido, se desactivará el
botón de cmdParada y, se habilitará el de cmdInicio.
El código asociado será:
Private Sub cmdInicio_Click()

timeInicio = Now
txtHInicio.Text = Format$(timeInicio; "hh:mm:ss")
cmdInicio.Enabled = False
cmdParada.Enabled = True
End Sub
Private Sub cmdParada_Click()

timeParada = Now
timeTiempo = timeParada - timeInicio
txtHParada.Text = Format$(timeParada; "hh:mm:ss")
txtTTranscurrido.Text = Format$(timeTiempo; "hh:mm:ss")
cmdInicio.Enabled = True
cmdParada.Enabled = False
End Sub
En este ejemplo se deben declarar las variables timeInicio, timeParada y timeTiempo como
variables a nivel de formulario (en la sección de declaraciones del formulario) para que sean
accedidas desde cualquier procedimiento asociado al formulario. Por tanto, el ámbito de una
variable determina qué procedimientos podrán acceder a esa variable. Cualquier sentencia Dim
declarada en cualquier procedimiento tiene preferencia con respecto a variables declaradas a nivel
de módulo.
Siempre que una variable aparece por primera vez, es inicializada al valor por defecto (0 para
variables numéricas y cadena vacía para tipo String) Para que una variable mantenga el valor en
cada ejecución del procedimiento donde se utiliza, se debe declarar con la instrucción:
Static Nombre_Variable [As Tipo]
Nota: Se mantiene la palabra reservada Global por compatibilidad de la versión 3.0, pero es
preferible utilizar la palabra reservada equivalente: Public.
Tipos Definidos por el Usuario

Se pueden definir tipos por parte del usuario para crear registros (structs en C, Record en Pascal).
Un registro puede definirse como una colección de datos de diferentes tipos relacionados entre sí.
Para crear un registro se necesita la sentencia Type ... End Type. Esta sentencia solo puede
aparecer en la sección de declaraciones de un módulo estándar y pueden ser declarados como
Private o Public:
Type Ficha

Nombre As String
Dirección As String * 40
Teléfono As Long
DNI As Long
End Type
Una vez definido un tipo de datos, se pueden declarar variables del mismo tipo.
Dim (Public) Alumno As Ficha
Para refererirse a un determinado campo del registro, se utiliza la notación variable.campo (Por ej.
Alumno.Nombre). Un tipo definido por el usuario no puede contener un array dinámico, pero sí
estático.
Funciones y Procedimientos
Para evitar duplicar código en los procedimientos de evento, se deben utilizar los procedimientos
generales. Estos deben escribirse como un procedimiento Sub o como una función Function.
Cuando un procedimiento es llamado para su ejecución, Visual Basic lo busca en el formulario o

en el módulo donde se encuentre en ese momento. Si no lo encuentra, continúa la búsqueda en el
resto de los módulos de la aplicación.
Para crear un procedimiento general, desde la ventana de código se accederá a Insertar/Nuevo

Procedimiento.
Las funciones en Visual Basic son declaradas en los módulos o en la sección de declaraciones de
un formulario y devuelven un valor al procedimiento que la invocó. La sintaxis empleada es la
siguiente:
[Private|Public] [Static] Function nombre [(lista_argumentos) ] [As tipo]

[Declaraciones]
[nombre = expresión]
[Exit Function]
[Declaraciones]
[nombre = expresión]
End Function
Los procedimientos generales necesitan ser invocados explícitamente para poder ser ejecutados.
No devuelven ningún valor. La sintaxis para declarar procedimientos generales es:
[Private | Public] [Static] Sub nombre [(lista_argumentos) ]

[Declaraciones]
[Exit Sub]
[Declaraciones]
End Sub
donde:
Public indica que el procedimiento es accesible desde otros procedimientos en cualquier módulo.
Si se utiliza en un módulo privado, no estará disponible fuera del proyecto.
Private indica que el procedimiento solo es accesible desde los procedimientos del módulo en que
está declarado.
Static indica que las variables locales al procedimiento mantendrán el valor entra llamadas al
procedimiento.

Lista_argumentos es una lista de los argumentos que se pasan al procedimiento. Los argumentos
múltiples van separados por comas. Puede tomar la forma siguiente:
[[Optional] [ByVal | ByRef] [ParamArray] varnombre [( )] As tipo]
donde:
Optional indica que el argumento no se necesita. Todos los argumentos opcionales deben ser de
tipo Variant.
ByVal indica que el argumento es pasado por valor.

ByRef indica que el argumento es pasado por referencia.
ParamArray utilizado para indicar que el argumento final es una lista opcional de argumentos.
Proporciona una forma de pasar un número arbitrario de argumentos.
No puede utilizarse con ByVal, ByRef o con Optional.
La forma de llamar a una función es

var = nombre_función([argumentos] )
La forma de invocar a un procedimiento es utilizando cualquiera de las dos formas siguientes:

Call nombre_procedimiento[(argumentos)]
nombre_ procedimiento [argumentos]
Paso de Parámetros
Por defecto, los argumentos son pasados por referencia; de este modo cualquier cambio de valor
que sufra un parámetro en el cuerpo de la función o del procedimiento también se produce en el
argumento correspondiente de la llamada a la función o procedimiento.
Cuando se llama a una función o a un procedimiento, se podrá especificar que el valor de un

argumento sea pasado por valor, poniendo dicho argumento entre paréntesis en la llamada. Otra
forma de especificar que un argumento será siempre pasado por valor es anteponiendo la palabra
ByVal a la declaración del parámetro en la cabecera del procedimiento.
Ejercicios
1. Crear una aplicación que permita calcular el factorial de un número. Utilizar funciones o
procedimientos.
2. Crear un procedimiento que permita separar en palabras una frase dada.
3. Crear un procedimiento que, dada una frase, permita devolver la misma frase invertida.
4. Obtener un procedimiento capaz de determinar si una palabra es palíndroma (capicúa).
5. Diseñar una aplicación que permita al usuario introducir valores en una lista desplegable y,
obtenga la suma de dichos valores.

Convenciones de codificación. Denominación de Variables y Objetos
Las convenciones de codificación son pautas de programación que no están enfocadas a la lógica
del programa, sino a su estructura y apariencia física. Facilitan la lectura, comprensión y
mantenimiento del código. Las convenciones de codificación suelen incluir:
❏ Convenciones de nombres para variables, objetos y procedimientos.

❏ Formatos estandarizados para etiquetar y comentar el código.
❏ Instrucciones de espaciado, formato y sangría.
En las secciones siguientes se explica cada una de estas áreas y se dan ejemplos de su uso correcto.
Por qué existen las convenciones de codificación?

La razón principal de usar un conjunto coherente de convenciones de código es estandarizar la
estructura y el estilo de codificación de una aplicación de forma que el autor y otras personas
puedan leer y entender el código fácilmente.
Las convenciones de codificación correctas dan como resultado un código fuente preciso, legible y
sin ambigüedad, que es coherente con otras convenciones del lenguaje y lo más intuitivo posible.
Convenciones de codificación mínimas

Un conjunto de convenciones de codificación de propósito general debe definir los requisitos
mínimos necesarios para conseguir los objetivos explicados anteriormente, dejando libertad al
programador para crear la lógica y el flujo funcional del programa.
El objetivo es hacer que el programa sea fácil de leer y de entender sin obstruir la creatividad
natural del programador con imposiciones excesivas y restricciones arbitrarias.
Por tanto, las convenciones sugeridas en este apunte son breves y sugerentes. No muestran todos
los objetos y controles posibles, ni especifican todos los tipos de comentarios informativos que
podrían ser útiles. Dependiendo del proyecto y de las necesidades específicas de la organización,
quizás desee ampliar estas instrucciones para que incluyan elementos adicionales como:
❏ Convenciones para objetos específicos y componentes desarrollados internamente o comprados
a otros proveedores.
❏ Variables que describan las actividades comerciales o instalaciones de la organización.
❏ Cualquier otro elemento que el proyecto o la empresa considere importante para conseguir
mayor claridad y legibilidad.
Directrices para la Denominación de Variables y Objetos

Al seleccionar los nombres de las variables y objetos, elíjalos de modo que una persona que deba
leer el código programado por usted pueda comprenderlos fácilmente. Esta sugerencia es válida
también para el caso en que usted deba realizar modificaciones sobre código que usted mismo
programó bastante tiempo atrás. Cuanto más claros sean los nombres a lo largo de su código, más
fácil le resultará realizar las modificaciones que sean necesarias. Además, según lo notará a
medida que aplica esta práctica común, resulta más fácil programar cuando el código crece de
tamaño.
Los convenios de denominación deben cubrir los siguientes puntos:
El cometido de la variable
Para qué se utiliza la variable?. Se la utiliza como un manejador, un banderín boleano, un banderín
de bits (un array de bits), un índice, un contador, un ordinal, una cadena de caracteres, un
identificador, etc.? Normalmente esta es la información más útil, que se puede proporcionar y es
independiente del lenguaje.

El tipo de datos de la variable
Esta información normalmente es irrelevante porque el tipo de datos está implicado por el
cometido. Lo que es más, el tipo de datos depende del lenguaje. Si se diseña el convenio de
denominación para un lenguaje que soporta tipos con y sin signo, (por ejemplo C y la mayoría de
las variaciones de Pascal), el convenio se hace irrelevante para lenguajes que solamente tienen
enteros con signo (Basic). Si se usan características especiales del lenguaje para definir los
nombres de tipos propios, esos nombres serán irrelevantes en los lenguajes que no permitan
nombrar tipos propios.
Algunos convenios de denominación de variables que se basan en tipos de datos, separan, por
ejemplo los prefijos para variables reales en Single (sng) y Double (dbl) y en enteros cortos (int) y
largos (lng). Nosotros no realizaremos esta distinción, ya que como dijimos anteriormente, esta
información resulta irrelevante.
El contexto de la variable
Generalmente esto significa usar un modificador que indique que la variable es una array o
colección. Los lenguajes que soportan punteros, requieren un modificador para distinguir un
puntero a una variable de la variable en sí. Se puede usar un modificador para indicar un contador
de variables. Por ejemplo, si el modificador es h, para manejador, (handle), a para array, p para
puntero y c para contador, entonces se podría tener un ah (array de manejadores), un ph (un
puntero a un manejador) o un ch (un contador de manejadores).
El ámbito de la variable
Algunos convenios distinguen claramente entre variables que son locales, globales o cualquier otro
ámbito intermedio. Normalmente se asume local, y no requiere modificador, y se utiliza g como
prefijo para indicar una variable global.
A medida que aumenta el tamaño del proyecto, también aumenta la utilidad de reconocer
rápidamente el alcance de las variables. Esto se consigue escribiendo un prefijo de alcance de una
letra delante del tipo de prefijo, sin aumentar demasiado la longitud del nombre de las variables.
En la siguiente tabla se resumen los prefijos que utilizaremos a lo largo del desarrollo de la cátedra
para distinguir el ámbito de una variable.
Ambito Prefijo Ejemplo

Global g gstrNombreUsuario
Nivel de módulo m mblnProgresoDelCalculo
Local del procedimiento Ninguno dblVelocidad
La posibilidad de modificación de la variable

Algunos convenios distinguen constantes de variables, normalmente escribiendo las constantes
todo en mayúsculas. En otros tipos de convenios, se suele identificar una constate por su nombre y
el contexto. Si clr es el prefijo para un color, está bastante claro que crlTitulo es el nombre de una
variable, y crlRojo el nombre de una constante.
Se debe tener en cuenta que algunos prefijos modifican a otros prefijos. Por ejemplo, acmd es un
array de botones, mientras que ccmd es un contador de botones y ncmd una colección de botones.
Los convenios de denominación de variables son una cosa, los convenios de denominación de
tipos son otra.
Se pueden definir varias clases de tipos: formularios, clases, colecciones, tipos definidos por el
usuario, etc.
Recomendaciones para la utilización de prefijos en variables:

En la siguiente tabla se dan ejemplos de los prefijos a utilizar para la denominación de las
variables.

Variable Prefijo Sugerido Ejemplo
indice entero i iFilas
número real f fResultado
byte b bDatosImagen
cadena de caracteres s sNombre
variant v vSumar
moneda cur curIngresos
hora time timeComienzo
fecha date dateInicio
puntero p pMemoriaVideo
tipo definido por el tdu tduEmpleado
usuario
contador c cNumeros
Convenciones de nombres de objetos (controles)

En la ventana de propiedades de los objetos se observa la propiedad Name; esta propiedad debe
determinar quién es quién. Por lo tanto, cada vez que agregue un objeto a su aplicación, modifique
su nombre en base a algún criterio claro y fácil de entender.
Un criterio muy utilizado a la hora de nombrar objetos en VB consiste en asignar a cada control un
nombre compuesto por:
1. Apócope del tipo de objeto (por ejemplo, txt=TextBox, lbl=Label, cmd=Command, frm=Form,
etc.)
2. La primera palabra mostrada por el objeto De este modo una propiedad Name válida para un
botón puede ser: “cmdSumar”, o para el formulario: “frmCalcular“.
Los objetos deben llevar nombres con un prefijo coherente que facilite la identificación del tipo de
objeto.
A continuación se ofrece una lista de convenciones recomendadas para algunos de los objetos
permitidos por Visual Basic.
Prefijos sugeridos para controles

Tipo de control Prefijo Ejemplo
Panel 3D pnl pnlGrupo
Botón animado ani aniBuzon
Casilla de verificación chk chkSoloLectura
Cuadro combinado, cuadro cbo cboIngles
de lista desplegable
Botón de comando cmd cmdSalir
Diálogo común dlg dlgArchivoAbrir
Comunicaciones com comFax
Control (dentro de ctr ctrActivo
procedimientos cuando no
se conoce el tipo específico)
Control de datos dat datBiblio
Cuadro combinado enlazado dbcbo dbcboLenguaje
a datos
Cuadrícula enlazada a datos dbgrd dbgrdResultadoConsulta
Cuadro de lista enlazado a dblst dblstTipoTarea
datos
Cuadro de lista de dir dirOrigen
directorios
Cuadro de lista de unidades drv drvDestino

Cuadro de lista de archivos fil filOrigen
Continuación
Formulario (form) frm frmEntrada
Marco fra fraLenguaje
Medidor (gauge) gau gauEstado
Gráfico gra graIngresos
Cuadrícula grd grdPrecios
Barra de desplazamiento hsb hsbVolumen
horizontal
Imagen (Image) img imgIcono
Estado de tecla key keyMayusculas
Etiqueta lbl lblMsjAyuda
Línea lin linVertical
Cuadro de lista lst lstCodigosDePolitica
Mensaje MAPI mpm mpmEnviarMsj
Sesión MAPI mps mpsSesion
MCI mci mciVídeo
Formulario MDI secundario mdi mdiNota
Menú mnu mnuArchivoAbrir
MS Flex Grid msg msgClientes
MS Tab mst mstPrimero
ActiveX ole oleHojaDeTrabajo
Esquema out outDiagramaDeOrg
Pen BEdit bed bedNombre
Pen Hedit hed hedFirma
Trazo de pluma ink inkMapa
Imagen (Picture) pic picVGA
Clip de imagen clp clpBarraDeHerramientas
Informe rpt rptGananciasTrimestre1
Forma shp shpCirculo
Cuadro de número spn spnPaginas
Cuadro de texto txt txtApellido
Cronómetro tmr tmrAlarma
Arriba-abajo upd updDireccion
Barra de desplazamiento vsb vsbVelocidad
vertical
Control deslizante sld sldEscala
Lista de imágenes ils ilsTodosLosIconos
Vista de árbol tre treOrganizacion
Barra de herramientas tlb tlbAcciones
TabStrip tab tabOpciones
Barra de estado sta staFechaHora
Lista lvw lvwEncabezados
Barra de progreso prg prgCargarArchivo
RichTextBox rtf rtfInforme
Sugerencias para elegir nombres

Hasta ahora hemos apuntado sobre todo a los prefijos a utilizar en la denominación y hemos dado
muy pocos consejos para el nombre en sí de la variable. Las sugerencias que se incluyen a
continuación son aplicables a los nombres de:
❏ Variables.
❏ Objetos.
❏ Propiedades, métodos y eventos.
Utilice palabras o sílabas completas siempre que sea posible. Es más fácil recordar palabras
completas que recordar si ha abreviado Window como Wind, Wn o Wnd.

Cuando necesite abreviar porque de lo contrario el identificador sería demasiado largo, procure
utilizar las sílabas iniciales completas. Por ejemplo, utilice AltExpEval en lugar de
AlternateExpressionEvaluation o AltExpnEvln.
Evite los acentos. Bajo ninguna condición incluya acentos en los nombres de los controles o las
variables; su uso puede llevar a condiciones de funcionamiento impredecibles.
Mezcle mayúsculas y minúsculas. Todos los identificadores deben utilizar mayúsculas y

minúsculas, mejor que el carácter de subrayado, para separar las palabras. Por ejemplo utilice
ShortcutMenus en lugar Shortcut_Menus, Shortcutmenus, SHORTCUTMENUS.
Verbo-objeto frente a objeto-verbo

Si crea nombres de procedimientos que combinen un verbo con el nombre del objeto sobre el que
actúa, deberá ser coherente en cuanto al orden. Coloque el verbo antes que el objeto en todos los
casos, como en InsertarAparato e InsertarPieza, o bien escriba siempre el objeto primero, como en
AparatoInsertar y PiezaInsertar. Cada una de estas formas tiene una ventaja. El orden verbo-objeto
produce nombres más similares al habla ordinaria y, por tanto, indican mejor el propósito del
método. El orden objeto-verbo agrupa todos los procedimientos que afectan a un objeto en
particular. No importa el orden que elija, pero si mezcla los dos probablemente los confundirá en
algún momento.
Convenciones de codificación estructurada

Además de las convenciones de nombres, las convenciones de codificación estructurada, como
comentarios al código y sangrías coherentes, pueden mejorar mucho la legibilidad del código.
Convenciones de comentarios al código

Todos los procedimientos y funciones deben comenzar con un comentario breve que describa las
características funcionales del procedimiento (qué hace). Esta descripción no debe describir los
detalles de implementación (cómo lo hace), porque a veces cambian con el tiempo, dando como
resultado un trabajo innecesario de mantenimiento de los comentarios o, lo que es peor,
comentarios erróneos. El propio código y los comentarios de líneas necesarios describirán la
implementación.
Los argumentos que se pasan a un procedimiento se deben describir cuando sus funciones no sean
obvias y cuando el procedimiento espera que los argumentos estén en un intervalo específico.
También hay que describir, al principio de cada procedimiento, los valores de retorno de funciones
y las variables globales que modifica el procedimiento, en especial los modificados a través de
argumentos de referencia.
Los bloques del comentario de encabezado del procedimiento deben incluir los siguientes
encabezados de sección. En la sección siguiente, “Dar formato al código”, hay algunos ejemplos.
Encabezado de sección Descripción del comentario

Finalidad Lo que hace el procedimiento (no cómo lo hace).
Premisas Lista de cada variable externa, control, archivo abierto o
cualquier otro elemento que no sea obvio.
Efectos Lista de cada variable externa, control o archivo
afectados y el efecto que tiene (sólo si no es obvio).
Entradas Todos los argumentos que puedan no ser obvios. Los
argumentos se escriben en una línea aparte con
comentarios de línea.
Resultados Explicación de los valores devueltos por las funciones.

Recuerde los puntos siguientes:
❏ Cada declaración de variable importante debe incluir un comentario de línea que describa el
uso de la variable que se está declarando.
❏ Las variables, controles y procedimientos deben tener un nombre bastante claro para que los
comentarios de línea sólo sean necesarios en los detalles de implementación complejos.
❏ Al principio del módulo .bas que contiene las declaraciones de constantes genéricas de Visual
Basic del proyecto, debe incluir un resumen que describa la aplicación, enumerando los
principales objetos de datos, procedimientos, algoritmos, cuadros de diálogo, bases de datos y
dependencias del sistema. Algunas veces puede ser útil un pseudocódigo que describa el
algoritmo.
Dar formato al código

Siempre resulta conveniente hacer que el formato del código siga reflejando la estructura lógica y
el anidamiento. Estos son algunos indicadores:
❏ Los bloques anidados estándar, separados por tabuladores, deben llevar una sangría de cuatro
espacios (predeterminado).
❏ El comentario del esquema funcional de un procedimiento debe llevar una sangría de un
espacio. Las instrucciones de nivel superior que siguen al comentario del esquema deben llevar
una sangría de un tabulador, con cada bloque anidado separado por una sangría de un tabulador
adicional. Por ejemplo:
'************************************************************
' Finalidad:Ubica el primer caso encontrado de un
' usuario especificado en la matriz
' ListaUsuario.
' Entradas:
' strListaUsuario(): lista de usuarios para buscar.
' strUsuarioDest: nombre del usuario buscado.
' Resultados: Índice del primer caso de rsUsuarioDest
' encontrado en la matriz rasListaUsuario.
' Si no se encuentra el usuario de destino, devuelve -1.
'************************************************************
Function intBuscarUsuario (strListaUsuario() As String, strUsuarioDest As _
String)As Integer
Dim i As Integer ' Contador de bucle.
Dim blnEncontrado As Integer ' Indicador de
' destino encontrado.
intBuscarUsuario = -1
i = 0
While i <= Ubound(strListaUsuario) and Not blnEncontrado
If strListaUsuario(i) = strUsuarioDest Then
blnEncontrado = True
intBuscarUsuario = i
End If
Wend
End Function

Estructuras de Selección
Este tipo de estructura de control permite tomar decisiones, ejecutando condicionalmene una o más
sentencias.
Estructura Si...Entonces...Sino (If.. Then... Else)
If condición_1 Then sentencias(s) [Else

sentencias()]
If condición_1 Then
Falso sentencias1(s)
Condición1
[Else
sentencia2(s)]
Verdadero End If
La condición es generalmente una expresión

Sentencia1(s) Sentencia2(s) booleana, pero puede ser cualquier expresión que
pueda ser evaluada a un valor numérico, ya que un
valor cero es considerado como Falso (False) y un
valor distinto de cero como Verdadero (True). Si
Figura 15 - Estrucutra If-Then la condición es verdadera, se ejecutan las
sentencias que están a continuación de Then y si la condición es falsa, se ejecutan las sentencias
que estan a continuación de Else, si ha sido especificado.
Una expresión booleana da un resultado Verdadero (True) o Falso (False). Desde un análisis
riguroso los operadores de Boole son los operadores lógicos And, Or y Not. Ahora bien, los
operadores que intervienen en esta estructura de control pueden ser de relación (=, <>, <, <=, >,
>=), lógicos (And, Or, Xor, Eqv, Imp, Not) y otros...
Para indicar que se quiere ejecutar uno o varios bloques de sentencias dependientes cada uno de
ellos de una condición, la estructura adecuada es la siguiente:

Figura 16- If-Then anidados

Falso
Condición1
Verdadero
Falso
Condición2
Verdadero
Falso
Condición3
Verdadero
Sentencia1(s) Sentencia2(s) Sentencia3(s) SentenciaN(s)
If condición_1 Then
sentencia1(s)
[ElseIf condición_2 Then
sentencia2(s)]
[ElseIf condición_3 Then
sentencia3(s)]
.........................................
[Else
sentencian (s)]
End If
Select Case
Esta estructura de control permite ejecutar ina de varias acciones en función del valor de una
expresión.
Select Case expr-test

Case lista-1
[sentencias-1]
[Case lista-2
[sentencias-2]]
..................................................
[Case Else
[sentencias-n]]
End Select
expr-test es una expresión numérica o alfanumérica, y lista-1, lista-2, .... rerpesenta una lista que
puede tener una de las siguientes formas.
expresión [,expresión]...

expresión To expresión
Is operador-de-relación expresión
combinación de las anteriores separadas por comas.
Cuando se utiliza la forma expresión To expresión, el valor más pequeño debe aparecer en primer
lugar.
Al ejecutarse una sentencia Select Case, se evalúa expr-test y se busca el primer Case que incluya
el valor evaluado, ejecutando a continuación el correspondiente bloque de sentencias. Si no existe
un valor igual a expr-test, entonces se ejecutan las sentencias a conmtinuación de Case Else. En
cualquier caso, el control pasa a la siguiente sentencia a End Select.

Estructuras Repetitivas
Introducción
Supongamos que deseamos ejecutar repetidamente un proceso, es decir, deseamos indicar la
ejecución de un proceso iterativo, que finalizará al cumplirse una condición. Este tipo de estructura
se llama repetitiva o iterativa.
Las estructuras repetitivas, junto con las selectivas, constituyen las estructuras de control que
permiten la resolución de los problemas con computadora.
La programación estructurada, como ya sabemos, es un método para resolver problemas por
computadora que exige el uso de las estructuras secuenciales, selectivas y repetitivas.
El teorema de la programación estructurada de Böhm y Jacopini, dice que todo programa propio
puede ser siempre definido por estructuras secuenciales, selectivas y repetitivas.
Un algoritmo para resolver un problema, requiere con frecuencia que una sentencia o grupo de
sentencias se repita un número determinado de veces. Una estructura de control que permita la
repetición de un conjunto determinado de sentencias se denomina bucle.
Un Bucle o ciclo, repite una secuencia de sentencias mientras o hasta que se cumpla que una
condición determinada es verdadera o falsa. Las condiciones se representan mediante expresiones
booleanas dado que toman solo dos valores posibles, verdadero o falso.
Figura 17- Representación de una de las formas de

la estructura de control.
Condición
Expresión Booleana F
V
Proceso o cuerpo
del bucle
Vemos que una estructura repetitiva tiene dos componentes: una acción que se ejecuta
repetidamente y un medio de decidir cuando se deben detener las acciones iterativas.
Las estructuras repetitivas se diferencian unas de otras en la localización del punto donde se decide
la detención del bucle, es decir, la terminación o salida del bucle.
La decisión o comprobación de la condición se puede verificar antes, entre o después de la
ejecución de las sentencias que componen el cuerpo del bucle.
Condición Condición
F F
Proceso o cuerpo
del bucle
V V
V
Proceso o cuerpo Proceso o cuerpo
del bucle del bucle
Condición
F
Figura 18 - Estructuras repetitivas

Tipos de estructuras repetitivas
1- Ciclo 0-n, Mientras, While-Wend (o Do While)
Esta estructura es la más utilizada. Es una estructura repetitiva en la que la condición de salida se
sitúa al principio del bucle.
Permite la repetición de una serie de sentencias, mientras una condición o expresión lógica sea
verdadera.
Mientras Pseudocódigo
Condición F
mientras condición
Sentencia_1;
V Sentencia_2;
Proceso o cuerpo .....................
del bucle fin mientras
Figura 19 - Ciclo 0-n
Reglas de funcionamiento:
1- La condición puede ser cualquier expresión lógica o relacional.
2- Como la condición se evalúa al principio del bucle, si la condición es inicialmente falsa, las
sentencias en el interior del bucle no se ejecutarán nunca.
3- Mientras la condición sea verdadera, el bucle se ejecutará. Lo que significa que el bucle se
ejecutará indefinidamente a menos que algo dentro del mismo modifique la condición.
Esta situación, conocida como bucle infinito, es anómala, y normalmente se debe evitar.
Existen fundamentalmente dos tipos de bucles.

I) Controlados por contador: son los que se repiten un número conocido de veces.
II) Controlados por acciones (Centinelas y flags): los que se repiten hasta que sucede alguna
acción específica en el cuerpo del bucle.
A continuación podemos ver la forma que tienen los bucles controlados por contador:
←1
Cuenta←
Mientras Pseudocódigo
Cuenta <=100
Cuenta=1
mientras cuenta <=100
Sentencias
Sentencia_1
Cuenta ← Cuenta+1 Sentencia_2
...................
Cuenta=Cuenta+1
fin mientras
Figura 20- Bucle controlado por contador

Bucles controlados por centinela
Se utilizan con frecuencia para leer y procesar listas de datos sin conocer el número de ellos por
anticipado.
Cada vez que una iteración se ejecuta, una nueva lectura de datos se realiza, para salir del bucle se
utiliza un valor especial denominado centinela.
Un centinela es valor utilizado para indicar el final de una lista de datos, y no se procesa como un
dato válido. El bucle se ejecuta mientras no se lea el valor centinela.
←
Centinela←
Mientras
Centinela <>-999
Pseudocódigo
Sentencias ingresar Centinela
←
Centinela← mientras Centinela <>-999
Sentencia_1
Sentencia_2
ingresar Centinela
fin mientras
Figura 21- Bucle controlado por centinela
Bucles Controlados por Bandera o Flag
La bandera (Flag) es una variable que se utiliza para conservar el estado verdadero o falso de una
condición. Generalmente, Verdadero se representa con -1 (1) y Falso con 0.
2- Ciclos 1-n - Repeat - Do-Until
Es una estructura de control de bucles en la que se realizan las sentencias del interior hasta que se
cumpla una condición, es decir, la condición es verdadera.
Proceso o cuerpo
del bucle Pseudocódigo
F
repetir
Sentencia_1
Repetir hasta Sentencia_2
V ...................
(Expresión lógica)
hasta que condición
Figura 22- Ciclo 1-n
Reglas de funcionamiento
1- El bucle realiza siempre una iteración antes de evaluar la expresión.
2- El bucle 1-n evalúa la condición después de realizar la ejecución del cuerpo del proceso.

Ejemplo: Suma de números enteros de 1 a 10.
←1
Numero←
Pseudocódigo
←0
Suma←
inicializar Número en 1
inicializar Suma en 0
Suma ← Suma +Número repetir
hacer Suma←Suma+Número
Número ← Número +1 hacer Número←Número+1
F hasta que Número >10
escribir Suma
Repetir hasta
V
Número >10
Figura 23 - Diagrama del ejemplo

Suma
3- Ciclo Exacto - For
Este tipo de bucle es controlado por contador ya que existe una variable numérica que actúa
como contador y que se incrementa en un valor constante a partir del valor inicial después de cada
iteración del bucle. Se utilizan para repetir una tarea un número fijo de veces.
Repetir desde
i hasta f F
Pseudocódigo
V
Proceso o cuerpo repetir desde v= i hasta v= f
del bucle Sentencia_1
Sentencia_2
....................
fin repetir
Figura 24 - Ciclo Exacto
Reglas de funcionamiento:
1- v es la variable de control. i es el valor inicial de dicha variable. f es el valor final.

2- En el ciclo exacto, la variable de control se inicializa al valor inicial i, valor con el cual se
ejecuta por primera vez el ciclo, y luego se incrementa en 1 (o en el paso x) antes de proceder a
una nueva repetición del bucle.
3- El bucle se termina cuando la variable de control v toma un valor mayor que el valor final f.
Ejemplo: Hallar los cuadrados de los números comprendidos entre 1 y 10

Repetir desde
N← 1 hasta 10
Pseudocódigo
← N*N
Cuadrado← repetir desde N←1 hasta N←10
Cuadrado ← N * N
Cuadrado
Escribir N
fin repetir
Figura 25 - Diagrama del ejemplo
Ejercicios
1) Realizar un algoritmo que cree una tabla de conversión de:

a) Pulgadas a centímetros 1Pulg=2,54 cm
b) Pies a metros 1 pie=0,3048 m
c) Millas por hora a Km por hora 50mph=80kph
d) Grados a radianes 360 grados= 2π radianes
2) Realizar un algoritmo que calcule e imprima la suma de los números enteros impares menores o
iguales a n, siendo n un número a ingresar.
3) Escribir un algoritmo que obtenga la suma de los números pares hasta 20.000 inclusive.
4) Escribir un algoritmo que calcule si es primo o no un número a ingresar.
5) Escribir un algoritmo que sume los cuadrados de los n primeros enteros pares, donde n se
ingresa con anterioridad.
6) Escribir un algoritmo que muestre todos los números divisibles por trece comprendidos entre un
número de tres cifras a ingresar y cero.
7) En una fábrica existen 10 máquinas, cada una de ellas con un código diferente. Se quiere
calcular el rendimiento de cada una de ellas, sabiendo el número de orden de producción, la
cantidad de unidades programadas y la cantidad de unidades producidas por cada máquina.
8) En una empresa se desea controlar el stock de productos para lo cuál se deben dar de alta los
códigos, el stock actual, el mínimo y el máximo de cada uno de ellos, y verificar cuáles están por
debajo del stock mínimo y cuáles por encima del máximo.

Estructuras de datos: Arrays
Los datos pueden organizarse en diferentes formas: el modelo matemático o lógico de una
organización particular de datos recibe el nombre de estructura de datos. Una estructura de datos
es, en esencia una colección de datos. La forma en que están relacionados unos con otros
determina el tipo de estructura. El valor de la estructura de datos se determina por:
1. Los valores de los elementos.

2. La disposición de los elementos.
Las estructuras de datos se clasifican en dos grandes grupos: estáticas y dinámicas.
arrays (vectores y matrices)

estáticas
archivos
listas
listas enlazadas pilas
dinámicas colas
árboles
grafos
Estructuras estáticas son aquellas en las que la dimensión ocupada en memoria se declara
previamente y no es posible modificarla. Las estructuras dinámicas, como su nombre indica, no
tienen un tamaño fijo de memoria y mediante variables denominadas punteros es posible modificar
su tamaño en memoria.
Generalmente, la mayoría de los lenguajes de programación soportan dos tipos de estructuras

estáticas: arrays y archivos. Esta guía se centrará en el tema de arrays (vectores y matrices),
dejando el tema de archivos para tratar posteriormente.
Un array es una colección o conjunto de posiciones de memoria que tienen el mismo nombre de
variable, es decir, un conjunto de datos numéricos ó de cadena que tienen el mismo nombre.
Los vectores individuales de un array son elementos. Como un array es referenciado por un
nombre de variable, los elementos de los arrays son también variables y se pueden utilizar en
cualquier sentencia o función.
Tipos de Arrays
Los arrays se clasifican atendiendo a sus dimensiones en:
❏ arrays unidimensionales (listas o vectores)

❏ arrays bidimensionales (tablas o matrices)
❏ arrays multidimensionales
Cada valor de un array se denomina elemento del array. Para acceder a los elementos de un array
se utilizan subíndices numéricos que identifican la posición de un valor dado en el array.
Se pueden definir array de cualquier tipo, numéricos, de caracteres y de registros (tipos de datos
definidos por el usuario). Los arrays numéricos pueden ser de cualquier tipo numérico: enteros,
enteros largos, simple precisión o doble precisión.

Los vectores: arrays unidimensionales
Un array unidimensional o lineal (también denominado lista o vector) es una lista de un número
finito de datos (elementos) del mismo tipo, que se referencian por un nombre común y un número
de orden (subíndice) y que son consecutivos, normalmente, 1 , 2, 3, . . n.
Las variables que representan los arrays se denominan variables de subíndice.
Cada elemento puede tener asignado un valor y se puede manipular de igual forma que cualquier
otra variable.
La dimensión de un vector es el número de elementos que componen el vector. En el caso de un
vector de nombre A y que conste de n elementos se representa por alguna de las siguientes
notaciones:
al , a2 , a3 , . . . , an
A(1) , A(2) , A(3) , . . . , A(n)
A[1] , A[2] , A[3] , . . . , A[n]
donde A es el nombre del vector y l, 2, 3, . n es el subíndice o índice de cada elemento del vector.
Una variable de subíndice tiene el formato general:
variable (subíndice)
en el que variable es un nombre de variable y puede ser numérica o de cadena. El subíndice o

índice es cualquier constante numérica positiva, variable o expresión matemática y se utiliza para
especificar qué valor de la variable se utiliza. Ejemplos de variables de subíndice son:
A(7) el elemento séptimo de A; 7 es el subíndice

TJ(42) el elemento 42º de TJ; 42 es el subíndice
F$(18) el elemento 18º de F$; 18 es el subíndice
Así pues, en general, las características de un vector en cualquier lenguaje de programación son:
❏ Todos los elementos son del mismo tipo (numérico o cadena).

❏ El vector tiene un nombre único y los elementos están ordenados de acuerdo al subíndice
Distintas formas de representación de un vector
Vector A:
A(1) A(2) A(3).....A(n) A(1), A(2), A(3),....,A(n)
A(1) A(2) A(3) A(4) ... ... A(n) A(1)

A(2)
A(3)
......
......
A(n)
En el momento de comenzar la ejecución de un programa, los elementos de los vectores tienen el

valor cero en el caso de vectores numéricos y cadena nula en el caso de vectores de cadenas de
caracteres.
Los vectores se suelen representar en forma de listas como muestra la Figura anterior.
Si los elementos de los vectores ya tienen valores almacenados, un sistema de representación
típico suele ser el de la Figura que se observa a continuación.

Vectores Numéricos:
Índice 1 2 3 4 5 6 7 8 9
Valor 4 51 32 -14 25 6 9 14 23
A partir de ahora, el paréntesis (o corchetes) después del nombre de una variable estará indicando
que se está refiriendo a un vector en lugar de a una variable ordinaria. Es decir, A() es el vector
llamado A.
Lectura/Salida de Datos
A continuación veremos como se realiza la lectura de los datos de un vector. La salida se realizará
en una forma similar.
Si conocemos la cantidad de elementos del vector utilizamos el ciclo exacto (for).
Repetir desde Si no conocemos el número de elementos

v← i hasta v← f F podemos utilizar un “centinela”
←1
i←
V ←
A(i)←
A(v)
Mientras F
A(i) <>-999
V
← i+1
i←
A(i) ←
Figura 26 - Dos manera de realizar la lectura de datos
Matrices: arrays de dos dimensiones

Recordemos que un array de una dimensión o vector es básicamente una serie de posiciones de
memoria que se identifican por un nombre. Dicho de otra forma, una columna o fila de datos. Cada
posición en el vector viene dado por un número (el subíndice o índice) que lo distingue de los
demás.
Un array de dos dimensiones, denominado también matriz o tabla, es un array con filas y columnas
que tiene dos dimensiones. Así una matriz o tabla de 4 filas y 6 columnas se representa:
Col 1 Col 2 Col 3 Col 4 Col 5 Col6

fila 1 3 4 6 7 -1 0
fila 2 14 20 16 8 2 4
fila 3 0 4 5 -6 3 8
fila 4 4 3 2 1 0 -1
El diagrama anterior representa una matriz de dos dimensiones con 4 x 6 elementos = 24 y de
nombre B. Los elementos de una matriz se referencian con un subíndice para la fila y otra para las
columnas.
B (2 , 5) elemento correspondiente a la segunda fila y quinta columna: su valor es 2

Lectura/Salida de datos
Como en el caso de vectores se pueden o no conocer el número de elementos de la matriz.

Veremos a continuación el método a utilizar cuando este se conoce.
Repetir desde
f← pf hasta f← uf F Figura 27 - Diagrama de la lectura de datos de una matriz
V
Repetir desde
c← pc hasta c← uc F
V
A(f, c)
En este caso, la matriz o tabla se irá cargando fila por fila.
Arrays multidimensionales
En general, los lenguajes de programación permiten declarar arrays con un número elevado de
dimensiones, pero es difícil tener que declarar array con más de 3 dimensiones.
Una matriz de tres dimensiones A(I,J,K) se puede representar por un cubo o paralelepípedo. Así,
por ejemplo, la matriz T(3,2,5).
Figura 28 - Representación de un array de 3 dimensiones
La mayoría de las aplicaciones no utilizan arrays con más de tres dimensiones, posiblemente
porque visualizar más de tres dimensiones parece demasiado abstracto.
Declaraciones de arrays. Sintaxis utilizadas en Visual Basic

Declarar un array es definir dentro del programa la estructura que tendrá ese array: nombre, tipo
de array, tipos de elementos de array y número de elementos del array (tamaño).

Los elementos de un array vienen definidos por dos subíndices que señalan los límites inferior y
superior del total de elementos.
Visual Basic permite dos tipos de array: Estáticos y dinámicos.
Array Estáticos
Para declarar un array estático, formado por un número fijo de elementos, Visual Basic utiliza una
sintaxis parecida a la declaración de variables. Veamos algunos ejemplos:
Dim Array_A(19) As String
declara un array unidimensional de 20 elementos: Array_A(0), Array_A(1)...
Dim Array_B(3, 1 To 6) As Integer

declara un array bidimensional de 4x6 elementos: Array_B(0,1), Array_B(1,2)...
Array Dinámicos
Para declarar un array dinámico, formado por un número variable de elementos, Visual Basic
utiliza una sintaxis parecida a la declaración anterior. El espacio necesario para un array dinámico
será asignado durante la ejecución del programa. Un array dinámico puede ser redimensionado en
cualquier momento durante la ejecución. Para redimensionarlos se utiliza la sentencia ReDim. Esta
sentencia puede aparecer solamente en un procedimiento y permite cambiar el número de
elementos del array, no el número de dimensiones. Por ejemplo:
Dim Array_A() As String

declara un array unidimensional dinámico. Más tarde, un procedimiento puede utilizar
la sentencia ReDim para asignar el espacio, p.e. ReDim Array_A(4,4)
Cada vez que se ejecuta la sentencia ReDim, todos los valores en el array se pierden. Cuando
interese conservar los valores del array, se utilizará la sentencia ReDim Preserve. Sólo se puede
cambiar el límite superior de la última dimensión.
Métodos de Ordenamiento
La ordenación y búsqueda de la información son de las tareas más realizadas en los procesos de
manejo de datos. Consideremos, por ejemplo, el hecho de encontrar una palabra en un diccionario
o un nombre en una guía telefónica. La búsqueda del elemento particular se simplifica
considerablemente por el hecho de que las palabras del diccionario y los nombre de la guía
telefónica están ordenados o clasificados en orden alfabético.
A continuación veremos la terminología básica a aplicar y desarrollaremos uno de los más
sencillos métodos de ordenación, ya que estos se verán en detalle en materias posteriores.
La ordenación o clasificación de datos consiste en la clasificación de los mismos de acuerdo con

algún valor o característica.
Los métodos de ordenación son muy variados, y la elección del algoritmo adecuado debe realizarse
con criterios de eficiencia (tiempo de ejecución) y en función de la memoria disponible.
Generalmente se pueden dividir en dos grandes grupos:
Directos: Método de la burbuja, Selección, Inserción, etc.

Avanzados: Método Shell, Quick Sort
En el caso de las listas pequeñas, los métodos directos se demuestran eficaces y relativamente
eficientes, ya que la codificación de los algoritmos correspondientes no es muy compleja.
Sin embargo, en array grandes estas ordenaciones directas pueden ser muy ineficaces y se
necesitan métodos de ordenación avanzados.

Ordenamiento por Selección
Veremos como aplicación el método de ordenamiento por selección, que es uno de los métodos
directos, y que nos permite de manera sencilla ordenar listas de pocos elementos,
Este método consiste buscar el elemento más pequeño de entre los N elementos de un tabla y
colocarlo en el primer lugar. De igual manera se procede con los N-1 elementos restantes para
colocarlo en la segunda posición y así sucesivamente.
Los pasos a seguir son:
1- Seleccionar el elemento más pequeño del vector.
2- Intercambiarlo con el elemento ubicado en la primera posición.
3- Buscar a partir del segundo elemento en adelante el dato más pequeño.
4- Intercambiarlo con el valor almacenado en la segunda posición.
5- Repetir este procedimiento con los elementos restantes.
Veamos el siguiente ejemplo:

Sea el vector A():
1 2 3 4 5 6 7 8
68 24 57 79 11 13 46 35
Buscamos el menor elemento, en este caso A(5)=11 y lo colocamos en el primer lugar, pasando
A(1)=68 al quinto lugar.
Para ello procedemos de la siguiente manera:
Utilizamos una variable temporal Ind. El valor dado es Ind=i=1, por lo que A(Ind)=68 y
comparamos este valor con los restantes elementos.
Como A(Ind)>A(2)=24, guardamos ahora en Ind el valor 2, con lo que A(Ind)=24,. Comparamos
con A(3)=57 que es mayor que A(Ind)=24, con lo que pasamos a comparar con A(4)=79, también
mayor que A(Ind).
Ahora comparamos con A(5)=11 < A(Ind), por lo que lo guardamos en Ind = 5, con lo que
A(Ind)=11, y mantiene su valor pues es el menor elemento. Posteriormente intercambiamos A(Ind)
= A(5) con A(1), quedando:
1 2 3 4 5 6 7 8
11 24 57 79 68 13 46 35
Posteriormente hacemos lo mismo pero comenzando ahora con el segundo elemento: A(2)= 24,
con lo que quedará:
1 2 3 4 5 6 7 8
11 13 57 79 68 24 46 35
Seguimos de esta manera con los hasta los N-1 elementos.
Diagrama de Flujo

Repetir desde
Figura 29 - Algoritmo del F
i=1 hasta i= N-1
ordenamiento por selección
V
←i
Ind←
Repetir desde
j= i+1 hasta j=N F
A(Ind)>A(j)
←J
Ind←
← A(i)
Temp←
← A(Ind)
A(i)←
← Temp
A(Ind)←
CLS
DIM a(9) FOR i = 1 TO N - 1
N = 8 Ind = i
a(1) = 11 FOR J = (i + 1) TO N
a(2) = 24 IF a(Ind) > a(J) THEN
a(3) = 57 Ind = J
a(4) = 59 END IF
a(5) = 68 NEXT J
a(6) = 13 Temp = a(i)
a(7) = 46 a(i) = a(Ind)
a(8) = 35 a(Ind) = Temp
NEXT i
FOR t = 1 TO N
PRINT a(t); FOR t = 1 TO N
NEXT t PRINT a(t);
PRINT NEXT t
Ejercicios
1- Realizar un algoritmo que permita cargar un vector de no menos de 10 elementos, con el cual se
realizarán los siguientes pasos:
a) Presentar por separado los elementos pares e impares del mismo.
b) Determinar cuál es el mayor elemento del vector y en que posición está ubicado.
c) Hallar todos los múltiplos de N en el vector siendo N un número a ingresar.
d) A partir del vector original A(), generar un nuevo vector B() tal que el primer elemento del
vector A() sea el último del B() y así sucesivamente.

2- Se desea cargar un vector con nombres de personas con la salvedad de que el proceso se pueda
finalizar con el ingreso de un asterisco (*) .
Se desea visualizar, el número de elementos leídos y todos los nombres. Además se desea extraer
todos los nombres que comiencen con la letra A en un nuevo vector y el número de los mismos.
3- Realizar un algoritmo que permita cargar una matriz de 5 filas por 4 columnas y calcular:
a- La suma de las filas 2, 3, 4 y 5.
b- El mayor elemento de las tres últimas columnas.
c- Presentar la matriz y los resultados obtenidos.
4- Realizar un algoritmo que permita leer un número natural N, y a continuación los valores de una
matriz de N por N elementos. Luego imprimir los elementos de la diagonal principal y de la
contradiagonal.
5- Realizar un algoritmo que permita cargar una matriz de 40 por 30 elementos, y obtener un
vector de 40 elementos formado por los mínimos de cada fila.
6- Crear un algoritmo que permita cargar un vector con no menos de 10 elementos con valores
enteros de 2 cifras y luego ordenarlos en forma creciente y decreciente. Imprimiendo los resultados
obtenidos.
7- Modificar el algoritmo anterior para crear a partir del primero, dos nuevos vectores con los
valores ordenados.
8 - Crear una aplicación que permita crear un cuadrado mágico. Un cuadrado mágico es aquel en
el que todas las filas, columnas y diagonales principales suman lo mismo. Para resolver el ejercicio
se utilizará el argumento de Loubère, que funciona solo con cuadrados mágicos impares:
Colocar 1 en el centro de la primera fila.
Los números se colocan en orden moviéndose hacia arriba en diagonal hacia la derecha.
Si se sale por la parte superior se sustituye por el lugar correspondiente de la fila inferior.
Si se sale por la derecha se sigue en la posición correspondiente de la columna izquierda.
Si se llena el cuadrado o se alcanza la esquina superior derecha, desplazarse hacia abajo y
continuar con las reglas.
17 24 1 8 15
23 5 7 14 16
4 6 13 20 22
10 12 19 21 3
11 18 25 2 9
9- Crear una aplicación que permita obtener el elemento mayor de una matriz cuadrada de
dimensión cualquiera. Los elementos de la matriz serán números entre el 1 y el 1000 introducidos
aleatoriamente.
10- Realizar un algoritmo que permita implementar un filtro promedio móvil a los valores leidos
en un vector a partir de una adquisición de .
Explicación y Resolución Ejercicio 10 - Filtro Promedio Móvil

El promedio móvil es el tipo de filtrado más común en el procesamiento de señales,
principalmente porque es el filtro más fácil de entender y utilizar.

A pesar de su simplicidad, el filtro de promedio móvil es óptimo para una tarea común: reducir el
ruido aleatorio presente en una señal.
Como su nombre lo indica, el filtro de promedio móvil opera promediando un número de puntos
desde la señal de entrada para producir cada punto de la señal de salida.
En forma de ecuación sería:
Y[i]=1/M Sumatoria x[i+j]
Donde x[] es la señal de entrada, y[] es la señal de salida y M es el número de puntos involucrados.
La capacidad de reducción de ruido de un filtro de promedio móvil es igual a la raíz cuadrada del
número de puntos involucrados en el promedio.
Por ejemplo, un filtro promedio móvil de 100 puntos reduce el ruido por un factor de 10.
Este método de filtro digital es ampliamente utilizado en microcontroladores pues su
implementación requiere pocas instrucciones y un espacio moderado de memoria RAM.
Aplicación de Filtrado por Promedio Móvil a la Corriente del Motor
240.00
220.00
200.00
180.00
160.00
140.00
120.00
100.00
8:00:00 9:12:00 10:24:00 11:36:00 12:48:00 14:00:00 15:12:00 16:24:00 17:36:00 18:48:00
Cte Motor 50 per. media móvil (Cte Motor)
En la página siguiente se puede obserbar la implementación del algoritmo por medio de un

diagrama de flujo de un Filtro Promedio Móvil a Partir de datos registrados en un vector.

Comienzo
Repeitr desde 1
hasta TotalMediciones
iContador <-0
fAcumulador <-0
Mientras (iContador < iPeriodos Y

iBucle < (TotalMediciones - iPeriodos)
fAcumulador <- fAcumulador + fValor(iBucle + iContador)
iContador ++
iTemporal1<-Ent((iPeriodos / 2))
Si iBucle
<=
iTemporal1
fMovil(iBucle) <- fValor(iBucle)
iTemporal2<-(TotalMediciones - Ent(iPeriodos / 2) - 1)
Si iBucle <
iTemporal2
Si iBucle >=
iTemporal3 Y
<=TotalMediciones
fMovil(iBucle + Int(iPeriodos / 2)) <- fAcumulador / iPeriodos
fMovil(iBucle) <- fValor(iBucle)
Fin

Listado del Procedimiento Implementado
Public Sub FiltroPromedioMovil(fValor() As Single, fMovil() As Single,

TotalMediciones As Integer)
' Procedimiento para realizar un filtro promedio móvil de los valores
leidos.
' Realizado el 17/05/2001
'
Static iPeriodos As Integer, iContador As Integer, fAcumulador As
Single, iBucle As Integer
'
iPeriodos = Parametros.CoefFiltroCurvas
For iBucle = 1 To TotalMediciones
iContador = 0
fAcumulador = 0
Do While (iContador < iPeriodos And iBucle < (TotalMediciones -
iPeriodos))
fAcumulador = fAcumulador + fValor(iBucle + iContador)
iContador = iContador + 1
Loop
If iBucle <= Int((iPeriodos / 2)) Then
fMovil(iBucle) = fValor(iBucle)
End If
If iBucle < (TotalMediciones - Int(iPeriodos / 2) - 1) Then
fMovil(iBucle + Int(iPeriodos / 2)) = fAcumulador / iPeriodos
ElseIf iBucle >= (TotalMediciones - Int(iPeriodos / 2) - 1)
And iBucle <= TotalMediciones Then
fMovil(iBucle) = fValor(iBucle)
End If
Next iBucle
End Sub

Archivos en Visual Basic
Introducción
Muchas aplicaciones requieren almacenar y recupera datos de una sesión a otra. Los archivos de
datos permiten almacenar información en un archivo separado en el disco, esto es un archivo
independiente de los archivos que almacena la aplicación.
Una archivo de datos está compuesto por registros, los cuales a su ves se encuentran separados en
campos. Para clarificar, supongamos que deseamos guardar los siguientes datos personales de un
grupo de personas:
Apellido y Nombre CP Edad

Dirección Provincia Peso
Localidad Teléfono Altura
Cada uno de los anteriores datos representa un campo, y el conjunto de estos campos un registro
para una determinada persona.
Si lo representáramos en un formato de tabla, los campos corresponderían a las colúmnas, y los
registros a las filas.
Nombre Dirección Localidad CP Prov. Tel. Edad Pes Altura

o
1 José S.Martin 10 C. del Urug. 3260 E. Ríos 12345 22 68 1,70
2 María S. Martín 500 Colón 3270 E. Ríos 45114 24 62 1,65
3 Juan Alberdi 400 C. del Urug. 3260 E. Ríos 20155 34 75 1,80
4 Marina 9 de Julio 895 C. del Urug. 3260 E. Ríos 26560 32 58 1,63
5 Natalia Sarmiento Colón E.Ríos 12120 22 61 1,64
621
Tipos de Acceso a Archivos

Los archivos proporcionan una manera de almacenar información a largo plazo. Visual Basic
ofrece tres formas de acceder a los datos:
Archivo secuencial: Se lee una línea cada vez. Cada línea podrá ser tan larga como quiera.
Cuando se empieza a leer un archivo secuencial, se empieza por la primera línea y se continúa con
la siguiente hasta llegar al final. En este tipo de archivos para acceder a un registro determinado se
deben primero leer los registros anteriores. Ejemplos: archivos TXT
Archivo aleatorio: El contenido de los registros puede ser leído y escrito en el orden que se
necesite, ya que se puede acceder a cualquir registro sin necesidad de leer los ateriores
Está formado por un conjunto de registros de la misma longitud. Cada registro individual se
identifica con un único número y puede ser leído, escrito o actualizado en cualquier orden, siempre
y cuando se conzca el número del registro al cual se desea acceder. Ejemplos: archivos que
simulen bases de datos.
Archivo binario: Es una colección de bytes o secuencia numerada de caracteres,

independientemente de la estructura del mismo. Ofrecen la posibilidad de almacenar los datos
como se quiera, aunque para poder acceder a ellos, es necesario conocer cómo fueron escritos.
Ejemplos: archivos EXE

En esta cátedra veremos dos tipos de acceso a archivos: el secuencial y el aleatorio.
Para cualquiera de estos dos tipos los pasos a seguir en el manejo de archivos son:
1. Definir los campos, tipo de datos y longuitud de los mismos.
2. Escribir los datos en el archivo (esta es la forma en que se crea el archivo)
2.1 Abrir el archivo en el modo de escritura o para agregar datos
2.2 Escribir los datos en el archivo (generalmente dichos datos se encuentran en variables)
2.3 Cerrar el archivo
3. Leer datos de un archivo
3.1 Abrir el archivo en el modo de lectura
3.2 Leer los datos en el archivo (y pasarlos a variables)
3.3 Cerrar el archivo
Los pasos anteriores son los que desarrollaremos a continuación, en los casos particulares de
archivos secuenciales y aleatorios.
La siguiente tabla muestra las instrucciones habitualmente usadas al escribir y al leer datos en
archivos de acuerdo al tipo del mismo.
Tipo de acceso Grabar datos Leer datos

Secuencial Print #, Write # Input #
Aleatorio Put Get
Binario Put Get
Archivos de Acceso Secuencial
Abrir archivos secuenciales

La instrucción Open (abrir) le dice a Visual Basic a qué archivo debe acceder. La sintaxis es:
Open NombreDeArchivo For {Input | Output| Append} As #NúmeroDeArchivo
donde Input indica si se quiere leer del archivo, Output si se quiere escribir de él, Append si se
quiere añadir información al final del fichero y, NumeroDeArchivo es un número entre 1 y 255.
Si se trata de abrir para lectura un archivo que no existe, se producirá un error. Si se abre para
escritura Visual Basic creará un nuevo archivo, reemplazando cualquier archivo con ese nombre.
Si no se sabe qué número de archivo está libre, se utilizará el siguiente código:
NumArchivo = FreeFile
Open NomArch For {Input | Output} As #NumArchivo
Cerrar archivos secuenciales

Después de trabajar con un archivo, se debe cerrar con la instrucción Close, cuya sintaxis es:
Close #NúmeroDeArchivo
Si la intrucción Close se utiliza sin poner NumeroDeArchivo, se cerrarán todos los ficheros
abiertos.
Escribir en archivos secuenciales

Para escribir en un archivo secuencial, utilizaremos las instrucciones Print o Write con la
sintaxis:
Print #NúmeroDeArchivo [, expresión [{ , | ; } expresión] ...] [{ , | ; }]
Write #NúmeroDeArchivo [, expresión [{ , | ; } expresión] ...] [{ , | ; }]

Write y Print son diferentes. Write inserta comas entre los distintos items a escribir en el fichero.
Si se desean conservar los valores de un archivo abierto para escritura, se tendrá que abrir en modo
Append y no Output.
Por tanto, para escribir en un archivo de acceso secuencial se seguirán los pasos:
1. Abrir el fichero para escritura con: Open NombreDeArchivo For Output As
#NúmeroDeArchivo
2. Escribir los datos en el fichero utilizando la sentencia: Print #NúmeroDeArchivo, expresiones
3. Cerrar el archivo con la sentencia: Close #NúmeroDeArchivo
Como ejemplo guardaremos en un archivo secuencial los datos de la Tabla 1.
En este caso en ves de utilizar la variable NombreDeArchivo, directamente escribimos dicho

nombre
Open “DATOS.DAT” For Output As #1

Print #1,Nombre, Direccion, Localidad, CP, Prov, Tel, Edad, Peso,
Altura
Close #1
Leer de archivos secuenciales

Para leer de un archivo secuencial se utilizará la instrucción Input ó Line Input que permite leer
una línea cada vez y que tiene la sintaxis:
Input #NúmeroDeArchivo, VariableDeCadena

o bien se utilizará:
Line Input #NúmeroDeArchivo, VariableDeCadena
o bien se utilizará:
VariableDeCadena = Input(NúmCaracteres, #NúmeroDeArchivo)
donde la última instrucción, permite leer un número determinado de caracteres y, está limitado a
ficheros de 32.767 bytes máximo.
La función EOF (Fin De Fichero) indica cuándo se acaba un archivo. A esta función hay que
facilitarle el número de archivo correspondiente y, devolverá True si se ha leído toda la
información del archivo. La función LOF (Longitud De Archivo) indica la longitud de un archivo.
Por tanto, para leer de un archivo de acceso secuencial se seguirán los pasos:
Abrir el fichero para lectura con: Open NombreDeArchivo For Input As #NúmeroDeArchivo
Leer los datos del fichero utilizando las sentencias:

Line Input #NúmeroDeArchivo, VariableDeCadena; o bien
Input #NúmeroDeArchivo, VariableDeCadena; o bien
VariableDeCadena = Input$ NúmCaracteres, #NúmeroDeArchivo
Cerrar el archivo con la sentencia: Close #NúmeroDeArchivo
En este ejemplo se utiliza la instrucción Input # para leer datos de la tabla 1 un archivo y ponerlos
en
variables.
Open "Datos.Dat" For Input As #1 ' Abre archivo para recibir datos.
Do While Not EOF(1) ' Repite el bucle hasta fin archivo.
Input #1 ,Nombre, Direccion, Localidad, CP, Prov, Tel, Edad, Peso,
Altura ‘Ponen los datos en las variables.
Loop
Close #1 ' Cierra el archivo.

Archivos de Acceso Aleatorio
Abrir y cerrar archivos aleatorios

Modificaremos la instrucción Open (abrir) con la sintaxis:
Open NombreDeArchivo For Random As #NúmeroDeArchivo Len = LongitudDelRegistro
En un archivo de acceso aleatorio, se puede leer o escribir sin tener que cerrar cada vez.. Se debe
facilitar el número de bytes que se deben leer o escribir. Para cerrar un archivo aleatorio, se
utilizará Close como si fuera un archivo secuencial.
Leer y escribir de archivos aleatorios

Para leer y escribir de un archivo aleatorio, utilizaremos las instrucciones Get y Put
respectivamentes, con las sintaxis:
Get #NúmeroDeArchivo, [NúmeroDeRegistro] , Variable
Put #NúmeroDeArchivo, [NúmeroDeRegistro] , Variable
Get lee del archivo y almacena los datos en la variable, mientras que Put escribe el contenido de la
variable en el archivo.
Por tanto, para leer / escribir en un archivo de acceso aleatorio, se seguirán los pasos:
Abrir el fichero para acceso aleatorio con: Open NombreDeArchivo For Random As
#NúmeroDeArchivo Len = LongitudRegistro
Escribir los datos en el fichero utilizando la sentencia:

Put #NúmeroDeArchivo, [NúmeroDeRegistro] , Variable
o bien leer los datos del archivo con la sentencia:
Get #NúmeroDeArchivo, [NúmeroDeRegistro] , Variable
Cerrar el archivo con la sentencia: Close #NúmeroDeArchivo
En este ejemplo se utiliza la instrucción Put para escribir datos en un archivo del disco. Se
escriben cinco registros del tipo definido por el usuario Registro.
Type Registro ' Definir el tipo definido por

el usuario.
ID As Integer
Nombre As String * 20
Direccion As String * 20
Localidad As String * 30
CP As String * 4
Prov As String * 30
Tel As String * 10
Edad As Integer
Peso As Single
Altura As Single
End Type
Dim MiRegistro As Registro ' Declara la variable.

' Abrir archivo para acceso aleatorio.
Open "Datos.Dat" For Random As #1 Len = Len(MiRegistro)
For NumeroRegistro = 1 To 5 ' Repite 5 veces el bucle.
MiRegistro.ID = NumeroRegistro ' Define el ID.
Put #1, NumeroRegistro, MiRegistro ' Escribe el registro.
Next NumeroRegistro

Detalle de las Instrucciones y Funciones Utilizadas con Archivos
A continuación se reproducen las instrucciones utilizadas en el manejo de archivos. Se incluyen
además ejemplos de su utilización, que pueden servir de guía en el momento de realizar
aplicaciones.
Se han tratado de dividir de acuerdo a el tipo de acceso, si bien algunas de ellas se utilizan para
todos los tipos de acceso, como ser las instrucciones Open y Close.
1. Open (Instrucción)
Activa operaciones de entrada/salida (E/S) con un archivo.
Sintaxis:
Open nombreruta [For modo] [Access acceso] [bloquear] As [#]

númeroarchivo [Len=longitudregistro]
La sintaxis de la instrucción Open tiene estas partes:
Parte Descripción
nombreruta Expresión de cadena que especifica un nombre de archivo
nombrearchivo puede incluir el directorio o carpeta y la unidad de disco.
modo Palabra clave que especifica el modo de archivo: Append, Binary, Input, Output o
Random.
acceso Palabra clave que especifica las operaciones permitidas en el archivo abierto: Read,
Write o Read Write.
bloquear Palabra clave que especifica las operaciones permitidas en el archivo abierto por
otros procesos: Shared, Lock Read, Lock Write y Lock Read Write.
númeroarchivo Un número de archivo en el intervalo 1 a 511 inclusive. Para obtener el número del
siguiente archivo disponible se utiliza la función FreeFile.
longitudregistro Número igual o inferior a 32,767 (bytes). En archivos abiertos para acceso
aleatorio, este número es la longitud del registro. Para archivos secuenciales, este
valor es el número de caracteres colocados en el área de memoria intermedia.
Observaciones
Antes de poder ejecutar una operación de E/S en un archivo, éste debe estar abierto. Open asigna
un área de memoria intermedia para operaciones de E/S con el archivo y determina el modo de
acceso que se debe utilizar con el área de memoria intermedia.
Si el archivo especificado con nombreruta no existe, se crea al abrir un archivo en los modos
Append, Binary, Output o Random. Si el archivo ya ha sido abierto por otro proceso y no se
permite el tipo de acceso especificado, la operación Open fracasa y se produce un error.
Importante En los modos Binary, Input y Random se puede abrir un archivo utilizando un número
de archivo distinto sin necesidad de cerrarlo antes. En los modos Append y Output se debe cerrar
el archivo para poder abrirlo con un número de archivo distinto.
Ejemplos de la instrucción Open
Se ilustran varios usos de Open para habilitar operaciones de entrada/salida a un archivo.
El siguiente ejemplo abre el archivo PRUEBA en modo de entrada secuencial.

Open "PRUEBA" For Input As #1
' Cierra antes de volver a abrir en otro modo.
Close #1
Se abre el archivo en modo de acceso aleatorio. El archivo contiene registros del tipo definido por el usuario Record.
Type Registro ' Define un tipo definido por el usuario.
ID As Integer
End Type

Dim MiRegistro As Record ' Declara una variable.
Open "PRUEBA" For Random As #1 Len = Len(MiRegistro)
' Cierra antes de volver a abrir en otro modo.
Close #1
2. Close (Instrucción)
Termina las operaciones de entrada/salida en un archivo abierto con la instrucción Open.
Sintaxis: Close [listadenúmerosdearchivo]
El argumento listadenúmerosdearchivo puede estar constituido por uno o más números de archivo,
donde númerodearchivo es cualquier número de archivo válido y tiene la siguiente sintaxis:
[[#]númerodearchivo][, [#]númerodearchivo] . . .
Observaciones
Si se omite la listadenúmerosdearchivo, se cierran todos los archivos activos abiertos con la
instrucción Open.
3. Print # (archivo secuencial)

Escribe los datos con formato de muestra en un archivo secuencial.
Sintaxis: Print #númeroarchivo, [listasalida]
La sintaxis de la instrucción Print # tiene estas partes:
Parte Descripción
númeroarchivo Cualquier número de archivo válido.
listasalida Expresión o lista de expresiones a imprimir.
Configuración
El argumento listasalida tiene la configuración siguiente:
[{Spc(n) | Tab[(n)]}][expresión][poscarácter]
Parte Descripción
Spc(n) Se utiliza para insertar caracteres de espacio en la salida, donde n es el número de
caracteres de espacio a insertar.
Tab(n) Se utiliza para colocar el punto de inserción en una número de columna absoluta, donde n
es el número de columna. Se utiliza Tab sin argumento para colocar el punto de inserción
al comienzo de la siguiente zona de impresión.
expresión Expresión numérica o de cadena a imprimir.
poscarácter Especifica el punto de inserción del carácter siguiente. Se utiliza un punto y coma (;) para
especificar que el punto de inserción debe estar inmediatamente después del último
carácter que se ha mostrado. Se usa Tab(n) para colocar el punto de inserción en un
número de columna absoluta. Se usa Tab sin argumentos para colocar el punto de inserción
al comienzo de la siguiente zona de impresión. Si se omite PosCarácter, el siguiente
carácter se imprime en la línea siguiente.
Observaciones
Si se omite listasalida y se incluye sólo un separador de listas después de númeroarchivo, se
imprime una línea en blanco en el archivo. Se pueden separar varias expresiones por medio de un
espacio o de una punto y coma (;). El espacio tiene el mismo efecto que el punto y coma.
Todos los datos escritos en el archivo por medio de Print # están internacionalizados; es decir,
tienen el formato apropiado (con el separador decimal correcto) y las palabras clave se imprimen
en el formato apropiado de la información local especificada en el sistema. En el caso de datos del

tipo Boolean se imprime True o False. Las palabras clave True y False son traducidas de la manera
apropiada para la información local definida en el sistema.
Dado que Print # escribe una imagen de los datos en el archivo, se deben delimitar los datos para
que se impriman correctamente. Si se utiliza Tab sin argumentos para colocar la posición de
impresión en la siguiente zona de impresión, Print # también escribe en el archivo los espacios
entre campos de impresión.
Nota: Si, en el futuro, se necesita leer por medio de la instrucción Input # los datos contenidos en
un archivo, se debe utilizar la instrucción Write # en vez de la instrucción Print # para escribir los
datos en el archivo. La utilización de Write # asegura la integridad de cada campo de datos
separado, al delimitarlo adecuadamente, de modo que pueda ser leído otra vez utilizando Input #.
La utilización de Write # asegura también que los datos puedan ser leídos correctamente en
cualquier información local.
Ejemplo de la instrucción Print #
En este ejemplo se utiliza la instrucción Print # para escribir datos en un archivo.
Open "PRUEBA" For Output As #1 ' Abre el archivo para salida.

Print #1, " Esta es una prueba " ' Escribe texto en el archivo.
Print #1, ' Imprime una línea en blanco.
Print #1, "Zona 1"; Tab ; "Zona 2" ' Escribe en dos zonas de impresión.
Print #1, "Hola" ; " " ; "Mundo" ' Separa las cadenas de
caracteres con un espacio.
Print #1, Spc(5) ; "5 esp. iniciales " ' Escribe 5 espacios iniciales.
Print #1, Tab(10) ; "Hola" ' Escribe una palabra en la colum 10.
Close #1 ' Se cierra el archivo.
4. Write # (archivo secuencial)

Escribe datos no procesados en un archivo secuencial.
Sintaxis: Write #numarchivo, [listasalida]
La sintaxis de la instrucción Write tiene estas partes:
Parte Descripción
numarchivo Cualquier número de archivo válido.
listasalida Una o varias expresiones de cadena o numéricas delimitadas por comas que se
desea escribir en un archivo.
Observaciones
Si se omite listasalida y se incluye un punto y coma después de númerofila, se imprime una línea
en blanco en el archivo. Se pueden separar múltiples expresiones con un espacio, un punto y coma
(;) o una coma. Un espacio tiene el mismo efecto que un punto y coma.
Cuando se utiliza Write # para introducir información en un archivo, se siguen distintas
convenciones universales, de modo que los datos pueden ser siempre leídos e interpretados
correctamente mediante la ejecución de Input #, independientemente de la información local con la
que esté trabajando:
❏ Los datos numéricos son siempre introducidos utilizando la coma (,) como separador decimal.
❏ Para datos de tipo Boolean se imprime #TRUE# o #FALSE#. Las palabras clave True y False
no son traducidas, independientemente de la información local con la que esté trabajando.
❏ Las fechas son escritas en el archivo con el formato de fecha universal. Si el componente
correspondiente a la fecha o a la hora falta o es igual a cero, sólo se escribe en el archivo la
parte suministrada.
❏ Si los datos de listasalida son de tipo Empty, no se escribe nada en el archivo. Sin embargo, en
el caso de datos Null, la salida es #NULL#.
❏ Para datos de Error, la salida aparece en el formato #ERROR códigoerror#. La palabra clave
Error no se traduce, independientemente de la información local con la que esté trabajando.
A diferencia de la instrucción Print #, la instrucción Write # inserta puntos y coma entre elementos
y comillas alrededor de cadenas de caracteres, cuando se escriben en el archivo. No es necesario
colocar delimitadores en la lista. Write # inserta un carácter de línea siguiente, que es un retorno
de carro (Chr(13)) o continuación de línea (Chr(13) + Chr (10)), después de que se ha escrito el
último carácter de listasalida en el archivo.
Ejemplo de la instrucción Write #
En este ejemplo se utiliza la instrucción Write # para escribir datos no procesados en un archivo
secuencial.
Open "PRUEBA" For Output As #1 ' Abre el archivo para salida.

Write #1, "Hola a todos ", 234 ' Delimita con comas los datos.
Write #1, ' Coloca una línea en blanco.
Close #1 ' Se cierra el archivo.
5. Input # (archivo secuencial)

Lee datos de un archivo secuencial abierto y asigna esos datos a variables.
Sintaxis: Input #númarchivo, listavariables
La sintaxis de la instrucción Input # tiene las siguientes partes:
Parte Descripción
númarchivo Cualquier número de archivo válido.
listavariables Lista de variables delimitadas por puntos y coma a las que se asignan valores que se
leen de un archivo no pueden ser matrices ni variable objeto. Sin embargo, se
pueden utilizar variables que describen un elemento de una matriz y tipos definidos
por el usuario.
Observaciones
Utilice esta instrucción únicamente con archivos abiertos en los modos Input o Binary.
Cuando se leen datos numéricos o cadenas estándar, se asignan tal y como son a variables.
Se ignoran las comillas dobles (") en la entrada de datos.
Los elementos de los datos de un archivo deben aparecer en el mismo orden que tienen las
variables en listavariables y deben coincidir con variables del mismo tipo de datos. Si una variable
es numérica y los datos no lo son, se asigna cero a esa variable.
Si se llega al fin del archivo cuando se está introduciendo un elemento de los datos, se da por
terminada la entrada y se emite un error.
Nota Para introducir correctamente en variables los datos leídos de un archivo, se debe utilizar
siempre la instrucción Write #, en lugar de Print #, para grabar la información en los archivos. La
utilización de Write # garantiza que cada campo de datos separado se delimite correctamente.
Ejemplo de la instrucción Input #

En este ejemplo se utiliza la instrucción Input # para leer datos de un archivo y ponerlos en dos
variables. Se supone que PRUEBA es un archivo que contiene unas pocas líneas de datos que
fueron escritos en él por medio de la instrucción Write #; o sea, que cada línea contiene una

cadena de caracteres entre comillas y un número separado por un punto y coma, por ejemplo,
("Hola", 234).
Open "PRUEBA" For Input As #1 ' Abre el archivo para recibir los datos.
Do While Not EOF(1) ' Repite el bucle hasta fin de archivo.
Input #1, MiCadena, MiNumero ' Ponen los datos en las variables.
Debug.Print MiCadena, MiNumero ' Muestran los datos en la
ventana Depuración.
Loop
6. LineInput # (archivo secuencial)

Lee una línea de un archivo secuencial abierto y la asigna a una variable de cadena de caracteres.
Sintaxis: Line Input #númeroarchivo, nombrevariable
La sintaxis de la instrucción Line Input # tiene estas partes:
Parte Descripción
nombrevariable Nombre de variable de cadena de caracteres válido.
Observaciones
La instrucción Line Input # lee un carácter cada vez en un archivo hasta que encuentra un retorno
de carro (Chr(13)) o una secuencia retorno de carro-continuación de línea (Chr(13) + Chr(10)).
Ejemplo de la instrucción Line Input #
En este ejemplo se utiliza la instrucción Line Input # para leer una línea de un archivo secuencial
y asignarla a una variable. Se supone que PRUEBA es un archivo de texto con unas pocas líneas
de datos de muestra..
Open "PRUEBA" For Input As #1 ' Abre el archivo.

Do While Not EOF(1) ' Repite el bucle hasta el fin del archivo.
Line Input #1, LineaTexto' Establece la línea del archivo como la
variable LíneaTexto.
Debug.Print LineaTexto ' Muestra la línea en la ventana
Depuración.
Loop
7. Put (archivo secuencial)

Escribe en un archivo de disco los datos contenidos en una variable.
Sintaxis: Put [#]númeroarchivo, [númeroregistro], nombrevar
La sintaxis de la instrucción Put tiene estas partes:
Parte Descripción
númeroregistro Número de registro (archivos en modo Random) o número de byte (archivos en
modo Binary) en el cual se comienza a imprimir.
nombrevariable Nombre de la variable que contiene la información a escribir en el disco.
Observaciones
El primer registro/byte de un archivo se encuentra en la posición 1, el segundo en la posición 2 y
así sucesivamente. Si se omite NúmeroRegistro , se escribe el siguiente registro o byte (el que se
encuentra después de la última instrucción Get o Put o aquél al que la última función Seek). Se
deben incluir puntos y coma de delimitación, por ejemplo:
Put #4,,BuferArchivo
En los archivos abiertos en modo Random rigen las siguientes reglas:
❏ Aunque la longitud de los datos escritos sea menor que la especificada en la cláusula Len de la
instrucción Open, Put escribe los registros siguientes según los límites de longitud de registro y
llena el espacio entre el fin de un registro y el comienzo del siguiente con el contenido del área
de memoria intermedia del archivo. Dado que la cantidad de datos de llenado no puede ser
determinada con certeza, se considera una buena práctica que el registro tenga la misma
longitud que los datos que se escriben. Si la longitud de los datos que se escriben es mayor que
la especificada en la cláusula Len de la instrucción Open, ocurre un error.
❏ Si la variable en la que se escribe es una cadena de caracteres de longitud variable, la

instrucción Put escribe un descriptor de 2 bytes que indica la longitud de la cadena de
caracteres y luego escribe la variable. La longitud del registro, especificada por la cláusula en la
instrucción Open, debe ser por lo menos 2 bytes mayor que la longitud efectiva de la cadena de
caracteres.
❏ Si la variable que se va a incorporar es una Variant de tipo numérico, la instrucción Put escribe
2 bytes para identificar el VarType de la Variant y luego la variable. Por ejemplo, al escribir
una Variant de tipo VarType 3, Put escribe 6 bytes: 2 bytes para identificar la Variant que sea
del tipo VarType 3 (Long) y 4 bytes que contienen los datos del tipo Long. La longitud del
registro, especificada por la cláusula Len en la instrucción Open debe ser por lo menos 2 bytes
mayor que el número efectivo de bytes requerido para almacenar la variable.
Nota Puede utilizar la instrucción Put para escribir una matriz Variant en disco, pero no puede
emplear Put para escribir en disco una Variant escalar que contiene una matriz. Tampoco puede
utilizar Put para escribir objetos en disco.
❏ Si la variable escrita es una variante del tipo String Variant (VarType 8), Put escribe 2 bytes
para identificar el VarType, 2 bytes para indicar la longitud de la cadena y luego la cadena en
sí. La longitud del registro, especificada por la cláusula Len en la instrucción Open, debe ser
por lo menos 4 bytes mayor que la longitud efectiva de la cadena.
❏ Si la variable escrita es una matriz dinámica, Put escribe un descriptor cuya longitud equivale a
2 más 8 veces el número de dimensiones, es decir, 2 + 8 * NúmeroDeDimensiones. La longitud
del registro, especificada por la cláusula Len en la instrucción Open debe ser mayor o igual que
la longitud de los datos que se escriban. Por ejemplo, la siguiente declaración de matriz
requiere 118 bytes cuando la matriz se escribe en disco.
Dim MiMatriz(1 To 5,1 To 10) As Integer
Los 118 bytes se distribuyen de la siguiente forma: 18 bytes para el descriptor (2 + 8 * 2) y 100
bytes para los datos (5 * 10 * 2).
❏ Si la variable escrita es una matriz de tamaño fijo, Put solamente escribe los datos. No se
escribe en disco ningún descriptor.
❏ Si la variable que se escribe es de cualquier otro tipo (ni una cadena de longitud variable ni una
Variant), Put escribe solamente los datos de la variable. La longitud del registro especificada
por la cláusula Len en la instrucción Open debe ser mayor o igual que la longitud de los datos
escritos.
❏ Put escribe elementos de tipos definidos por el usuario como si escribiera cada uno por
separado, pero no coloca los datos de llenado entre elementos. En el disco, una matriz dinámica
en un tipo definido por el usuario escrita con Put incluye como prefijo un descriptor cuya
longitud es igual a 2 más 8 veces el número de dimensiones, es decir, 2 + 8 *
NúmeroDeDimensiones. La longitud del registro especificada por la cláusula Len en la
instrucción Open debe ser mayor o igual que la suma de todos los bytes necesarios para leer los
elementos por separado, incluyendo algunas matrices y sus descriptores.
Para archivos abiertos en modo Binary, tienen vigencia todas las reglas del modo Random, con las
siguientes excepciones:
❏ La cláusula Len de la instrucción Open no tiene efecto. Put escribe todas las variables en el
disco en forma contigua, es decir sin llenado entre registros.
❏ Para una matriz distinta de la indicada en un tipo definido por el usuario, Put escribe solamente
los datos. No escribe ningún descriptor.
❏ Put escribe las cadenas de caracteres de longitud variable que no son elementos de tipos
definidos por el usuario sin el descriptor de longitud de 2 bytes. El número de bytes que se
escribe es igual al número de caracteres de la cadena. Por ejemplo, en las siguientes
instrucciones se escribe 10 bytes en el archivo número 1:
VarCadena$ = String$(10," ")

Put #1,,VarCadena$
Ejemplo de la instrucción Put
En este ejemplo se utiliza la instrucción Put para escribir datos en un archivo del disco. Se
escriben cinco registros del tipo definido por el usuario Registro.
Type Registro ' Definir el tipo definido por el usuario.

ID As Integer
End Type

' Abrir archivo para acceso aleatorio.
For NumeroRegistro = 1 To 5 ' Repite 5 veces el bucle.
MiRegistro.ID = NumeroRegistro ' Define el ID.
MiRegistro.Nombre = "Nombre" & NumeroRegistro ' Crea una cadena.
Put #1, NumeroRegistro, MiRegistro ' Escribe el registro.
Next NumeroRegistro
9. Get (archivo secuencial)

Lee en un archivo de disco abierto y coloca la información en una variable.
Sintaxis: Get [#]númeroarchivo, [númeroregistro], nombrevariable
La sintaxis de la instrucción Get tiene estas partes:
Parte Descripción
númeroregistro El número de registro (en archivos de modo Random) o el número de byte (en
archivos de modo Binary) desde el que se comienza la lectura.
nombrevariable Nombre de una variable válida en la que se colocan los datos.
Observaciones
El primer registro/byte de un archivo se encuentra en la posición 1, el segundo en la posición 2 y
así sucesivamente. Si se omite númeroregistro, se lee el siguiente registro o byte (el que se

encuentra después de la última instrucción Get o Put o aquél al que apuntó la última función Seek).
Se deben incluir puntos y coma de delimitación, por ejemplo:
Get #4,,FileBuffer
En los archivos abiertos en modo Random rigen las siguientes reglas:
❏ Aunque la longitud de la información que se lee sea menor que la especificada en la cláusula
Len en la instrucción Open, Get lee los registros siguientes según los límites de longitud de
registro. El espacio comprendido entre el final de un registro y el principio del siguiente se
llena con el contenido del área de memoria del archivo. Dado que la cantidad de la información
de llenado no puede ser determinada con certeza, es una buena práctica hacer que el registro
tenga la misma longitud que la información que se lee.
❏ Si la variable en la que se lee la información es una cadena de caracteres de longitud variable,

Get lee un descriptor de 2 bytes que contiene la longitud de la cadena de caracteres y a
continuación los datos que van en la variable. Por lo tanto, la longitud del registro especificada
por la cláusula Len en la instrucción Open debe ser por lo menos 2 bytes mayor que la longitud
efectiva de la cadena de caracteres.
❏ Si la variable que se va a leer es una Variant de tipo numérico, Get lee 2 bytes que identifican el
VarType de la Variant y luego los datos que van en la variable. Por ejemplo, cuando se lee una
Variant de VarType 3, Get lee 6 bytes: 2 bytes que identifican la Variant del VarType 3 (Long)
y 4 bytes que contienen los datos del tipo Long. La longitud del registro, especificada por la
cláusula Len en la instrucción Open, debe ser por lo menos 2 bytes mayor que el número
efectivo de bytes requerido para almacenar la variable.
Nota Puede utilizar la instrucción Get para leer una matriz Variant del disco, pero no puede
emplear Get para leer una Variant escalar que contenga una matriz. Tampoco podrá utilizar Get
para leer objetos del disco.
❏ Si la variable que se va a leer es una String Variant (VarType 8), Get lee 2 bytes que identifican
el VarType, 2 bytes que indican la longitud de la cadena de caracteres y luego la propia cadena.
La longitud del registro especificada por la cláusula Len en la instrucción Open debe ser por lo
menos 4 bytes mayor que la longitud efectiva de la cadena.
❏ Si la variante que va a leer es una matriz dinámica, Get lee un descriptor cuya longitud equivale
a 2 más 8 veces el número de dimensiones, es decir, 2 + 8 * NúmeroDeDimensiones. La
longitud del registro especificada por la cláusula Len en la instrucción Open, debe ser mayor o
igual que la suma de todos los bytes necesarios para leer los elementos por separado. Por
ejemplo, la siguiente declaración de matriz requiere 118 bytes cuando la matriz se escribe en
disco.
Dim MiMatriz(1 To 5,1 To 10) As Integer
Los 118 bytes se distribuyen de la siguiente forma: 18 bytes para el descriptor (2 + 8 * 2) y 100
bytes para los datos (5 * 10 * 2).
Si la variable que va a leer es una matriz de tamaño fijo, Get lee solamente los datos. No lee
ningún descriptor.
❏ Si la variable que va a leer es cualquier otro tipo de variable (no una cadena de longitud
variable ni una Variant), Get lee solamente los datos variables. La longitud del registro
especificada por la cláusula Len en la instrucción Open debe ser mayor o igual que la longitud
de los datos que está leyendo.

❏ Get lee elementos de tipos definidos por el usuario como si cada uno de ellos se leyera
individualmente, excepto en que no hay relleno entre los elementos. En disco, una matriz
dinámica de un tipo definido por el usuario (escrito con Put) tiene como prefijo un descriptor
cuya longitud es igual a 2 más 8 veces el número de dimensiones, es decir, 2 + 8 *
NúmeroDeDimensiones.
❏ La longitud del registro especificada por la cláusula Len en la instrucción Open debe ser mayor
o igual que la suma de todos los bytes necesarios para leer cada uno de los elementos,
incluyendo las matrices y sus descriptores.
Ejemplo de la instrucción Get
En este ejemplo se utiliza la instrucción Get para leer datos de un archivo de disco y ponerlos en
una variable. Se supone que PRUEBA es un archivo que contiene cinco registros del tipo definido
por el usuario Record.

ID As Integer
End Type

' Se abre un archivo de muestra para acceso aleatorio.
Open "PRUEBA" For Random As #1 Len = Longitud(MiRegistro)
' Se lee el archivo de muestra por medio de la instrucción Get.
Posicion = 3 ' Define el número del registro.
Get #1, Posicion, MiRegistro ' Lee el tercer registro.
10. Seek (Función)

Devuelve la posición actual de lectura/escritura de un archivo abierto con la instrucción Open.
Sintaxis: Seek(númeroArchivo)
El argumento con nombre númeroArchivo es cualquier número de archivo válido.

Observaciones
En archivos abiertos en modo Random, Seek devuelve el número del siguiente registro a leer o
escribir. Para archivos abiertos en modo Binary, Output, Append o Input, Seek devuelve la
posición de byte en la que se va a ejecutar la siguiente operación.
Ejemplo de la función Seek
En este ejemplo se utiliza la función Seek para obtener la posición de archivo actual. El ejemplo
supone que PRUEBA es un archivo que contiene registros del tipo definido por el usuario
Registro.

ID As Integer
End Type
Para los archivos abiertos en modo de aleatorio, Seek devuelve el número del siguiente registro.
Dim MiRegistro As Record ' Declara la variable.

Do While Not EOF(1) ' Repite hasta el final del archivo.
Get #1, , MiRegistro ' Lee el registro siguiente.
Debug.Print Seek(1) ' Imprime el número de registro en la
Ventana Depuración.
Loop

En archivos abiertos en modos distintos del modo aleatorio, Seek devuelve la posición del byte en
la que se ejecuta la siguiente operación. Se presupone que PRUEBA es un archivo que contiene
unas pocas líneas de texto.
Open "PRUEBA" For Input As #1 ' Abre el archivo para lectura.

Do While Not EOF(1) ' Repite hasta el final del archivo.
MiCaracter = Input(1, #1) ' Lee el siguiente carácter de datos.
Debug.Print Seek(1) ' Imprime la posición de byte en la
Ventana Depuración.
Loop
11. Seek (Instrucción)

Establece la posición de la próxima operación de lectura o escritura en un archivo abierto con la
instrucción Open.
Sintaxis: Seek [#]númeroarchivo, posición
La sintaxis de la instrucción Seek tiene estas partes:
Parte Descripción
posición Un número en el intervalo 1 a 2,147,483,647 inclusive, que indica la posición en la
que se debe ejecutar la próxima operación de lectura o escritura.
Observaciones
Si se ejecuta una operación de escritura de archivo después de una instrucción Seek más allá del
fin de un archivo, se extiende el archivo. Si se intenta ejecutar una instrucción Seek en una
posición negativa o cero, se produce un error.
Ejemplo de la instrucción Seek
En este ejemplo se utiliza la instrucción Seek para establecer la posición de la próxima operación
de lectura o escritura a ejecutar en un archivo. Este ejemplo supone que PRUEBA es un archivo
que contiene registros del tipo definido por el usuario Registro.

ID As Integer
End Type
En archivos abiertos en modo aleatorio, Seek devuelve el número del registro siguiente.
Dim MiRegistro As Record ' Declara una variable.
' Se abre un archivo en modo aleatorio.
MaxTam = LOF(1) \ Len(MiRegistro) ' Obtiene el número de registros del
archivo.
' Se leen todos los registros empezando con el último.
For NumeroRegistro = MaxTam To 1 Step - 1
Seek #1, NumeroRegistro ' Establece la posición.
Get #1, , MiRegistro ' Lee el registro.
Next NumeroRegistro
En archivos abiertos en modos distintos del aleatorio, Seek devuelve la posición de byte en la que
se ejecuta la siguiente operación. Se supone que PRUEBA es un archivo que contiene unas pocas
líneas de texto.

Open "PRUEBA" For Input As #1 ' Abre el archivo para entrada.
MaxTam = LOF(1) ' Obtiene el tamaño del archivo en bytes.
' Se leen todos los caracteres empezando con el último.
For SigCar = MaxTam To 1 Step -1
Seek #1, SigCar ' Establece la posición.
MiCaracter = Input(1, #1) ' Lee el carácter.
Next SigCar
12. LOF (Función)

Devuelve el tamaño, en bytes, de un archivo abierto con la instrucción Open.
Sintaxis: LOF(númeroarchivo)
El argumento con nombre númeroarchivo es cualquier número de archivo válido.
Observaciones
Para obtener la longitud de un archivo que no está abierto utilice la función FileLen.
13. FileLen (Función)

Devuelve la longitud de un archivo en bytes.
Sintaxis: FileLen(nombreRuta)
El argumento con nombre nombreRuta es una expresión de cadena que especifica un nombre de
archivo se puede incluir el directorio o carpeta y la unidad de disco.
Comentarios
Si el archivo especificado está abierto cuando se llama la función FileLen, el valor devuelto
representa el último tamaño de ese archivo cuando se guardó la ultima vez en el disco.
Para obtener la longitud de un archivo abierto, utilice la función LOF.
14. EOF (Función)

Devuelve un valor que indica si se ha llegado al final de un archivo.
Sintaxis: EOF(númeroArchivo)
Observaciones
Se utiliza EOF para evitar producir un error al intentar obtener información más allá del fin de un
archivo.La función EOF devuelve False a menos que se haya llegado al fin del archivo; en cuyo
caso devuelve True.
Acceso a una Base de Datos
El Control Datos
Utilizando un control Data, podremos comunicarnos con una base de datos para editar, visualizar y
actualizar uno o más registros. Visual Basic permite comunicarse con bases de datos creadas con
Microsoft Access, Microsoft Fox Pro, Borland Paradox, Borland dBase.
Los métodos que se pueden utilizar con un control de datos son: MoveFirst, para posicionarse en
el primer registro. MovePrevious, para posicionarse en el registro anterior. MoveLast, para
posicionarse en el último registro. MoveNext, para posicionarse en el registro siguiente. Refresh,
la base de datos se abre para ser utilizada o, se cierra y se vuelve a abrir si ya estaba abierta.
AddNew, añadir un nuevo registro. Update, se escriben todos los campos editados en la base de
datos. Delete, elimina el registro actual.

Las propiedades importantes de este control son: Connect (conexión). Esta propiedad especifica el
formato de la base de datos. Los valores que se pueden utilizar son: cadena vacía para formato
Access, "foxpro 2.5;", "paradox;", y "dbase iv;". DatabaseName (nombre de la base de datos)
Sirve para identificar al archivo de base de datos. RecordSource (fuente del registro). Indica de
dónde se obtienen los datos. Exclusive (exclusiva). Determina el tipo de acceso, monousuario
(True) o multiusuario (False). ReadOnly (solo lectura). Determina el modo de acceso.
Cada vez que se cambie el valor de una propiedad, debe ejecutarse el método Refresh. Otras
propiedades que se podrán consultar son: BOF (comienzo del archivo) esta propiedad es True si el
registro actual es el primero. EOF (final del archivo) que estará a True cuando el registro actual
sea el último.
Un objeto Dynaset es un conjunto dinámico de registros. Cada conjunto de registros tiene asignado
una colección Fields por defecto (conjunto de objetos Field, cada uno de los cuales define un
campo de la base de datos). La propiedad por defecto para un objeto Field, es Value, que contiene
el valor del campo que representa para el registro actual. Para acceder a un miembro individual de
una colección, puede hacerlo a través de un índice o utilizando el nombre del campo. P.e. la
sentencia Print Data1.RecordSet(0) es equivalente, suponiendo que el campo 0 es Título, a las
sentencias:
Print Data1.RecordSet.Fields(0)
Print Data1.RecordSet.Fields(">
¡Transferencia interrumpida!
Data1.RecordSet.Fields("Título").Value
También tiene asociada una propiedad Count que dice cuántos objetos están contenidos en el
objeto Dynaset.
Para poder realizar modificaciones en una base de datos, ésta tiene que ser actualizable, es decir, la
propiedad ReadOnly tiene que estar establecida a False y la propiedad Updatable a True.
La propiedad Attributes indica los atributos de un campo. Para saber si un campo tiene un
determinado atributo, se hará un And con el valor del atributo a verificar. Las constantes DB_...
están definidas en el fichero ...\vb\dataconstant.txt
Algunos eventos que se producen en un control de datos son:
Reposition. Se produce después de que un determinado registro pase a ser el registro actual. Su
sintaxis es Sub Data1_Reposition()
Validate. Se produce justo antes de que un determinado registro pase a ser el registro actual.
Ocurre antes de una operación Update, Delete o Close. Su sintaxis es Sub Data1_Validate(Action
As Integer, Save As Integer). Para saber la causa que originó el suceso Validate, habrá que
examinar el parámetro Action. Este parámetro se corresponde con el tipo de operación que causó
este suceso. Los valores que puede tomar se pueden localizar en el fichero ...\vb\constant.txt y
empiezan por DATA_ACTION... El parámetro Save toma el valor True si cualquier control ligado
al control de datos cambia. Para saber qué control ha cambiado, habrá que evaluar la propiedad
DataChanged de cada uno de ellos. Durante este suceso, no se podrán utilizar los métodos Move....
En su lugar se utilizará el parámetro Action.
Utilidades Adicionales
Las utilidades adicionales que se pueden utilizar en aplicaciones complejas son:
Control de transacciones. Una transacción es una serie de cambios que se quieren hacer sobre
una base de datos con la posibilidad de deshacerlos. Las tres sentencias de Visual Basic para

realizar transacciones son: BeginTrans, CommitTrans y RollBack. La forma de utilizarlas lo
veremos en un ejemplo.
BeginTrans
Criterio = "Título Like ‘*1ª Edición*’"
Data1.Recorset.FindFirst Criterio
Do While Not Data1.Recordset.NoMatch
If Not Data1.Recordset.NoMatch Then
Data1.Recordset.Delete ‘Borrar registro
RegsBorrados = RegsBorrados + 1
End If
Data1.Recorset.FindNext Criterio
Loop
If RegsBorrados = 0 Then
RollBack
Exit Sub
End If
Msg = "¿Está seguro que desea borrar " & RegsBorrados & "
registros?"
If MsgBox(Msg, 17, "¿Borrar registros?") <>1 Then
RollBack ‘Deshacer los cambios
Else
CommitTrans ‘Borrar Registros
End If
Métodos UpdateRecord, que guarda valores contenidos en los controles ligados correspondientes
al registro actual. Su ejecución no provoca el suceso Update. Y UpdateControls, que actualiza los
controles ligados con los valores del registro actual. Ambos métodos ejecutan sus acciones sin
cambiar de registro actual.
Suceso Error, que se produce si ocurre un error en tiempo de ejecución. Útil para controlar los
errores. Su sintaxis es: Sub Data1_Error(DataErr As Integer, Response As Integer), donde
DataErr es el nº de error y Response es la respuesta que se desea tomar: 0 continuar, 1 visualizar
mensaje (valor por defecto)

Bibliotecas Dinámicas. Comunicaciones DDE. Comunicación entre
Aplicaciones OLE2
Enlaces Dinámicos y Comunicaciones DDE

DDE es un mecanismo soportado por Windows que permite a dos aplicaciones mantener una
conversación durante la cual, la información es intercambiada automáticamente. DDE automatiza
el cortar y pegar información entre aplicaciones Windows. La forma en la que trabaja DDE
consiste en que una aplicación Windows llamada destino (cliente en versiones anteriores), que es
la aplicación que inicia la conversación DDE, le dice a otra aplicación Windows, llamada fuente
(servidor en versiones anteriores), que quiere información, es decir, que quiere establecer una
conversación DDE o un enlace DDE. Una aplicación puede mantener varias conversaciones DDE
al mismo tiempo. En Visual Basic los formularios pueden ser fuentes DDE o destinos DDE
cambiando su propiedad LinkMode a vbLinkNone o vbLinkSource. Las cajas de texto, las de
figuras (picture box) y las etiquetas, pueden ser destinos DDE. Normalmente, la información fluye
de la fuente al destino. Es necesario conocer el nombre de la aplicación origen a la que se va a
llamar. A continuación, se necesita conocer el tema de la conversación DDE, que suele ser una
unidad de información que reconoce la fuente. Con la aplicación y el tema, se identifica una
conversación. Y, por último, queda establecer el elemento de conversación DDE o pieza de
información que se va a pasar en la conversación, significativa para ambas aplicaciones.
Cada aplicación que puede actuar de fuente DDE tiene un nombre único. Normalmente es el
nombre del fichero ejecutable sin la extensión. Antes de poder establecer una conversación DDE,
es necesario que las dos aplicaciones se estén ejecutando.
Se pueden tener tres clases de conversaciones DDE. Enlace Automático (vbLinkAutomatic)

significa que la fuente envía la información al destino, siempre que cambie el dato en la aplicación
fuente. Este tipo de enlace transcurre en tiempo real. Enlace Manual (vbLinkManual) significa
que la fuente envía información cuando el destino la solicita, cuando hay demanda. Enlace de
Notificación (vbLinkNotify) es aquel en el que la fuente le dice al destino que el dato ha
cambiado, pero no se envía hasta que el destino lo solicite.
Cada vez que la fuente DDE actualiza la información de un control de Visual Basic que actúa
como destino DDE, se genera el evento Change.
Las propiedades importantes en una conversación DDE son:
LinkTopic (tema del enlace)
El valor de esta propiedad tiene siempre el formato: Aplicación|Tema, donde Aplicación es el

nombre de la aplicación fuente y Tema es la información empleada en la conversación.
Normalmente, es el nombre de un archivo, incluyendo su ruta.
LinkItem (elemento del enlace)
El valor de esta propiedad identifica el dato que realmente se va a pasar desde la fuente al destino,
un registro, una hoja de cálculo, una celda, un marcador en Word, etc.
LinkMode (modo del enlace)
Modo de establecer la conversación DDE. Puede ser vbLinkNone, vbLinkAutomatic,

vbLinkManual y vbLinkNotify.
LinkTimeout (tiempo sin enlazar)

Indica cuánto tiempo tiene que tratar Visual Basic de establecer el enlace o lo que es lo mismo, el
tiempo que debe esperar respuesta a una conversación. El valor por omisión es 50 décimas de
segundos (5 seg.). Si no se puede establecer la conversación, se produce un error.
Crear Enlaces DDE Durante el Diseño (Utilización del Portapapeles)

Los enlaces creados en tiempo de diseño, son enlaces automáticos, ya que son restablecidos al
ejecutar la aplicación. Para explicar este apartado, utilizaremos Excel. Crearemos un formulario
con una etiqueta y una caja de texto. A continuación, se arrancará Excel y, estableceremos un
enlace automático con Excel como fuente DDE, siendo el contenido de la celda A1 el tema de
conversación DDE. Los pasos a seguir son:
1. Acceder a la ventana de Excel y copiar el contenido de la celda A1.

2. Ir a la ventana de Visual Basic y seleccionar la caja de texto.
3. Elegir el menú Edit/Paste link (pegar enlace).
Si ahora se accede a la ventana de Excel y, se introduce un valor en la celda A1, el valor aparecerá
en la caja de texto de Visual Basic.
Los Sucesos DDE

Los sucesos de enlace que se pueden generar son: LinkOpen (abrir enlace) se genera cuando se
crea un enlace DDE. LinkClose (cerrar enlace) se genera cuando se termina un enlace DDE.
LinkError (error en el enlace) se genera cuando sucede un error en una conversación DDE y no se
está ejecutando código Visual Basic. LinkNotify (notificación de enlace) se genera cuando la
propiedad LinkMode está establecida a 3 - Notify y se actualiza la información en la fuente.
LinkExecute (ejecutar) ocurre en la aplicación fuente cuando el destino de la conversación envía
un comando para se ejecutado por la fuente DDE.
Los Métodos DDE

Los métodos de enlace que se pueden utilizar con los controles Visual Basic que estén actuando
como destinos en un enlace DDE, son:
LinkPoke (introducir)
Es la única forma que tiene un destino DDE de enviar datos a la fuente. Se puede usar para
transferir el contenido de un control destino DDE a la fuente. La sintaxis es:
NombreControl.LinkPoke
LinkRequest (petición)
Se emplea para pedir a la fuente DDE que envíe la información al control, que la actualice. Solo es
necesario si se ha puesto la propiedad LinkMode a 2. Su sintaxis es:
NombreControl.LinkRequest
LinkSend (enviar)
Se emplea cuando se tiene un formulario como fuente DDE y se quiere enviar el contenido de una
caja de figuras a la aplicación destino. La sintaxis es:
NombreCajaFiguras.LinkSend
Incrustación y Comunicación entre Aplicaciones. OLE2

OLE es una técnica de comunicación entre aplicaciones Windows que hace posible la creación de
documentos (destino) compuestos con datos procedentes de una variedad de fuentes. Por tanto,
permite la cooperación entre aplicaciones Windows, p.e. usar el corrector de Word desde Visual
Basic. La tecnología OLE presenta en forma de objetos varias prestaciones clave del sistema
operativo, como la gestión de ficheros, asignación de memoria y la transferencia de datos. Para
acceder a estas prestaciones, el usuario debe conocer totalmente las interfaces (conjunto de
funciones relacionadas semánticamente con un objeto, accesibles públicamente para el usuario)
que soporta cada objeto.
Terminología OLE
Objeto OLE: Es cualquier dato con el que un control OLE pueda trabajar.
Unidad de datos suministrada por una aplicación Windows que soporta OLE.
Puede ser texto, hojas de cálculo, celdas de una hoja de cálculo, gráficos,... Un control OLE puede
contener solo un objeto cada vez.
Clase OLE: Es la aplicación que produce el objeto OLE. Toda aplicación que soporta OLE, tiene
un único nombre de clase OLE.
Aplicación Cliente o Aplicación Contenedora: Contiene el objeto creado por otra aplicación (el
objeto OLE).
Servidor OLE: Es la aplicación original que ha permitido crear el objeto OLE. A veces se llama
Aplicación Fuente.
ObjetoVinculado: Los datos de un objeto pueden ser vinculados a una aplicación, es decir, pueden
ser añadidos de forma que cuando se modifique el objeto original, se actualizará en todas las
aplicaciones en las que haya sido vinculado ya que sólo existe la copia original de los datos. A este
tipo de objeto también se le suele llamar Enlazado. Un enlace ocupa menos espacio, pero tiene la
desventaja de la potencial pérdida del enlace. Por tanto, solo se mantiene una referencia al objeto.
Objeto Incrustado: Los datos de un objeto pueden incrustarse en una aplicación, de forma que si
cambian en la fuente, el destino no sufrirá ningún cambio. En este caso, cada aplicación tiene una
copia de los datos, independiente del original.
Algunas propiedades del control OLE son: DisplayType (tipo de presentación) permite mostrar la
infomación como un icono. SizeMode (modo de tamaño) permite cambiar la forma en que
aparecerán los datos durante la ejecución. Si su valor es 0 (vbOLESizeClip), se recortarán los
datos. Si se quieren estirar los datos para que ocupen el tamaño actual del control OLE, el valor
será 1 (vbOLESizeStretch). Si se quiere que el control modifique automáticamente de tamaño, el
valor será 2 (vbOLESizeAutoSize). El valor 3 (vbOLESizeZoom) permite que el objeto cambie de
tamaño para rellenar el control contenedor OLE tanto como fuera posible manteniendo las
proporciones. Class, especifica la aplicación que contiene los datos, para un objeto incrustado.
OleType devuelve el estado del objeto (vinculado o incrustado). SourceDoc (documento fuente)
proporciona el nombre del objeto enlazado o el archivo a emplear para los objetos incrustados.
SourceItem (elemento fuente) se emplea en los objetos enlazados para especificar qué parte del
documento enlazado puede trabajar con la aplicación en Visual Basic. Action (acción) especifica
qué se quiere hacer exactamente con el objeto OLE. El control OLE opera de manera similar al
control CommonDialog, en tanto a que la asignación de ciertos valores a esta propiedad produce
que se ejecuten las operaciones asociadas. Se recomienda utilizar los métodos equivalentes, p.e.
CreateLink, CreateEmbed, etc.
Ejemplo (Crear un objeto durante el diseño)

Nota: Cuando se añade a un formulario un control OLE, aparecerá el cuadro de diálogo Insertar
Objeto. Este cuadro proporciona los nombres de todas las aplicaciones Windows a las que se

puede conectar. Si se desea establecer las propiedades durante la ejecución, se deberá pulsar el
botón de Cancel.
Crearemos un nuevo proyecto al que se añadirá un control OLE al formulario. En caja de diálogo
Insertar Objeto, seleccionaremos como tipo de datos a incluir, "Hoja de cálculo de Microsoft
Excel". A continuación, si se ejecutara la aplicación y se hiciera doble clic sobre el objeto OLE,
Excel se arrancaría para poder realizar las modificaciones pertinentes.
Para que al hacer doble clic sobre un objeto contenedor OLE, aparezca el menú de la aplicación
Visual Basic, es necesario definirlo en tiempo de diseño y establecer el valor de la propiedad
NegotiatePosition del menú, a la opción adecuada.
Ejemplo (Crear un objeto durante la ejecución)

Se necesita escribir el código utilizando las propiedades del control OLE. Si se quiere crear un
objeto enlazado, se deberá establecer la propiedad SourceDoc con el nombre del archivo y la
propiedad Action con CreateLink. Si se quiere crear un objeto incrustado, se deberá establecer la
propiedad Class para determinar el objeto a emplear, la propiedad SourceDoc con el nombre del
archivo y la propiedad Action con CreateEmbed.
¿Qué es un control ActiveX?

Un control ActiveX es una extensión del cuadro de herramientas de Visual Basic. Los controles
ActiveX se usan como cualquiera de los controles estándar incorporados, como el control
CheckBox. Cuando se agrega un control ActiveX a un programa, pasa a formar parte del entorno
de desarrollo y de tiempo de ejecución y proporciona nueva funcionalidad a la aplicación.
Los controles ActiveX incrementan la capacidad del programador de Visual Basic conservando
algunos métodos, propiedades y eventos ya familiares, como la propiedad Name, que se
comportan como cabría esperar. Pero, además, los controles ActiveX incorporan métodos y
propiedades que aumentan enormemente la flexibilidad y capacidad del programador de Visual
Basic.
Por ejemplo, las ediciones profesional y empresarial de Visual Basic incluyen los controles
comunes de Windows®, que permiten crear aplicaciones totalmente compatibles con las barras de
herramientas, barras de estado y modos de ver de estructuras de directorios de Windows 95. Otros
controles permiten crear aplicaciones que aprovechan al máximo Internet.
Durante la instalación, las ediciones profesional y empresarial instalan y registran
automáticamente los controles ActiveX en el directorio \Windows\System o System32. Desde ese
momento ya se pueden usar los controles ActiveX en tiempo de diseño para desarrollar
aplicaciones.
Los controles ActiveX tienen la extensión de archivo .ocx. Pueden usarse los controles ActiveX
suministrados con Visual Basic 5.0 o bien se pueden conseguir controles adicionales desarrollados
por otros programadores.
Se pueden utilizar controles ActiveX y otros objetos insertables en el proyecto si se los agrega al
cuadro de herramientas.

Aplicaciones de control automático basadas en Visual Basic
Introducción
Estamos ahora en condiciones de desarrollar un ejemplo en el cual aplicaremos los conocimientos
que hemos adquirido hasta el momento e incorporaremos algunos nuevos que necesitamos para
poder completarlo.
Este ejemplo pretende ser la base para el trabajo final que se desarrollará en la cátedra.
Nuestra primer aplicación orientada al control

Comenzaremos nuestra incursión de aplicación de los lenguajes de programación visual
desarrollando en forma ordenada “Un sistema de adquisición de datos y control basado en
placas y módulos de adquisición” Control de temperatura.
Las características que deseamos para nuestro sistema son:
Configuración de los parámetros de la placa de adq

Configuración de los parámetros generales del sistema
Presentación en pantalla de las variables de entrada y salida en forma numérica
Presentación en pantalla de las variables de entrada y salida en forma gráfica en tiempo real:
a) Por medio de controles
b) Por medio de gráfico cartesiano
Control del tipo ON-OFF y PID
Alarma configurable de máxima y mínima temperatura
Archivos de datos
a) Archivo de datos que permita guardar la configuración del sistema.
b) Archivo de datos que permita registrar la variación de variables de entrada y salida.
c) Reemplazo de los puntos a y b por una base de datos en Access.
Desarrollo de la aplicación
Comenzaremos creando un nuevo proyecto, el que constará en esta primera etapa de un formulario
y de un módulo.
Lo primero que haremos en nuestro proyecto es presentar en pantalla el valor de una entrada
analógica de una placa de adquisición, el algoritmo de lectura de un valor analógico es
básicamente el siguiente:
1. Setear el nro de canal en el registro de control del ADC.

2. Poner RUN en “1”.
3. Permanecer en un loop mientras STATUS sea igual a “1”.
4. Permanecer en un loop mientras STATUS sea igual a “0”.
5. Poner RUN en “0”.
6. Leer byte menos significativo del conversor.
7. Leer byte más significativo y hacer una máscara con Fh.
8. Multiplicar este valor por 256 y sumarle el byte menos significativo.
9. Convertir el valor anterior en un valor de tensión.
Lo anterior traducido a un lenguaje de programación Basic quedaría de la siguiente forma:
Primeramente debemos determinar cuales son las variables a utilizar:
REM Declaración de las variables a utilizar

Public pDireccionBase As Integer, pDireccionRegistroControl As Integer, pDireccionRegistroStatus As Integer,
pDireccionByteAlto As Integer, pDireccionByteBajo As Integer
Public bStatus As Byte, bByteBajo As Byte, bByteAlto As Byte, iValorLeido As Integer, fValordeTension As Single,
iGanancia As Integer

Luego, asignamos los valores a los parámetros
REM Inicialización de las direcciones de los registros

pDireccionBase = &H300
pDireccionRegistroControl = pDireccionBase + &HB
pDireccionRegistroStatus = pDireccionBase + &HC
pDireccionByteAlto = pDireccionBase + &H9
pDireccionByteBajo = pDireccionBase + &HA
Por último, escribimos el código que nos permitirá realizar la adquisición de un valor a través de
los registros de las placa de adquisición
Out pDireccionRegistroControl, 1
Do
bStatus = Inp(pDireccionRegistroStatus)
Loop Until bStatus = 1
Do
bByteBajo = Inp(pDireccionByteBajo)
bByteAlto = Inp(pDireccionByteAlto)
bByteAlto = bByteAlto And &HF
iValorLeido = bByteAlto * 256 + bByteBajo
fValorDeTension= iValorLeido * iGanancia/4095
Ahora tenemos el código de nuestro algoritmo en basic, y veremos a continuación como ese código
lo incorporamos a nuestro proyecto en Visual Basic.
Como se señaló anteriormente, el desarrollo de aplicaciones en VB consta siempre de los

siguientes pasos:
1. Crear la interfase
1. Crear la Interfaz
El primer paso para generar una aplicación de Visual Basic consiste en crear los formularios que
van a ser la base de la interfase de su aplicación. Usaremos formularios para agregar ventanas y
cuadros de diálogo a la aplicación.
Nuestra interfase tendrá:
1. Una ventana principal.
2. Un elemento que nos permita presentar el resultado en la pantalla.
3. Un lugar, dentro de nuestro proyecto, en donde “pegar” el código anterior.
4. Un par de funciones que el Vbasic desgraciadamente no trae...
Ahora está en condiciones de dibujar los objetos que van a componer la interfase en el formulario
que ha creado. Para esta primera aplicación, usará tres controles del cuadro de herramientas.
Botón Control Nombre por

defecto
Etiqueta (Label) Label1
Empezaremos por incorporar una etiqueta (Label) y dos botones (CommandButton) al formulario.

Una vez definida la ubicación de los controles que componen la aplicación (que por supuesto
pueden posteriormente cambiarse de tamaño y posición), es el momento de configurar sus
propiedades.
Dicha configuración se realiza en la ventana de propiedades, a la cual se puede llegar rápidamente
presionando F4. Esta ventana muestra por defecto las propiedades del control activo (aquél que
tiene los indicadores cuadrados de movimiento y cambio de tamaño), sin embargo también posee
una caja de opciones que permite seleccionar el objeto cuyas propiedades se desean modificar.
En la figura se observa que el objeto seleccionado posee el nombre “Command1” y pertenece a la

categoría “CommandButton”. La propiedad que aparece resaltada, denominada Caption es la que
indica el texto que aparece en la superficie del botón.
Si se cambia este texto puede observarse que la modificación es inmediatamente aceptada por el
control. La mayoría de los controles que muestran un texto poseen una propiedad denominada
Caption en la que se asigna dicho texto. La excepción más notable a esta regla es la del control
caja de texto, cuya propiedad principal se denomina Text.
En la figura de la ventana de propiedades se observa la propiedad Name; esta propiedad debe

determinar quién es quién.
Por lo tanto, cada vez que agregue un objeto a su aplicación, modifique su nombre en base a algún
criterio claro y fácil de entender.
Siguiendo el criterio de la sugerencia, los nombres de los controles incorporados en la aplicación

quedan como se indica en la tabla a continuación:
Nombre anterior Nombre actual

Form1 frmAdquisicion
Label1 lblTension
Command1 cmdAquirir
Command2 cmdSalir
De este modo, con sólo mirar un control sobre el formulario, se está en condiciones de deducir
su nombre.
Si en este momento ejecutamos la aplicación, presionando el botón o F5 el programa comienza a
correr. Vemos que sin haber introducido ni una sola línea de código, tenemos una aplicación
ejecutándose, con una ventana que podemos minimizar o cambiar de tamaño, con cajas de texto
que son sensibles al teclado y a Ctrl+Ins o Shift+Ins y con botones que, aún cuando no hacen
nada, tienen la inteligencia suficiente para responder al click del mouse hundiéndose y elevándose.
Para detener la aplicación presione la cruz de cerrar ventana o terminar en la barra de
herramientas.
Bien, justamente lo que deseamos es que esos botones sí estén en condiciones de responder al click
del mouse ejecutando la tarea que corresponda. Para que esto suceda debemos elegir entre los
eventos que ofrece el objeto botón aquél que mejor se adapta a la tarea que debe ejecutarse, e
incorporar dentro de ese evento nuestras instrucciones en código Basic. Ha llegado el momento de
escribir algunas líneas de programa.
La ventana de código es donde usted escribe el código Basic para su aplicación. Para abrir la
ventana de código, haga doble-click sobre el botón de la aplicación que indica “Adquirir”, o en la

ventana de proyecto presione el botón Ver código.
La ventana de código incluye los siguientes elementos:

❏ Caja de objetos: Muestra el nombre del objeto seleccionado. Haciendo click en la flecha a la
derecha de la caja se descuelga la lista de todos los objetos asociados al formulario.
❏ Caja de procedimientos: Lista todos los procedimientos de eventos disponibles para el objeto
seleccionado. En la figura el evento seleccionado es el evento Click. Todos los controles
brindan una gran cantidad de eventos de los cuales normalmente se utilizan pocos. En nuestro
caso, necesitamos que los botones sean sensibles al “Click” del usuario.
Como ya se aclaró con anterioridad, el código de una aplicación VB se divide en pequeños bloques
denominados procedimientos. Un procedimiento de evento, o sencillamente evento, como el que
está creando en este momento, contiene código que se ejecuta cuando un determinado evento o
suceso ocurre (tal como el click del usuario sobre el botón).
El evento Click del botón cmdAdquirir está limitado por dos instrucciones que identifican el
comienzo y el final del procedimiento:
Private Sub cmdAdquirir_Click()
End Sub
El nombre del evento está compuesto por el nombre del objeto al que éste pertenece, un separador
“_” (underscore) y el nombre del evento genérico.
Entre estas dos instrucciones se debe insertar el bloque de código con que se desea que el evento
responda.
En este caso deberíamos insertar el código del programa que hemos realizado, pero como estamos
trabajando con un bloque de código extenso, utilizaremos una forma más ordenada y crearemos
dentro del formulario frmAdquisicion un procedimiento llamado Adquirir, donde agregaremos el
código.
El evento Click del control cmdAdquirir, llama al procedimiento adquirir de la siguiente manera:
Private Sub cmdAdquirir_Click()
Adquirir
End Sub
Mientras que el procedimiento Adquirir queda en la forma:

Public Sub Adquirir()
Do
Do
bByteBajo = Inp(pDireccionByteBajo)
bByteAlto = Inp(pDireccionByteAlto)
bByteAlto = bByteAlto And &HF
fValorLeido = bByteAlto * 256 + bByteBajo
fValorDeTension = fValorLeido * iGanancia / 4095
lblTension.Caption=fValordeTension
End Sub
Como se verá, al listado de código original, se le agregó al finalizar una nueva línea:
lblTension.Caption= fValordeTension
Esta nueva línea es la que nos permite ver el valor de la variable fValordeTension en la etiqueta
(label) lblTension.
También agregaremos el código al evento click del botón cmdSalir.

Private Sub cmdSalir_Click()

End
End Sub
Si en este momento ejecutamos la aplicación, presionando el botón o F5, nos encontraremos con
un pequeño problema. En Visual Basic, las funciones Out e Inp, que son las que nos permiten leer
y escribir valores en los puertos de I/O de una PC no están implementadas, por lo que deberemos
incorporárcelas.
Por suerte para nosotros no tendremos que escribir estas funciones, pues alguien ya se ha
encargado de ello, solamente tendremos que incorporarlas a nuestro proyecto.
Estas funciones están disponibles en forma de una Librería Dinámica (DLL “Dynamic Link
Library”). Qué es una librería dinámica? Una DLL es un fichero ejecutable de funciones, o
simplemente recursos, tales como bitmap o recursos de fuentes, que puede ser llamada por
cualquier aplicación Windows. La utilización de DLL trae algunas ventajas, como ser la reducción
del código de la aplicación, su actualización independiente de la aplicación, y por sobre todo, la
posibilidad de poder incorporar en nuestra aplicación funciones que nos demandarían una
enormidad de tiempo implementarlas y que ya alguien se encargo de hacerlas. Como
inconveniente, podemos destacar la necesidad de que deben estar presentes en tiempo de
ejecución.
Para incorporar una DLL a nuestra aplicación, lo que debemos hacer es declararla. Esta
declaración la debemos hacer a nivel de módulo, es decir que primeramente agregaremos un nuevo
módulo a nuestra aplicación, el cual llamaremos modPrinc.Bas y incluiremos el siguiente
segmento de código dentro de la sección declaraciones de dicho módulo. Este módulo también nos
servirá para incluir varios procedimientos que crearemos a lo largo de este trabajo.
Declare Function Inp Lib "InpOut.DLL" (ByVal Port%) As Integer

Declare Sub Out Lib "InpOut.DLL" (ByVal Port%, ByVal Value%)
Nuestra aplicación nos presenta en la pantalla un solo valor de tensión, lo cual no es muy
representativo, por lo que la modificaremos para que nos indique el valor medido en forma
continua.
Para ello, le agregaremos un bucle, de manera de realizar la lectura en forma continua:
Public Sub Adquirir()
Do
............................................................
lblTension.Caption=fValordeTension
DoEvents
Loop
End Sub
El problema, es que al agregar este bucle, se realizará continuamente la tarea de leer la placa de
adquisición, no pudiendo realizarse, mientras tanto, ninguna otra tarea.
Es por esta razón, que dentro del bucle hemos agregado la función DoEvents, que cede el control
de la ejecución al sistema operativo, para que éste pueda procesar otros eventos.
Si todo funciona correctamente, en este momento deberíamos “ver” la temperatura ambiente en la

pantalla de nuestra computadora, representada digitalmente.
Pero, no es más atractivo ver el valor que estamos adquiriendo por medio de un instrumento
virtual? Seguramente que si, por lo tanto, agregemos a nuestra aplicación dicho instrumento...
Agregaremos a continuación un instrumento virtual de aguja.

Primero, incertemos en nuestro formulario un control llamado Gauge, al que le daremos las
siguientes propiedades básicas, queda para ustedes investigar que otras propiedades se pueden
modificar en el control para lograr una mejor presentación.

Control Propiedad Valor
Gauge Name gauTension
Style ‘Semi’ Needle
Luego, agregemos el siguiente código, entre las dos lineas

siguientes:
ValorDeTension= ValorLeido * Ganancia/4095
lblTension.Caption= ValorDeTension
gauTension.Value= ValorDeTension Figura 30- Ejemplo de un Control Gauge
DoEvents
y listo...
Configuración de la placa de adquisición

Hemos partido suponiendo que nuestra placa de adquisición se encuentra configurada en la
dirección base 300h.
Pero, que sucedería si de antemano no conocemos la dirección en la que se encuentra instalada?
Tenemos dos caminos, o cambiamos la dirección base de la placa modificando el código fuente, lo
que resulta poco práctico, o parametrizamos la configuración de la placa, de manera de poder
seleccionar la dirección correcta.
Para implementar esta nueva característica en nuestro sistema, utilizaremos Botones de Opción,
en una estructura llamada matriz (array) de controles.
Incorporemos a nuestro formulario los siguientes controles:

Marco Caption Dirección Base Placa
Boton de Opción Name optDireccionBase
Private Sub optDireccionBase_Click(Index As Integer)

Select Case Index
Case 0
pDireccionBase= &H300
Case 1
pDireccionBase=&H310
Case 2
Case 3
Case 4
Case 5
Case else
End Select
End Sub
De esta forma, haciendo click sobre el botón de opción correspondiente a la dirección base en la
cual se encuentra instalada la placa, a la variable pDireccionBase se le asigna el valor de dicha
dirección.
Alarma configurable de máxima y mínima temperatura

Básicamente, los pasos a seguir para incorporar una alarma a nuestra aplicación son:
Configuración de los valores.

Indicación de que se ha salido fuera del intervalo.

Comparación de la temperatura actual con las temperaturas máxima y mínima.
Tenemos varias formas de incorporar a nuestra aplicación una alarma configurable. Podríamos
ingresar los valores utilizando cuadros de texto, podríamos utilizar botones de opción , lo cual no
sería muy cómodo por la cantidad de botones a crear, y también podíamos utilizar un
“SpinButton”, que es lo que utilizaremos.
Agregemos a nuestro formulario los siguientes controles:

Marco Caption Configuración Alarma
SpinButton Name spbAlarmaMx
SpinButton Name spbAlarmaMin
Text Box Name txtAlarmaMx
Text Box Name txtAlarmaMin
CommadButton Name cmdAplicar
Caption Aplicar
Label Caption T. Máxima
Label Caption T. Mínima
En los eventos SpinDown y SpinUp de los SpinButton debemos escribirle el código que permita
aumentar y disminuir los valores máximos y mínimos de la alarma:
Private Sub spbAlarmaMx_SpinDown ()

txtAlarmaMx.Text = Str$(Val(txtAlarmaMx.Text) -1)
If Val(txtAlarmaMx.Text) < 1 Then txtAlarmaMx.Text = "1"
End Sub
Private Sub spbAlarmaMx_SpinUp ()

txtAlarmaMx.Text = Str$(Val(txtAlarmaMx.Text) +1)
If Val(txtAlarmaMx.Text) > 200 Then txtAlarmaMx.Text = "200"
End Sub
Private Sub spbAlarmaMin_SpinDown ()

txtAlarmaMin.Text = Str$(Val (txtAlarmaMin.Text) - 1)
If Val(txtAlarmaMin.Text) < 1 Then txtAlarmaMin.Text = "1"
End Sub
Private Sub spbAlarmaMin_SpinUp ()

txtAlarmaMin.Text = Str$(Val(txtAlarmaMin.Text) + 1)
If Val(txtAlarmaMin.Text) > 200 Then txtAlarmaMin.Text = "200"
End Sub
Private Sub cmdAplicar _Click ()

iTempMx= Val(txtAlarmaMx.Text)
iTempMin= Val(txtAlarmaMin.Text)
End Sub
Vemos que estamos ante una situación en la cual se repite el código de los controles utilizados, por
lo que es un caso en el cual deberíamos incluir en nuestra aplicación “array de controles”.
Hasta ahora tenemos determinada la configuración de las alarmas de máxima y mínima

temperatura, pero que acción debemos tomar en caso de que la temperatura se escape del intervalo
prefijado?
Como lo planteamos al comienzo de este párrafo, realizaremos una indicación en pantalla
Utilizaremos una función que se llama caja de mensaje (MsgBox) , la cual muestra un mensaje en
un cuadro de diálogo, espera a que el usuario elija un botón y devuelve el valor correspondiente al
botón elegido por el usuario, como se trata de una función, no de un control, debemos únicamente
agregar el código correspondiente.

El formato de la función MsgBox es el siguiente:
MsgBox(mensaje[, botones][, título][, archivoAyuda, contexto])
(Para información sobre los parámetros de esta función leer el archivo de ayuda de VBasic).
Crearemos a continuación un procedimiento, llamado Alarma al cual le pasaremos como parámetro

la temperatura actual
Private Sub Alarma (bAltaBaja as Integer)

Dim iEstilo as Integer, iAlarma as Integer, sMensaje as String
If bAltaBaja = 1 Then
sMensaje=“Temperatura por encima del Límite”
If bAltaBaja = 0 Then
sMensaje=“Temperatura por debajo del Límite”
End If
iEstilo=VbOkOnly+VbCritical
iAlarma= MsgBox(sMensaje, estilo, “Alarma”)
End Sub
Al procedimiento Alarma, lo podemos llamar desde el procedimiento Adquirir agregando el

siguiente código:
If fTemActual >= iTempMax Then

Alarma 1
End If
If fTempActual <= iTempMin Then
Alarma 0
End If
También podemos llamar al procedimiento Alarma desde un control Timer incorporado al

formulario frmAdquirir. Este mismo Timer se podría utilizar para realizar el control On-Off que
veremos en el próximo apartado. Como se observará, no existe una única posible solución, lo que
debemos evaluar es cual es la solución más apropiada y más consistente a la hora de evaluar
posibles errores.
Control ON-OFF
Desarrollaremos un sencillo control ON-OFF para, por ejemplo, mantener la temperatura de un
líquido utilizando una resistencia.
Si bien nuestra aplicación original incorpora un control del tipo PID, la teoría de control en la cual
se trata este tema, se desarrollará el próximo año, por lo que no lo incorporaremos a nuestra
aplicación. Lo que si queremos rescatar, que su implementación es fácilmente realizable.

fSetPoin <- Para implementar este tipo de
fHisteresis <- Paramet.Dat
control, primero veamos cuales
son los parámetros que
debemos tener en cuenta:
fTempActual<-
Set Point (temperatura deseada)
Rango de Histéresis
Estas variables las llamaremos:

fSetPoint
fTempActual<
fHisteresis
fSetPoint
-fHisteresis ?
y se declaran de la forma
Encender acostumbrada.
Calentador
La manera en la cual se le
asignaran los valores a estas
variables es similar a la
fTempActual>= utilizada en el caso de las
fSetPoint
+fHisteresis ? alarmas de mx y min., por lo
tanto, el desarrollo de este
Apagar
Calentador punto queda para que ustedes
lo realicen.
Figura 31- Algoritmo del control On-Off

En el diagrama de flujo anterior, se representa el algoritmo del control a realizar.
Veamos la manera de codificar este algoritmo utilizando el Visual Basic.
IF fTempActual < (fSetPoint - fHistHistesis) Then

' Llamamos al procedimiento de encendido del calentador
EncenderCalentador
End IF
IF fTempActual >= (fSetPoint + fHistHistesis) Then
' Llamamos al procedimiento de apagado del calentador
ApagarCalentador
End IF
Ahora vemos los procedimientos ApagarCalentador y PrenderCalentador.

Desde el punto de vista de control, accionaremos una salida digital de la placa de Adq, lo cual
resulta muy sencillo, ya que solamente debemos poner en cero o uno el bit que corresponde a la
salida digital.
Nota: Para mayor información ver la hoja de datos de la placa de adquisición utilizada, la cual se
adjunta con estos apuntes.
Public Sub EncenderCalentador

Out pDireccionBase ,1
End Sub
Public Sub ApagarCalentador

Out pDireccionBase ,0
End Sub

Gráfico en tiempo real de la temperatura
Incorporaremos a nuestro proyecto un nuevo formulario al que llamaremos frmGraficoTemp, y que
tendrá las siguientes propiedades:

Command Name cmdCerrar
Button
Timer Name tmrRedibujar
Comenzaremos por establecer el sistema de coordenadas de nuestro gráfico.

Utilizando las propiedades relacionadas ScaleHeight, ScaleWidth, ScaleLeft y ScaleTop, se puede
configurar un sistema de coordenadas completo, con coordenadas positivas y negativas.
ScaleHeight, ScaleWidth, devuelven o establecen el número de unidades de medida horizontal

(ScaleWidth) y vertical (ScaleHeight) del interior de un objeto al utilizar métodos gráficos o al
colocar controles.
Sintaxis: objeto.ScaleHeight [= valor]

objeto.ScaleWidth [= valor]
Con estas propiedades se puede crear una escala de coordenadas personalizada para dibujar o
imprimir. Por ejemplo, la instrucción ScaleHeight = 100 define la altura interior de como 100
unidades, o la unidad como 1/100 de la altura.
También se puede utilizar la propiedad ScaleMode para definir una escala basada en una unidad de
medida estándar, como twips, puntos, píxels, caracteres, pulgadas, milímetros o centímetros.
Utilizando estas propiedades y las relacionadas ScaleLeft y ScaleTop, puede configurar un sistema
de coordenadas completo, con coordenadas positivas y negativas. Estas cuatro propiedades de
escala se relacionan con la propiedad ScaleMode de la siguiente forma:
Al establecer un valor en cualquier otra propiedad de escala, en ScaleMode se establece
automáticamente 0. Al establecer en ScaleMode un número mayor que 0, ScaleHeight y
ScaleWidth cambian a la nueva unidad de medida, y en ScaleLeft y ScaleTop se establece 0.
' Parametros para el Formulario

ScaleLeft = -20
ScaleTop = 120
ScaleWidth = 190
ScaleHeight = -150
' Ubicación del control cmdCerrar
cmdCerrar.Left = 120
cmdCerrar.Top = -13
cmdCerrar.Visible = True
Ubicaremos en el formulario los ejes del gráfico cartesiano. Para ello, graficaremos un rectángulo
lleno de color blanco con un borde de color negro, y un ancho de línea de dos puntos.
Para dibujar líneas se utiliza el método Line, cuya sintaxis es:
Line (xColumnaInicial, yFilaInicial)-(xColumnaFinal, yFilaFinal), CódigoColor,[B][F]
Donde los parámetros B y F son opcionales

B, si se incluye, hace que se dibuje un rectángulo utilizando las coordenadas para especificar las
esquinas opuestas del mismo.
Si se utiliza la opción B, la opción F especifica que el rectángulo se rellena con el mismo color que
se ha utilizado para dibujarlo. No se puede utilizar F sin B.

' Dibujamos los rectángulos
Cls
DrawWidth = 2
Line (0, 100)-(150, 0), QBColor(15), BF
Line (0, 100)-(150, 0), QBColor(1), B
A continuación dibujaremos las divisiones de los ejes vertical (y) y horizontal (x), y le daremos los
valores correspondientes.
' Dibujar divisiones de ejes y valores.
DrawWidth = 1
' Ejes Y
CurrentY = i
Line (-2, i)-(0, i), RGB(0, 0, 150)
Line (-3, i)-(0, i), RGB(0, 0, 150)
CurrentX = -14
CurrentY = i + 2
Print Format(i /20, "0.0")
End If
Line (150, i)-(152, i), RGB(0, 0, 150)
Line (150, i)-(153, i), RGB(0, 0, 150)
DrawStyle = 2
Line (1, i)-(149, i), QBColor(7)
DrawStyle = 0
End If
CurrentX = 153
CurrentY = i + 2
Print Format(i / 20, "0.0")
End If
Next i
' Eje X
CurrentX = i
Line (i, -2)-(i, 0), RGB(0, 0, 150)
If i Mod 10 = 0 Or i = 0 Then
Line (i, -3)-(i, 0), RGB(0, 0, 150)
DrawStyle = 2
Line (i, 1)-(i, 100), QBColor(7)
DrawStyle = 0
End If
CurrentY = -4
CurrentX = i - 3
Print i / 10
End If
Next i
CurrentY = -4: CurrentX = 155: Print "t [Seg]"
' Origen de Coordenadas (0;0) de las curvas a representar
CurrentX = 0: CurrentY = 0

Curva de temperatura a
1
graficar
La curva la graficaremos
Ejecutar cada siguiendo el diagrama de flujo
1 Seg por Timer que se representa a
continuación.
Hemos representado en
xAnterior<-0 particular este diagrama de flujo,
yAnterior<-0 pues el procedimiento principal
xActual<-1 de graficación de la(s) curvas.
Debemos definir y declarar las

fTempActual <- variables que utilizaremos, para
el gráfico de las temperaturas.
Las variables:
xActual, xAnterior, yAnterior
xActual > deben ser variables de tipo real
Ancho simple y locales.
Gráfico?
La variable fTempActual es
xActual<-0
xAnteriorl<-0 también del tipo real simple pero
es una variable global, ya que
este valor se actualiza en el
Redibujar ejes procedimiento de lectura de la
placa de ADQ.
A continuación codificaremos el
Dibuja Linea desde procedimiento descrito en el
(xAnterior, yAnterior) a
(xActual, fTempActual) diagrama de flujo.
xAnterior <- xActual

xActual <- xActual + 1
yAnterior <- fTempActual

Figura 32- Algoritmo del grafico en tiempo real
' Curva de Temperatura

Static xActual As Single, xAnterior As Single, yAnterior As Single
If xActual > 150 Then
xActual = 0
xAnterior = 0
Form_Paint
End If
Line ( xAnterior, yAnterior)-(xActual, fTempActual / 2.5), QBColor(4)
xAnterior = xActual
xActual = xActual + 1
yAnterior = fTempActual / 2.5

Tenemos en los párrafos anteriores el código que nos permitirá representar la curva de
temperatura, veamos ahora donde debemos ubicar dicho código dentro del formulario
frmGraficoTemp y si es necesario además agregar algún nuevo control al formulario.
Dentro del evento Paint del formulario escribimos el código correspondiente a los parámetros del
formulario, la ubicación del botón cmdCerrar y el código correspondiente al gráfico de los ejes
cartesianos.
El código correspondiente a la gráfica de la curva de temperatura lo “pegamos” en el evento
Timer del Timer tmrRedibujar.
Guardar la configuración en un archivo

Agregaremos a nuestra aplicación un archivo que permita guardar la configuración de los
parámetros del sistema.
Primeramente veamos cuales son estos parámetros:
Valores de configuración de las temperaturas máxima y mínima de la Alarma

Dirección base de la placa de adq.
Set Point (temperatura deseada)
Rango de Histéresis
Un archivo esta básicamente compuesto por un número variable de registros formados por un
número constante de campos, los cuales contienen igual tipo de datos.
Veamos la estructura de un registro:
Campo1 Campo2 Campo3 Campo4 .......... Campo

N
Ahora creemos un “tipo de datos definido por el usuario”. Qué es un tipo definido por el usuario?
Se pueden definir tipos por parte del usuario para crear registros (structs en C, Record en Pascal).
Un registro puede definirse como una colección de datos de diferentes tipos relacionados entre sí.
Para crear un registro se necesita la sentencia Type ... End Type. Esta sentencia solo puede
aparecer en la sección de declaraciones de un módulo estándar y pueden ser declarados como
Private o Public. En nuestro caso lo definiremos de la siguiente manera:
Type tipoParametros
fTempMx as Single
fTempMin as Single
iDireccionBase as Integer
fSentPoint as Single
fHisteresis as Single
End Type
Una vez definido un tipo de datos, se declara la variable con la instrucción Public, teniendo en
cuenta que “las variables que se declaran usando la instrucción Public a nivel de módulo están
disponibles para todos los procedimientos de todos los módulos en todas las aplicaciones”.
Public tduParametros as tipoParametros
Para refererirse a un determinado campo del registro, se utiliza la notación variable.campo:

tduParametros.fTempMx
tduParametros.fTempMin
tduParametros.iDireccionBase
tduParametros.fSentPoint
tduParametros.fHisteresis

Los parámetros los grabaremos en un archivo al que llamaremos Paramet.Dat, utilizando el
siguiente segmento de código.
Open "Paramet.Dat" For Random As #1 Len = Len(tduParametros)

Put #1, , tduParametros
Close #1
En este caso, estamos utilizando un archivo de acceso aleatorio de un solo registro, el cual abrimos
con el comando Open, escribimos con el comando Put y cerramos con el comando Close.
Para leer los valores de los parámetros guardados en el archivo, utilizamos el siguiente segmento
de código.
Open "Paramet.Dat" For Random As #1 Len = Len(tduParametros)

Get #1, , tduParametros
Close #1
Los segmentos de código anteriores, los incorporamos a dos nuevos procedimientos llamados:
GrabarParametros y LeerParametros, los cuales creamos dentro del módulo modPrinc, de
manera de poder acceder a ellos desde cualquier parte de la aplicación.
Archivo de datos que permita registrar la variación de variables de entrada y

salida
Veamos primeramente cuales son los datos que queremos registrar
Fecha, Hora, Temperatura
Podemos crear un archivo de tipo secuencial o aleatorio.

Utilizando este último, podemos definir un tipo de datos de la siguiente manera:
Type tipoDatos
dateHisto As Date
timeHisto as Date
fTempHisto as Single
End Type
Lo declaramos a nivel de módulo como una variable global

Public tduDatos as tipoDatos
También declaramos un vector en el cual leeremos los datos guardados.

Public tduDatosHistoricos(50) As tipoDato
En este caso no se trata de un solo registro como vimos anteriormente para guardar los parámetros
de configuración , sino que tendremos un registro por cada valor de temperatura que deseemos
guardar, con lo que el código a escribir no será tan sencillo como en el caso anterior, pero tampoco
muy complicado.
Para generar el archivo y guardar los datos en el, primero actualizaremos los valores de los
campos:
tduDatos.dateHisto= Format(Now, "dd/mm/yyyy") ' Asignamos el dia de hoy

tduDatos.timeHisto= Format(Now, "hh:mm:ss") ' Asignamos la hora actual
tduDatos.fTempHisto=fTempActual ' Asignamos la temperatura medida
Para poder agregar un nuevo registro al archivo, debemos saber la cantidad de registros que tiene
el mismo. Esto se obtiene dividiendo la cantidad de bytes del archivo por la longitud en bytes del
registro. Para poder hacer esto, primero debemos abrir el archivo, luego calculamos la cantidad de
registros y le sumamos uno. Este número corresponde al número del nuevo registro.

' Declaramos las variables a utilizar
Static i as Integer, cNumeroRegistros as Integer, cRegistroActual as Integer
' Abrimos el archivo para acceso aleatorio
Open "Datos.Dat" For Random As #1 Len = Len(tduDatos)
cNumeroRegistros = LOF(1) / Len(tduDatos) ' Obtenemos la cantidad de registros del archivo
cRegistroActual = cNumeroRegistros + 1 ' Registro actual = registros en el archivo + 1
' Escribimos los valores históricos de la temperatura
Put #1, cRegistroActual , tduDatos
' Cerramos el archivo
Close #1
A continuación se representa el código necesario para poder leer los datos del archivo y asignarlos
al vector tduDatosHistoricos()
' Declaramos las variables a utilizar

Static i as Integer, cNumeroRegistros as Integer
' Abrimos el archivo para acceso aleatorio
Open "Datos.Dat" For Random As #1 Len = Len(tduDatos)
' Leemos los valores Históricos de temperatura.
cNumeroRegistros = LOF(1) / Len(tduDatos) ' Obtenemos la cantidad de registros del archivo
For i = 1 To cNumeroRegistros ' Leemos todos los registros
Get #1, , tduDatosHistoricos(i)
Next i
' Cerramos el archivo
Close #1
Nota: La variable tduDatosHistoricos se puede redimensionar dentro de este último procedimiento con
la cantidad de registros del archivo (cNumeroRegistros), utilizando la sentencia ReDim.
Una vez que los valores están asignados a dicho vector, se debería completar la aplicación
diseñando la manera de poder ver dichos valores utilizando un nuevo formulario.
También se podría diseñar un nuevo formulario que permita graficar en pantalla los valores de
temperatura históricos ordenados por fecha y hora.
Como verán, las opciones que de ahora en más podemos adicionar son variadas, y en general, las
mismas están basadas en las modificaciones de los procedimientos anteriores.
En la figura 33 vemos el formulario frmAdquisicion en una etapa intermedia del desarrollo de la
aplicación.
Figura 33 - Formulario en etapa intermedia del desarrollo

Comunicaciones Serie. El Control Communications
Introducción
El control Communications permite agregar tanto una funcionalidad sencilla de comunicaciones
de puerto serie como una funcionalidad avanzada para crear una herramienta de comunicaciones
completa controlada por eventos.
El control Communications proporciona una interfaz con un conjunto estándar de comandos de
comunicaciones. Permite establecer una conexión con un puerto serie, conectar con otro
dispositivo de comunicaciones (por ejemplo, un módem), emitir comandos, intercambiar datos, y
supervisar y responder a varios eventos y errores que pueden producirse durante una conexión
serie.
Fundamentos de la comunicación serie

Todos los equipos se suministran con uno o más puertos serie, que se denominan sucesivamente
COM1, COM2, etc. En un equipo estándar, normalmente el mouse (ratón) estará conectado al
puerto COM1. En el puerto COM2 puede haber conectado un módem, en COM3 un escáner, etc.
Los puertos serie proporcionan un canal para la transmisión de datos desde estos dispositivos serie
externos.
La función esencial del puerto serie es actuar como intérprete entre la CPU y el dispositivo serie.
Al enviar datos desde la CPU a través del puerto serie, los valores de tipo byte se convierten en
series de bits. Cuando se reciben datos, las series de bits se convierten en valores de tipo byte.
Para completar la transmisión de los datos es necesario otro nivel de interpretación. En el lado del
sistema operativo, Windows utiliza un controlador de comunicaciones, Comm.drv, para enviar y
recibir datos mediante las funciones estándar de la API de Windows. El fabricante del dispositivo
serie proporciona un controlador que conecta este hardware con Windows. Cuando utiliza el
control Communications, está ejecutando funciones de la API que interpreta el controlador
Comm.drv y que se transfieren al controlador del dispositivo.
Al trabajar en Visual Basic, sólo hay que establecer y supervisar las propiedades y eventos del
control Communications.
Establecimiento de la conexión serie

El primer paso para utilizar el control Communications consiste en establecer la conexión con el
puerto serie. En la tabla siguiente se enumeran las propiedades que se utilizan para esto:
Propiedades Descripción
CommPort Establece y devuelve el número del puerto de comunicaciones.
Settings Establece y devuelve la velocidad en baudios, la paridad, los bits de datos y los bits
de parada como una cadena.
PortOpen Establece y devuelve el estado de un puerto de comunicaciones. También abre y
cierra un puerto.
Apertura del puerto serie

Para abrir un puerto serie, se utilizan las propiedades CommPort, PortOpen y Settings. Por
ejemplo:
' Abre el puerto serie
MSComm1.CommPort = 2
MSComm1.Settings = "9600,N,8,1"
MSComm1.PortOpen = True
La propiedad CommPort determina el puerto serie que se va a abrir. Si hay un módem conectado
a COM2, en el ejemplo anterior se establece el valor a 2 (COM2) y se conecta con el módem.
Puede establecer la propiedad CommPort a cualquier número entre 1 y 16 (el valor
predeterminado es 1). Sin embargo, si se establece este valor a un puerto COM que no existe en el
sistema en el que se ejecuta la aplicación, se producirá un error.

La propiedad Settings permite especificar la velocidad en baudios, la paridad y el número de bits
de datos y de parada. De forma predeterminada, la velocidad en baudios es 9600. La paridad sirve
para la validación de los datos. Normalmente no se utiliza y se establece a “N”. El valor de bits de
datos indica el número de bits que representan un bloque de datos. El bit de parada indica cuándo
se ha recibido un bloque de datos.
Después de especificar el puerto que se va a abrir y la forma en que se realizará la comunicación
de los datos, para establecer la conexión se puede utilizar la propiedad PortOpen, que es un valor
booleano, True o False. Sin embargo, si el puerto no funciona, si la propiedad CommPort no se
ha establecido correctamente o si el dispositivo no admite la configuración especificada, se
producirá un error o puede que el dispositivo externo no funcione correctamente. Si se establece la
propiedad PortOpen a False, se cierra el puerto.
Establecimiento de las propiedades de los búferes de transmisión y de

recepción en tiempo de diseño
Cuando se abre un puerto, se crean búferes de transmisión y de recepción. Para administrarlos, el
control Communications proporciona diversas propiedades que se pueden establecer en tiempo de
diseño a través de las páginas de propiedades del control.
Asignación de memoria de búfer

En las propiedades InBufferSize y OutBufferSize, se especifican la cantidad de memoria
asignada a los búferes de recepción y transmisión. Cuanto mayor sea el valor especificado, menos
memoria habrá disponible para la aplicación. Sin embargo, si el búfer es demasiado pequeño, se
corre el riesgo de desbordarlo, a menos que se utilice un protocolo.
Las propiedades RThreshold y SThreshold

Las propiedades RThreshold y SThreshold establecen o devuelven el número de caracteres
recibidos en los búferes de recepción y transmisión antes de producirse el evento OnComm. El
evento OnComm se utiliza para supervisar y responder a los cambios en el estado de la
comunicación. Si se establecen ambas propiedades a cero (0), se impide que se produzca el evento
OnComm. Si se establece un valor distinto de 0 (1, por ejemplo), el evento OnComm se producirá
cada vez que se reciba un único carácter en cualquiera de los dos búferes.
Las propiedades InputLen y EOFEnable

Si se establece la propiedad InputLen a 0, el control Communications leerá todo el contenido del
búfer de recepción cuando se utilice la propiedad Input.
La propiedad EOFEnable se utiliza para indicar que se ha encontrado un carácter de final de
archivo (EOF) durante la entrada de datos. Si se establece a True, la entrada de datos se detiene y
se desencadena el evento OnComm para informarle de que se ha producido esta situación.
Administración de los búferes de recepción y transmisión

Como se ha indicado anteriormente, los búferes de recepción y transmisión se crean siempre que
se abre un puerto. Estos búferes se utilizan para almacenar los datos de entrada y para transmitir
los datos de salida. El control Communications permite administrarlos a través de diversas
propiedades con las que puede colocar y recuperar datos, obtener el tamaño de cada búfer y tratar
datos de texto y binarios. La correcta administración de estos búferes es una parte importante del
uso del control Communications.
El búfer de recepción
Se deb utilizar la propiedad Input para almacenar datos en el búfer de recepción y también para
obtenerlos de él. Por ejemplo, si se desea recuperar datos del búfer de recepción y mostrarlos en un
cuadro de texto, se puede utilizar código como el siguiente:
TxtDisplay.Text = MSComm1.Input

Sin embargo, para recuperar todo el contenido del búfer de recepción, primero se debe establecer
la propiedad InputLen a 0. Esto puede hacerse en tiempo de diseño o en tiempo de ejecución.
También se pueden recibir los datos de entrada como texto o como datos binarios, si se establece
la propiedad InputMode a una de las siguientes constantes de Visual Basic: comInputModeText
o comInputModeBinary. Se debe utilizar comInputModeText para los datos que empleen el
juego de caracteres ANSI y comInputModeBinary para todos los demás datos, como los que
incluyan caracteres de control incrustados, caracteres nulos, etc.
Al recibirse cada byte de datos, se traslada al búfer de recepción y la propiedad InBufferCount se
incrementa en una unidad. Por tanto, es posible utilizar la propiedad InBufferCount para obtener
el número de bytes del búfer de recepción. También se puede borrar el contenido del búfer de
recepción si se establece el valor de esta propiedad a 0.
El búfer de transmisión
Se debe utilizar la propiedad Output para enviar comandos y datos al búfer de transmisión.
Al igual que con la propiedad Input, se pueden transmitir los datos como texto o como datos
binarios. Sin embargo, la propiedad Output debe transmitir el texto o los datos binarios mediante
la especificación de una cadena o de un tipo Variant de matriz de bytes.
Como se mencionó anteriormente, las líneas de transmisión deben terminar con un carácter de
retorno de carro (vbCr).
Se pueden controlar el número de bytes del búfer de transmisión mediante la propiedad
OutBufferCount. También se puede borrar el contenido del búfer de transmisión si establece esta
propiedad a 0.
Protocolo
Una de las tareas de la administración de los búferes de recepción y transmisión es asegurar que el
tráfico de datos tenga éxito; por ejemplo, que la velocidad con la que se reciben los datos no
desborde los límites del búfer.
El término protocolo hace referencia al protocolo de comunicaciones interno por el cual se
transfieren los datos del puerto hardware al búfer de recepción. Cuando llega un carácter de datos
al puerto serie, el dispositivo de comunicaciones tiene que llevarlo al búfer de recepción para que
el programa pueda leerlo. Un protocolo de comunicaciones asegura que los datos no se perderán
por un desbordamiento del búfer, lo que puede ocurrir cuando los datos llegan al puerto tan rápido
que el dispositivo de comunicaciones no puede llevarlos al búfer de recepción.
Se puede establecer la propiedad Handshaking para especificar el protocolo de comunicación que
va a utilizar la aplicación. De forma predeterminada, está establecida a comNone (ninguno). Sin
embargo, se puede especificar cualquiera de los protocolos siguientes:
Opción Valor Descripción

comNone 0 Sin protocolo (predeterminado).
comXOnXOff 1 Protocolo XON/XOFF.
comRTS 2 Protocolo RTS/CTS (Petición para emitir / Listo para emitir
comRTSXOnXOff 3 Ambos Protocolos RTS/CTS y XON/XOFF.
El evento OnComm y la propiedad CommEvent

Según el alcance y la funcionalidad de la aplicación, puede que se necesite controlar y responder a
una serie de eventos y errores que pueden producirse durante la conexión con otro dispositivo o en
la recepción o transmisión de los datos.
El evento OnComm y la propiedad CommEvent permiten interceptar y comprobar el valor de los
eventos y errores de comunicación.
Cuando se produce un evento o un error de comunicación, se desencadena el evento OnComm y se
modifica el valor de la propiedad CommEvent. De esta forma, si es necesario, se puede
comprobar el valor de CommEvent cada vez que ocurra el evento OnComm.
En la tabla siguiente se enumeran los eventos de comunicaciones que desencadenarán el evento
OnComm. Los valores indicados se escriben en la propiedad CommEvent.
Constante Valor Descripción
comEvSend 1 En el búfer de transmisión hay menos caracteres que los indicados en
SThreshold.
comEvReceive 2 Se ha recibido el número de caracteres indicado en RThreshold. Este
evento se genera continuamente hasta que utilice la propiedad Input
para quitar los datos del búfer de recepción.
comEvCTS 3 Cambio en la línea Listo para emitir (CTS).
comEvDSR 4 Cambio en la línea Terminal de datos preparado (DSR). Este evento
sólo se produce cuando la línea DSR pasa de 1 a 0.
comEvCD 5 Cambio en la línea Detector de portadora (CD).
comEvRing 6 Detectada la llamada. Puede que algunos UART (transmisores-
receptores universales asíncronos) no admitan este evento.
comEvEOF 7 Recibido carácter de fin de archivo (carácter ASCII 26).
El evento OnComm también se desencadena, y se escribe un valor en la propiedad CommEvent,

cuando ocurren los errores siguientes:
Constante Valor Descripción

comEventBreak 1001 Se ha recibido una señal de interrupción.
comEventCTSTO 1002 Ha expirado el tiempo de espera para emitir. La línea Listo para emitir
(CTS) estaba en nivel bajo durante el número de milisegundos
indicado en CTSTimeout cuando se intentaba transmitir un carácter.
comEventDSRTO 1003 Ha expirado el tiempo de espera de terminal datos preparados. La
línea Terminal de datos preparado (DSR) estaba en nivel bajo durante
el número de milisegundos indicado en DSRTimeout, cuando se
intentaba transmitir un carácter.
comEventFrame 1004 Error de trama. El hardware ha detectado un error de trama.
comEventOverrun 1006 Puerto desbordado. No se leyó un carácter desde el hardware antes
de llegar otro carácter y el primero se ha perdido.
comEventCDTO 1007 Ha expirado el tiempo de espera de detección de portadora. La línea
Detector de portadora (CD) estaba en nivel bajo durante el número de
milisegundos indicado en CDTimeout cuando se intentaba transmitir
un carácter.
comEventRxOver 1008 Desbordamiento del búfer de recepción. No hay espacio suficiente en
el búfer de recepción.
comEventRxParity 1009 Error de paridad. El hardware ha detectado un error de paridad.
comEventTxFull 1010 Búfer de transmisión lleno. Se ha intentado colocar un carácter más
en la cola mientras el búfer de transmisión estaba lleno.
ComEventDCB 1011 Error inesperado al obtener el bloque de control de dispositivo ( DCB)
para el puerto.
Diagramación Lógica - Alberto R. Lardent.

Enciclopedia del MS Visual Basic 4.0 - Francisco Javier Ceballos
Programación Avanzada en MS Visual Basic 4.0 – Bruce McKinney
El libro del RS232 - Joe Campbell.
ADQ12-B Descripción Técnica del Hardware - Axial Electrónica
ADQ12-B Descripción Técnica del Software - Axial Electrónica
Manual del Taurus Active Scada.
Manual del programador de Visual Basic - Microsoft.
Artículos de Revistas Nacionales y/o Extranjeras

Apuntes Informática II - Año 2001

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Apuntes Informática II - Año 2001

Încărcat de

Drepturi de autor:

Formate disponibile

' Dibujar divisiones de ejes y valores.

CONTENIDOS TEORICOS - PRACTICOS DE

Facultad de Ciencias y Tecnología

Diagramación lógica: Conceptos..........................................................................5

1 Juan Carlos Ansaldi - Sept. 2001

Archivos en Visual Basic.........................................................................................54

Detalle de las Instrucciones y Funciones Utilizadas con Archivos..........................58

2 Juan Carlos Ansaldi - Sept. 2001

3 Juan Carlos Ansaldi - Sept. 2001

4 Juan Carlos Ansaldi - Sept. 2001

5 Juan Carlos Ansaldi - Sept. 2001

Figura 1 - Diagrama de flujo del problema anterior

Concepto de Algoritmo y Resolución de Problemas

6 Juan Carlos Ansaldi - Sept. 2001

Diagramas de lógica o de flujo

Los diagramas de flujo y los programas de computación

7 Juan Carlos Ansaldi - Sept. 2001

En síntesis, el empleo de la táctica de diagramación lógica permite la integración lógica de las

Simbología para diagramación

Veamos a continuación la simbología que se utilizan en la confección de los diagramas.

Terminal ó Extremos de Interrupción: Representa los pasos de comienzo y fin o un punto en

8 Juan Carlos Ansaldi - Sept. 2001

Proceso: Representa cualquier función de procesamiento, por ejemplo la función de ejecución de

Entrada/Salida: Representa la función de entrada de datos o salida de información,

Entrada manual: Representa una función de entrada en la cual la información se introduce

9 Juan Carlos Ansaldi - Sept. 2001

Decisión (Salto Condiciona

Operación de Entrada / Salid

Salida en forma de documen

Salida por pantal

Función de Entrada /Salid

10 Juan Carlos Ansaldi - Sept. 2001

11 Juan Carlos Ansaldi - Sept. 2001

Veamos la resolución del problema:

12 Juan Carlos Ansaldi - Sept. 2001

Nro de Variables de Entrada Variables de Salida Impresió

13 Juan Carlos Ansaldi - Sept. 2001

14 Juan Carlos Ansaldi - Sept. 2001

Los Ambientes de Desarrollo

Visual Basic, su entorno de trabajo

15 Juan Carlos Ansaldi - Sept. 2001

Figura 5 - Ambiente de Trabajo de V Basic

❏ Formulario: Es la ventana en donde se desarrolla la interfase de la aplicación. En ella se

16 Juan Carlos Ansaldi - Sept. 2001

Tiempo de diseño y tiempo de ejecución: Cuando el usuario construye su aplicación, trabaja

Propiedades: Las propiedades de un objeto definen su apariencia y comportamiento. Cada objeto

17 Juan Carlos Ansaldi - Sept. 2001

❏ Eventos Se disparan automáticamente ante la ocurrencia de un suceso. Su nombre es estándar y

Private Function NombreDeFuncion(Par.) As TipoDeDato

Los procedimientos pueden escribirse “dentro” de un formulario, y esto se hace generalmente

18 Juan Carlos Ansaldi - Sept. 2001

Desarrollo de aplicaciones utilizando Visual Basic

Como primera medida se debe dar un nombre y un destino en el

19 Juan Carlos Ansaldi - Sept. 2001

Botón Control Nombre por defecto

Figura 9 - La interfaz modificada de la aplicación Calcular

2. Configurar las Propiedades

En la figura se observa que el objeto seleccionado posee el

Figura 10 - Ventana de propiedades

Figura 11 - Nueva modificación de la aplicación Calcular

Objeto Propiedad Valor

21 Juan Carlos Ansaldi - Sept. 2001

Bien, justamente lo que

La ventana de código incluye los siguientes elementos: