Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Introduccin .............................................................................................................................................................4
Qu es LabWindows/CVI? ..................................................................................................................................4
Entorno de desarrollo ...........................................................................................................................................4
Mi primer programa .................................................................................................................................................5
Atributos importantes de un panel ......................................................................................................................6
Generando cdigo de archivo UIR ........................................................................................................................8
Analizando el cdigo generado ......................................................................................................................... 11
Agregando un botn para desplegar un mensaje ............................................................................................. 13
Eventos posibles para paneles y controles ........................................................................................................ 16
Prctica manejando eventos ............................................................................................................................. 17
Manejo de datos en pantalla ................................................................................................................................. 17
Leer y asignar informacin en un panel ............................................................................................................ 17
Prctica modificando el estado de un led ......................................................................................................... 17
Prctica de operacin con dos nmeros ........................................................................................................... 18
Prctica para actualizar controles usando eventos ........................................................................................... 20
Manejo de Timers .................................................................................................................................................. 21
Timer Sncrono y Asncrono............................................................................................................................... 21
Consideraciones para un timer sncrono ........................................................................................................... 22
Ejercicio utilizando timer sncrono .................................................................................................................... 23
Funciones para controles de tipo Timer ............................................................................................................ 23
Ejercicio utilizando timer sncrono y control graph........................................................................................... 24
Funcionamiento:................................................................................................................................................ 24
Timer Asncrono ................................................................................................................................................ 28
Funciones para el manejo de un Timer Asncrono ............................................................................................ 28
Ejercicio utilizando un timer asncrono ............................................................................................................. 30
Manejo de ActiveX................................................................................................................................................. 31
Cmo se registra un ActiveX en Windows? ................................................................................................. 31
2
Introduccin
Qu es LabWindows/CVI?
LabWindows/CVI es un completo ambiente de desarrollo ANSI C para la creacin de
aplicaciones de instrumentacin virtual. LabWindows/CVI viene con libreras para
adquisicin, anlisis y visualizacin, una interface simplificada de edicin para usuario con
arrastre y colocacin de elementos y herramientas automatizadas de generacin de cdigo
con las cuales se puede probar dicho cdigo interactivamente entes de adicionarlo a un
proyecto. Con LabWindows/CVI, se pueden crear interfaces localizadas de usuario, crear y
trabajar con componentes ActiveX y desarrollar aplicaciones multihilos.
Entorno de desarrollo
La interfaz del entorno de desarrollo, es muy similar a otros IDE como Visual Studio, Eclipse,
etc.
1.- Panel de proyectos. En esta parte se organizan los archivos (*.c, *.h, *.uir, *.prj) que
integran el o los proyectos. En este mismo espacio se pueden insertar archivos que no
formen parte del proyecto, como pueden ser archivos *.txt, archivos de base de datos, etc.
Este tipo de archivos no afectan el proceso de compilacin o ejecucin de un proyecto.
2.- Panel de libreras. En este espacio CVI coloca la descripcin del contenido de las
diferentes libreras que se encuentran integradas al proyecto activo.
3.- Espacio para usos mltiples. Se utiliza como editor de cdigo C, editor de la interfaz
grfica, editor de paneles de funciones, visualizacin de contenido de variables, memoria,
etc.
Mi primer programa
Una vez iniciada la sesin con LabWindows/CVI, se proceder a guardar el proyecto que
vamos a crear, el nombre propuesto es Ejercicio01.
Ahora crearemos un nuevo documento de tipo UIR para crear nuestro panel de interfaz de
usuario.
Una vez que hemos configurado nuestro primer panel, procederemos a guardar nuestro
archivo UIR. El nombre propuesto es Interfaz01.
El primer cambio es para que el archivo destino con el cdigo fuente, sea insertado en
nuestro proyecto activo.
El segundo, es indicar el nombre de una variable (veremos ms adelante que ser de tipo
entero) que nos servir a nivel de cdigo, para identificar a este panel en particular. Esta
variable ser utilizada para acciones como el desplegar el panel u ocultarlo.
El ltimo se refiere a indicar cul funcin callback de las existentes en nuestro archivo UIR,
servir para poder cerrar nuestra aplicacin. Como en este momento solo hemos
especificado una funcin (Terminar), seleccionaremos la misma para finalizar la aplicacin.
Al aceptar estos ajustes, deberemos observar una imagen como la siguiente:
10
Nuestra aplicacin solo se limita por ahora a mostrar un panel y responder a la accin de
cerrar. Las funciones de minimizar y maximizar se encuentran implcitas en todo panel
creado y no requieren de una funcin callback para ejecutarse.
2
1
3
1. En esta parte se concentran todas las libreras de tipo .h que son necesarias para
poder compilar exitosamente cada una de las funciones incluidas en el cdigo fuente.
Por lo general LabWindows nos recomendar las libreras que son necesarias incluir
cuando alguna funcin sea desconocida. Entre estos archivos podemos ver que existe
uno con el mismo nombre de nuestro archivo UIR. Esto se debe a que todo archivo
UIR que generemos, siempre se encontrar acompaado por su respectivo archivo .h
11
3. Como todo programa en C, siempre debe existir una funcin main. Normalmente en
esta funcin, se destina para ejecutar una funcin llamada LoadPanel.
La finalidad de esta funcin es el cargar en memoria el panel o los paneles que hemos
creado en nuestro archivo UIR. Esta funcin recibe tres parmetros:
- El primero por el momento lo usaremos con el valor de cero
- El segundo es el nombre del archivo UIR en donde se encuentra el panel que
deseamos cargar en memoria
- El tercero corresponde a la constante que identifica a nuestro panel.
Esta funcin retorna un valor de tipo entero, que no es otra cosa ms que la referencia
del panel que se ha cargado en memoria. Esta referencia sera el valor que
utilizaremos en todo nuestro cdigo para ejecutar acciones sobre un panel.
Importante: El valor que retorna la funcin LoadPanel, no es el mismo que se
encuentra asociado a la constante del panel. Son valores distintos.
4. En esta seccin encontramos nuestra funcin callback que definimos desde nuestro
archivo UIR. LabWindows por default genera una funcin callback en donde inserta
una estructura de control tipo switch.
La finalidad de una estructura switch es el poder manejar diferentes eventos que se
puedan generar desde el panel o control al que se encuentra asociada la funcin
callback.
12
El caso que nos interesa analizar por este momento, es que corresponde al
EVENT_CLOSE. Este evento se asocia a la accin de pulsar clic izquierdo sobre la X
de la ventana, indicando que se desea cerrar la ventana.
Una vez que estamos listos para capturar el evento que nos interesa, solo resta
escribir al interior del case, las acciones que deseamos sean ejecutadas cuando se
cumpla esa condicin.
Para el ejercicio actual, LabWindows ha escrito la funcin QuitUserInterface que
significa se debe detener toda captura de eventos para salir de nuestro programa.
La funcin QuitUserInterface cancela a la funcin RunUserInterface que se ejecut en
la funcin main.
13
Ajustaremos las propiedades del botn para que tenga el siguiente aspecto:
El cdigo de esta funcin ha sido generado en el archivo de cdigo fuente que tenemos en
nuestro proyecto. Cuanto tengamos varios archivos .c, LabWindows nos preguntar en cul
de ellos deseamos depositar el cdigo a generar.
Ahora nuestro editor de cdigo se muestra como sigue:
14
15
16
17
Ejecuta la aplicacin y valida su funcionamiento pulsando doble clic sobre el control led.
Dados dos nmeros (primera y segunda cantidad), al pulsar clic sobre el botn Multiplicar, se
colocar el resultado del producto en el control etiquetado como Resultado.
18
19
El funcionamiento de este ejercicio consiste en capturar a travs del control etiquetado como
Perilla de nivel, las variaciones que se hacen con el mouse en su valor y reflejarlo
simultneamente (sin soltar el mouse) en el control etiquetado como Depsito.
20
Manejo de Timers
Timer Sncrono y Asncrono
LabWindows ofrece dos tipos de controles que ayudan en el proceso de ejecucin
automtica de funciones mediante la programacin de eventos en base a tiempo.
El primero de ellos es el Timer
Sncrono, mismo que se pude insertar
desde el editor de UIR como un control.
Este tipo de control tiene las mismas
propiedades generales que hemos visto
hasta ahora, es decir, se identifica con un
Constant Name y se le asocia un nombre
de funcin callback, misma que se
ejecutar automticamente a intervalos
de tiempo predefinidos.
Un parmetro especfico para este tipo
de control, es el que permite la
configuracin del intervalo de tiempo de
ejecucin.
Otro parmetro que resulta de gran
utilidad al momento de trabajar con este
tipo de control, es el de habilitacin.
Este parmetro si se encuentra activo
indicar que desde el
momento en que nuestro proyecto es
ejecutado, el timer comenzar a ejecutar
la funcin asociada una vez transcurrido
el intervalo de tiempo especificado.
En caso contrario, si se encuentra deshabilitado
ser tarea del programador
mediante instruccin de cdigo, habilitar el timer cuando lo considere apropiado.
Una de las principales ventajas de este tipo de timer es su sencillez en el proceso de
implementacin, ya que se sigue el mismo proceso que hasta ahora hemos visto para
insertar un control y generar su funcin callback asociada desde el editor UIR.
21
La estructura de la funcin callback que nos genera un timer de este tipo es la siguiente:
Podemos observar que la nica diferencia es el tipo de evento que nos maneja la estructura
de control switch, ahora se trata de un EVENT_TIMER_TICK.
Cuando se inserta un timer en un panel dentro del editor UIR, observaremos un icono como
este
No debemos preocuparnos mucho por su ubicacin en nuestro panel que se est
diseando, ya que en tiempo de ejecucin el icono no es visible para el usuario.
Un ltimo dato importante sobre este tipo de timer sncrono es la resolucin de tiempo,
23
Funcionamiento:
Cuando se pulse clic sobre el botn Iniciar grfica, utilizando el valor de intervalo de
tiempo configurado y el nmero de datos a generar, se estar construyendo con nmeros
aleatorios, un vector con la cantidad de nmeros especificada en la pantalla. Este vector de
datos se estar dibujando en la grfica cada t segundos, segn se haya igualmente
configurado en la pantalla.
La grfica estar de forma continua hasta que se pulse en el botn Pausar grfica o se
cierre la aplicacin. En caso de pausar el proceso, se reanudar con Iniciar Grfica.
Finalmente, mientras la aplicacin se encuentra graficando datos automticamente,
podremos variar el tiempo de graficado y la cantidad de datos, simplemente modificando los
valores de los controles respectivos.
24
Constant Name
Callback Function
Label
INTERVALO
CambiarIntervalo
Intervalo de tiempo (segundos)
Constant Name
Callback Function
Label
DATOS
CambiaCantidadDatos
Cantidad de datos a generar:
Constant Name
Callback Function
Label
COMMANDBUTTON
Graficar
Iniciar grfica
Constant Name
Callback Function
Label
COMMANDBUTTON_2
Pausar
Pausar grfica
Constant Name
Callback Function
Label
Enable
TIMER
GraficarVector
0.500
No
Constant Name
Callback Function
Points per Screen
Scroll Mode
MIGRAFICA
10000
Continuos
25
Panel
Constant Name
Callback Function
Panel Title
PANEL
Salir
Utilizando
grficas
timer
sncrono
Una vez que se tenga configurado nuestro UIR, generamos todo el cdigo para comenzar a
complementarlo.
Para poner en marcha nuestra aplicacin, se requiere pulsar sobre el botn Iniciar grfica,
por lo que este botn deber establecer las condiciones iniciales de nuestra aplicacin.
- Leer y configurar el intervalo de tiempo que se ha configurado en la pantalla
- Leer el nmero de datos que se deben de generar
- Poner en marcha el timer
Se recomienda que las variables donde se almacene el intervalo de tiempo y la cantidad de
datos, sean globales, ya que sern utilizadas por varias funciones de nuestra aplicacin.
Cmo configurar el timer?.
Utilizamos la funcin SetCtrlAttribute en donde sus parmetros son:
- Variable con la referencia del panel
- Identificador del control que queremos modificar, en este caso el del timer
- El tipo de atributo que queremos modificar:
o ATTR_INTERVAL: Para modificar el intervalo de tiempo (tipo doble)
o ATTR_ENABLE: Para habilitar el timer (tipo entero)
- El valor del parmetro con el tipo de dato que segn aplique
Ahora, programaremos la funcin del botn Pausar grfica, en el paso anterior vimos como
se pone en marcha el timer, cmo podramos indicar que no est habilitado?.
Listo!! Ya tenemos nuestra funcin para pausar nuestro proceso de graficado.
Ahora hagamos que nuestra aplicacin responda a las modificaciones del tiempo y cantidad
de datos mientras se grafica.
Se generaron dos funciones callback asociadas a los controles que tiene esta informacin,
por lo que en cada funcin solamente habr que incluir el cdigo para que actualicen sus
variables respectivas.
Finalmente programemos las acciones del timer. Ah debemos construir un arreglo de datos
dobles y llenarlo con datos aleatorios. Podemos utilizar la funcin Random(). Posteriormente
hay que dibujarlo en pantalla con la instruccin PlotStripChart().
Hemos terminado.
26
27
Timer Asncrono
El segundo tipo de timer que nos permite implementar LabWindows, es el denominado
asncrono.
Una de las principales caractersticas de este control, es que la llamada de su funcin
callback se ejecuta en su propio hilo. Esto es, la administracin de los eventos generados por
un timer asncrono no corre a cargo de la funcin RunUserInterface.
Esta caracterstica hace que este tipo de timers sean ideales para tareas de adquisicin de
datos, en donde se requiere un mayor nivel de determinismo en su tiempo de ejecucin.
La cantidad de timers asncronos que se pueden crear en un sistema basado en Windows es
de 16, en sistemas de tiempo real la cantidad es de 128 y en sistemas Linux hasta 256.
En cuanto a la resolucin mnima de tiempo que se puede implementar en un timer
asncrono, a diferencia de la limitante de 1ms para el timer sncrono, en este caso se puede
alcanzar una resolucin de hasta 1us. Para conocer la resolucin mnima soportada por el
sistema operativo donde se va a ejecutar, la funcin GetAsyncTimerResolution proporciona
este dato.
Al utilizar este tipo de timers, se debe tener especial cuidado con las variables que sean
comunes entre timers. Esto es, ya que al tratarse de ejecuciones en hilos separados, el
contenido de las variables no se encuentra protegido y un mal manejo podra generar
inconsistencias en el contenido de las variables.
Finalmente, este timer se encuentra definido dentro de la librera asynctmr.h.
NewAsyncTimer. Con esta funcin creamos un nuevo timer asncrono. Cada timer
creado, tiene asociado un identificador (ID) que es de tipo entero, mismo que es
retornado por la funcin:
iIdentificador = NewAsyncTimer();
Esta funcin requiere de 4 parmetros:
o Intervalo: se define el tiempo de ejecucin del timer (valor doble)
o Contador: un valor de -1 significa que el timer se estar ejecutando hasta
que sea descartado por software. Para un valor mayor que cero, indicar el
nmero de veces que se ejecutar antes de que el timer se descarte
automticamente.
o Estado inicial: acepta los valores de 0/1. Un cero indica que el timer ser
creado pero estar detenido hasta que indiquemos por software lo contrario.
28
29
Funcionamiento.
-
El botn Crear timer, deber construir el timer asncrono para que se ejecute a
un intervalo de tiempo de 0.001 milisegundo.
El timer deber comenzar a ejecutarse automticamente para incrementar el
contenido del control numrico en 0.001
El botn Pausa, una vez que ha sido creado el timer y se encuentra en ejecucin,
deber pausar su ejecucin.
El botn Reanudar deber eliminar la pausa al timer asncrono, reanudando la
actualizacin de incremento en el control numrico.
Una vez concluida la aplicacin y estando en ejecucin, revisar el rendimiento del procesador
de la computadora y compararlo contra el ejercicio del timer sncrono con un intervalo de
0.001.
30
Manejo de ActiveX
LabWindows tiene la capacidad de utilizar los ActiveX registrados en Windows, dentro de las
aplicaciones que construyamos.
Como antecedente podemos comentar que los ActiveX son una tecnologa diseada por
Microsoft para el intercambio de informacin entre dos aplicaciones diferentes. Surgi de la
combinacin de dos tecnologas previas, OLE (Object Linking and Embedding - Insercin y
vinculacin de objetos) y COM (Common Object Model - Simulacin de objetos comunes).
Generalmente podremos identificar a un ActiveX por la extensin del archivo que lo contiene,
siendo sta .OCX
31
En esta ventana podremos observar una lista con todos los diferentes controles ActiveX que
se encuentran registrados en nuestro sistema operativo Windows.
Tomaremos como ejemplo el control Calendario de Windows.
Si
pulsamos
doble
clic
podremos ver que tenemos la posibilidad de configurar nuestra ya conocida Constant Name
y Callback Function, las cuales nos ayudan a identificar en cdigo el control y capturar los
eventos respectivamente.
33
En la parte superior nos mostrar el nombre del control al que se generar el archivo .fp
Podemos pulsar en el botn Advanced Options para mostrar la siguiente informacin:
34
En este pantalla podemos revisar cada una de las diferentes funciones que se van a generar.
Finalmente, al continuar con el proceso de generacin, tendremos la ltima pantalla que nos
confirma que se ha generado la librera para CVI.
35
Otro lugar donde podemos confirmar que nuestra librera ha sido cargada, es en el men
principal de nuestro entorno de desarrollo, en la seccin de Instrument.
Podemos ver que en la parte superior de la lista, aparece el nombre que identifica a nuestra
librera .fp
El resto de las opciones de este submen, nos permiten administrar nuestras libreras. Es
decir, si disponemos de alguna otra librera de tipo .fp, aqu es donde podemos indicarle a
nuestro proyecto que las incluya, las elimine o incluso, editarlas.
Nosotros podemos crear desde cero nuestra propia librera .fp, sin embargo, ese es un tema
que requiere dedicar varias horas de trabajo y por el momento, esta fuera del alcance de este
curso.
36
Funcionamiento:
Esta aplicacin deber capturar los eventos del control Calendario que correspondan al
momento en que modificamos la fecha seleccionada en l.
Una vez capturado el evento de modificacin, en los controles inferiores (Da, Mes y Ao) se
deber actualizar con la informacin correspondiente. Esta informacin la obtendremos del
control Calendario.
Finalmente, el botn de comando Actualizar calendario al da de hoy, nos servir para
restaurar la fecha en el control Calendario a la actual de nuestro sistema.
Bien, pues comencemos a desarrollar nuestra aplicacin.
Una vez que hemos configurado nuestro UIR y generamos cdigo, tendremos dos funciones
Callback que nos servirn para:
-
37
Antes de comenzar a insertar funciones relacionadas con el control Calendario para obtener
informacin de l, necesitamos crear la funcin callback que nos falta.
Veamos en nuestro panel de libreras lo siguiente.
La librera tiene dos grupos de funciones:
- Event Callback Registration Functions
- ICalendar
El primer grupo nos ofrece lo siguiente:
Aqu tenemos cada una de las funciones que nos permitirn registrar nuestras funciones
callback y que podemos asociar a nuestro control Calendario. Podemos ver que tenemos
funciones para registrar eventos tales como:
- Despus de que se ha generado alguna actualizacin
- Antes de generar una actualizacin
- Un clic
- Double clic
- Etc.
38
39
En los dos parmetros que se encuentran en blanco, el primero nos est solicitando lo que
llama Server Object. Esto no es ms que la variable donde actualmente tenemos
almacena la referencia de nuestro control Calendario.
El segundo, est solicitando el nombre que tendr nuestra funcin callback que se asociar
con el evento que hemos seleccionado. Para este caso la he llamado MiFuncion.
Al final, nuestra lnea de cdigo quedara como sigue:
Hasta este momento hemos registrado la funcin callback, ahora hace falta crear la funcin
misma. Para ello, la estructura que debe tener la funcin es la siguiente:
HRESULT CVICALLBACK Callback (CAObjHandle caServerObjHandle,
void *caCallbackData);
Por lo tanto, nuestra funcin quedara como sigue:
40
Es importante definir el prototipo de nuestra funcin al principio, esto para que el compilador
tenga conocimiento de la misma.
Ahora s, ya tenemos lista nuestra funcin callback en la cual podemos insertar el cdigo
necesario para leer informacin del control Calendario. Estas funciones las encontraremos en
el segundo grupo de funciones de la librera creada.
Lo que necesitamos conocer del control calendario es la fecha seleccionada, para ello
requerimos funciones que nos informen el da, mes y ao activos.
Complementando las funciones con sus parmetros e incluyendo el cdigo para actualizar la
interfaz de usuario, nuestro cdigo quedara:
Finalmente, necesitamos incluir cdigo para que el botn de comando restablezca el control
Calendario a la fecha actual.
Si revisamos en la lista de funciones disponibles del control Calendario, encontraremos una
que se llama
Nuestra funcin quedara como sigue:
41
Listo, nuestra aplicacin que opera con el ActiveX de Calendario de Windows est terminada.
Con este ejemplo hemos visto el proceso de insertar, generar cdigo y utilizar funciones de
un control ActiveX. Para cualquier control ActiveX es el mismo proceso, el reto al que nos
estaremos enfrentando es el comprender el contenido de las funciones del mismo.
Veremos que existen controles con unas cuantas funciones que son sencillas de entender y
en algunos casos, pueden resultar algo extensas en su nmero de funciones y relaciones
que guardan entre ellas.
Por ejemplo, para el caso del reproductor Windows Media Player, los grupos de funciones
disponibles son los siguientes:
funciones disponibles.
Complicado?. La verdad es que es ms sencillo de
lo que aparenta ser.
42
Con la experiencia de este ejercicio paso a paso, estamos en posibilidad de construir una
nueva aplicacin utilizando otro control ActiveX.
43
Les complemento
adicionales.
con
algunas
pantallas
44
45
Los datos al interior de una tabla no tienen un orden especfico. Ordenarlos, agruparlos y otro
tipo de operaciones con la informacin ocurre cuando de utiliza la sentencia SELECT para
46
extraer la informacin de la tabla. Un rengln puede tener columnas vacas, lo cual significa
que el rengln contiene valores nulos (NULL). Hay que destacar que el valor nulo en una
base de datos, no es lo mismo que el valor nulo utilizado en la programacin en lenguaje C.
Cada columna en una tabla tiene un tipo de dato definido. La disponibilidad de los datos
depender de cada administrador de base de datos (DBMS). El toolkit de SQL de
LabWindows usa un grupo comn de tipos de datos.
La siguiente tabla muestra los tipos de datos soportados por el LabWindows/CVI Toolkit SQL.
A lo largo de este documento, nos enfocaremos en mayor medida a las sentencias DML.
La siguiente es una lista de los comandos ms comunes de SQL:
-
CREATE TABLE. Permite crear una nueva tabla especificando el nombre y tipos
de datos para cada una de las columnas.
SELECT. Extrae todos los renglones en una tabla que cumplen con la condicin
especificada.
INSERT. Agrega un nuevo registro a la tabla. Esto permite asignar los valores
deseados a cada una de las columnas.
47
UPDATE. Actualiza los valores en las columnas especificadas para todos los
renglones que cumplan con la condicin definida.
DELETE. Elimina todos los registros que cumplan con la condicin especificada.
1. Primero pulsaremos clic sobre el icono de Base de datos en blanco. Esto nos
habilitar la seccin nmero 2.
2. En esta parte definiremos el nombre de nuestra base de datos y la ubicacin de la
misma.
3. Indicaremos que Access proceda con la creacin de nuestra base de datos en blanco
(sin tablas).
48
Ahora con nuestro entorno de desarrollo limpio, buscaremos abrir el editor de SQL desde el
men principal en la opcin Crear y posteriormente clic en la opcin Diseo de consulta.
49
Bien, a continuacin se encuentran las sentencias de SQL que deberemos ejecutar una a la
vez. Esto ser, copiar la sentencia de este documento y pegar reemplazando lo que exista en
el editor (donde dice SELECT;). Posteriormente pulsar clic en el botn
confirmando la accin.
Comencemos!
50
Ya tenemos listas nuestras 3 tablas, ahora comencemos a insertar datos en cada una de
ellas ejecutando de igual manera las siguientes sentencias.
Para la tabla Frecuentan:
a)
b)
c)
d)
e)
f)
g)
h)
insert
insert
insert
insert
insert
insert
insert
insert
into
into
into
into
into
into
into
into
Frecuentan
Frecuentan
Frecuentan
Frecuentan
Frecuentan
Frecuentan
Frecuentan
Frecuentan
VALUES('Hugo','Los Correa');
VALUES('Hugo','Los Tres Amigos');
VALUES('Hugo','El Portal');
VALUES('Paco','Los Tres Amigos');
VALUES('Paco','El Cortijo');
VALUES('Luis','Los Correa');
VALUES('Luis','El Portal');
VALUES('Tere','El Fuerte');
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
insert
into
into
into
into
into
into
into
into
into
into
into
into
into
Sirven
Sirven
Sirven
Sirven
Sirven
Sirven
Sirven
Sirven
Sirven
Sirven
Sirven
Sirven
Sirven
VALUES('Los Correa','Budweiser');
VALUES('Los Correa','Heineken');
VALUES('Los Correa','Tecate');
VALUES('Los Correa','Modelo Especial');
VALUES('Los Tres Amigos','Budweiser');
VALUES('Los Tres Amigos','Heineken');
VALUES('Los Tres Amigos','Tecate');
VALUES('Los Tres Amigos','Corona');
VALUES('El Portal','Budweiser');
VALUES('El Portal','Corona');
VALUES('El Portal','Sol');
VALUES('El Fuerte','Modelo Especial');
VALUES('El Cortijo','Indio');
51
insert
insert
insert
insert
insert
insert
insert
insert
insert
into
into
into
into
into
into
into
into
into
Le_Gusta_Beber
Le_Gusta_Beber
Le_Gusta_Beber
Le_Gusta_Beber
Le_Gusta_Beber
Le_Gusta_Beber
Le_Gusta_Beber
Le_Gusta_Beber
Le_Gusta_Beber
VALUES('Hugo','Budweiser');
VALUES('Hugo','Modelo Especial');
VALUES('Hugo','Corona');
VALUES('Paco','Heineken');
VALUES('Paco','Corona');
VALUES('Luis','Heineken');
VALUES('Luis','Tecate');
VALUES('Luis','Corona');
VALUES('Tere','Negra Modelo');
Aqu tenemos una vista que contiene el nombre de la persona (columna bebedor) y el
nombre del bar (columna bar) que acostumbra visitar.
He resaltado el nombre de la pestaa que tiene el nombre Consulta1, porque lo que
estamos viendo es el resultado de la consulta, no la tabla en s misma. As ocurrir con cada
SELECT que ejecutemos, el resultado ser una vista con la informacin que hayamos
solicitado.
Si quisiramos ver el contenido de la tabla, bastar con dar doble clic en el nombre de la
tabla.
52
Para ingresar una nueva consulta, bastar pulsar clic derecho sobre el nombre de la pestaa
y seleccionar Vista SQL.
En este caso, tenemos una tabla que nos muestra el bar (columna bar) con sus respectivos
tipos de cervezas que sirven (columna cerveza).
53
54
e) Imprimir los bebedores que frecuentan bares donde sirven alguna cerveza que les
gusta.
SELECT DISTINCT f.bebedor FROM Frecuentan f, Sirven s, Le_Gusta_Beber l
WHERE f.bar = s.bar AND s.cerveza = l.cerveza AND f.bebedor = l.bebedor;
55
56
Cada una de estas sentencias de SQL las podemos ejecutar tal cual dentro de
LabWindows/CVI, ms adelante comenzaremos a analizar como lograremos esto.
Por ahora continuemos revisando los requisitos de configuracin previos a trabajar con
LabWindows.
Adminstrador ODBC
La mayora de las ocasiones al trabajar con una base
de datos en LabWindows, requeriremos hacer algunas
modificaciones de configuracin al administrador de
orgenes de datos que tiene Windows.
Esto administrador al ejecutarlo mostrar la siguiente
ventana.
57
botn
58
59
60
El siguiente paso es ejecutar nuestra sentencia SELECT deseada. Por ejemplo, consultemos
el contenido de la tabla Frecuentan.
La funcin a utilizar es la siguiente:
iRefConsulta = DBActivateSQL(iRefODBC, select * from Frecuentan);
Recordemos de nuestros ejercicios de consulta con Access, que al ejecutar una sentencia
SELECT nos retornaba una vista con el contenido de la informacin solicitada.
Para la sentencia que estamos ejecutando, el asterisco (*) significa que queremos ver todas
las columnas de la tabla frecuentan.
61
LabWindows no puede mostrar una vista como lo hace Access, sin embargo, nos retorna una
referencia a dicha vista (para el ejemplo en la variable entera iRefConsulta). Con esta
referencia podremos leer el contenido de la vista.
iRefConsulta = DBActivateSQL(iReferenciaODBC, select * from Frecuentan);
iRefConsulta
iRefConsulta
Para poder vincular la informacin de la vista que hemos generado, necesitamos conocer el
tipo de dato de cada una de las columnas contenidas para identificar la funcin de lectura
adecuada en LabWindows.
Por ejemplo:
Tipo texto
Vista generada
Tipo texto
62
Las funciones que nos ofrece LabWindows para vincular nuestro cdigo con el contenido de
una columna en una vista, son las siguientes:
-
Donde:
Donde:
DBBindColInt.
63
Donde:
DBBindColFloat.
Donde:
Donde:
Es importante que el nmero de columna que se ingrese en cada una de las funciones
anteriores, corresponda con el orden de las columnas que existe en la vista que
hemos generado.
Volviendo a nuestro ejemplo de consulta a la tabla Frecuentan, nuestro cdigo desde la
conexin a la base de datos hasta vincular la vista a variables de cdigo quedara como
sigue:
La longitud de los arreglos de tipo char se han definido de 21 bytes, porque al construir
nuestra tabla Frecuentan, definimos que el ancho de cada una de las columnas fuera de 20
caracteres. El byte adicional es para que se pueda incluir el carcter de fin de cadena.
64
Una vez que tenemos establecida la vinculacin con las columnas de la vista, el siguiente
paso es leer rengln por rengln de la vista generada.
Para este efecto, LabWinidows nos ofrece las siguientes funciones:
-
Donde:
65
Donde:
Cada vez que ejecutemos por ejemplo DBFetchNext, el contenido de estas variables se
actualizar con la informacin correspondiente a donde se encuentre nuestro cursor.
Veamos la siguiente secuencia:
Nmero de ejecucin
De DBFetchNext
Variable
cBebedor
Variable
cBar
Cursor en la
vista
Ninguna
Primera
Hugo
Los Correa
Segunda
Hugo
Tercera
Hugo
El Portal
Cuarta
Paco
66
Cmo quedara nuestro cdigo para leer todo el contenido de la vista?. A continuacin se
muestra una propuesta.
Cada vez que se termine de utilizar la informacin de una vista, es necesario liberar la
referencia a la misma. Para ello disponemos de la funcin DBDeactivateSQL.
67
68
Para mayor informacin sobre el uso de esta funcin, pueden referirse a la ayuda de
LabWindows.
69
Para ejecutar esta funcin, necesitaremos previamente haber construido la sentencia SQL
que deseamos ejecutar y tenerla lista en una arreglo char.
Donde:
Un ejemplo de cdigo para insertar el nombre de una persona y el bar que le gusta
frecuentar, quedara como sigue:
70
Con esta nueva aplicacin, lo que haremos es, dados un nombre de bebedor y un nombre de
bar que frecuenta, a travs del botn Insertar registro sern agregados a la tabla
Frecuentan.
Para verificar que esto se haya llevado a cabo, bastar con pulsar en el botn Leer tabla
para actualizar la lista con el contenido.
71
Delete. Crea una consulta de eliminacin que elimina los registros de una o ms de las
tablas listadas en la clusula FROM que satisfagan la clusula WHERE. Esta consulta
elimina los registros completos, no es posible eliminar el contenido de algn campo en
concreto. Su sintaxis es:
DELETE FROM Tabla WHERE criterio
Una vez que se han eliminado los registros utilizando una consulta de borrado, no puede
deshacer la operacin. Si desea saber qu registros se eliminarn, primero examine los
resultados de una consulta de seleccin que utilice el mismo criterio y despus ejecute la
consulta de borrado.
El objetivo es que dado el nombre de un bebedor, procedamos a eliminar todos sus registros
y verifiquemos la accin mediante el botn Leer tabla.