ACTIVIDADES DE LAS PRÁCTICAS

PRACTICA 1 Y 2
1. Se realizan juntas, por lo que no hay actividades adicionales.

PRACTICA 3
1. Añadir un botón que haga un reset del contador (puesta a 0). También se puede
hacer un evento al hacer clic en la propia Label que muestra la cuenta.
2. Añadir un RadioGroup para seleccionar que la cuenta sea ascendente o
descendente. Usar propiedad Items para añadir las opciones. Se puede consultar el
valor de ItemIndex dentro de la función Reloj.

If (RadioGroup1->ItemIndex == 0) { // Ascendente, sino

descendente

3. Añadir un Edit para introducir el valor Final del contador. No hace falta programar
aquí ningún evento.
4. En la función Reloj, programar que cuando llegue al valor final, pare el contador, lo
ponga a 0, ponga color azul a la Shape1 y muestre un mensaje en un nuevo Label
(Label2)

Shape1->Brush->Color = clBlue;

5. Añadir un ScrollBar1 (barra Standard) o TrackBar1 (barra Win32) para establecer el

periodo del Timer, desde 100 (mS) a 1000 (mS). Establecer en el Object-Inspector
las propiedades: Max = 1000 y Min = 100. En el evento del ScrollBar1, actualizar el
valor de Timer:

Timer1Timer->???? = TrackBar1->Position;
PRACTICA 4
1. Añadir al proyecto un nuevo formulario, llamado Form2; de momento no contiene
nada.
2. En el formulario principal, crear un botón llamado “Abrir Form 2”, en su evento clic
hacer una llamada para abrir el formulario 2:

Form2->Show();

Para poder usar el formulario 2 desde el principal, deberemos poner un #include

“Unit2.h”. Ejecutar y comprobar que se puede hacer clic de nuevo en el formulario
principal sin cerrar el formulario 2, y probar cerrar uno y otro en distinto orden.
3. En el Form2, añadir un botón “Cerrar”, para cerrar el Form2 con este método del
propio objeto Form:

Form2->Close(); // o bien solo Close(); ya que estamos

dentro del Unit2, que corresponde a Form2

4. Cambiar la llamada Form2->Show(); por Form2->ShowModal(); Comprobar el

funcionamiento, ¿qué diferencia observas? Intenta hacer clic en el formulario 1 sin
cerrar el formulario 2. Volver a dejarlo en Show().
Además del método Close(), existe también Hide(), que solo oculta el formulario,
pero sigue existiendo en "memoria".
5. Añadir un menú en el formulario principal, con una opción que se llame “salir”, y
en su evento programar la función:
Close(); // en este caso cerraremos el Form1 y por tanto
toda la aplicación, que incluye todos los forms
PRACTICA 5

1. Cambiar nombre actual del TaskHandle, por TaskDigitalInputs, ya que usaremos las
tareas para varias entradas digitales.
2. Añadir las funciones para leer del bit2 una nueva entrada digital: OverHeat
3. Introducir el nombre de la tarjeta en tiempo de ejecución. Que podamos poner que
es Dev1, o Dev2, con el programa ejecutándose, antes de iniciar la tarjeta. Para ello
podemos añadir un Edit, y recuperar su contenido con EditN->Text
4. Cambiar periodo de muestreo en tiempo de ejecución, para ello añadir otro Edit, y
programar el evento “OnExit” para que el tiempo que se escriba se asigne a
Timer1->Interval.
5. Se puede iniciar la tarjeta automáticamente cuando se muestra el Form,
escribiendo en el evento OnShow del Form, pero para ello tenemos que tener un
valor por defecto en el Edit donde está el nombre de la tarjeta. También se puede
usar el evento OnClose, para hacer tareas como borrar la tarea DAQmxClearTask
PRACTICA 6

1. Añadir una segunda salida digital, para tener dos en total: válvula (valve) y
calefactor (heater). Usar la misma tarea y canal. Solo hay que crear una nueva
función process_write_heater(), igual a la process_write_valve() donde solo cambia
la máscara que usamos para actualizar mirror_DO, lo demás es todo igual. Poner
también el prototipo en process.h.
OPCIONAL: Si tuviéramos muchas más salidas digitales, optimizar el código
separando en funciones la parte de cálculo de máscara y la parte de funciones de la
tarjeta:

void process_write_heater(int state)

{ // ambas funciones usan mirror_DO como variable global
process_apply_mask(HEATER_MASK, state);
process_write_card();
}

2. Combinar con la práctica de entrada digital, para tener en total dos entradas
(pulsadores) y dos salidas digitales. Solo tenemos un archivo process.h, con una
función process_init() donde hay que crear las dos tareas (sensors_task y
actuator_task) y dos canales (uno DI y otro DO).
3. En el timer de 500mS se muestrean (leen) ambos sensores, y en caso de estar
activos (OVERHEAT_YES, o OVERFLOW_YES), mostrar un label de alarma indicando
si hay OVERFLOW o OVERHEAT
4. Si en el paso anterior se detecta sobrecalentamiento, llamar a la función de la
tarjeta para apagar el calefactor.
5. Igual que el anterior pero controlando el sensor de OVERFLOW y en caso
producirse, cerrar la válvula.
PRACTICA 7

1. En Poliformat/Recursos/7 Material Adicional/Codigo/IO_Error.cpp, tenemos una

función mejor para procesar los errores de las funciones de la tarjeta. Se propone
que se use la función IO_Test( DAQmx…(parametros), __LINE__);, en lugar de
process_error(), por lo que podemos prescindir de la variable daq_error
y del if, quedando más breve el código.

Esta es la function:
#include <stdio.h>
//---------------------------------------------------------------------------
void IO_Test(int error_code, int line){
char message[2000], buffer[1000];
if(error_code != 0){
DAQmxGetErrorString(error_code, buffer, 1000);
sprintf(message,"NiDAQmx Error\nLine: %d\nReason: %s\n", line, buffer);
ShowMessage(message);
exit(1);
}
}

Y el codigo actual asi:

int32 daq_error;
daq_error = DAQmxCreateTask("temperature_sensor_task",&temperature_sensor_task);
if (daq_error != 0)
process_error(daq_error,"process_init()->temperature_1");

Pasa a:

IO_Test( DAQmxCreateTask("temperature_sensor_task",&temperature_sensor_task),
__LINE__ );

2. Utilizar un ScrollBar para establecer una temperatura de alarma (leemos su

posición con ScrollBar1->Position, de modo que el programa por medio del Timer
compare el nivel real con el nivel de alarma, y de un aviso en caso de superar este
nivel por medio de un semáforo (Shape redondo)
3. Añadir una salida analógica AO0, y en la tarjeta podemos conectar con un cable
esta salida con la entrada analógica AI3, de modo que la salida analógica se puede
leer en la entrada. Esta actividad implica modificar process_init, para crear 2
nuevas tareas y 2 nuevos canales para AO0 y AI3. La función del Timer es la
encargada de llamar a process_analogOutput() para escribir en el AO0 la posición
de otro Scrollbar, y leer de AI3 por medio de una función process_analogInput() y
presentar el valor leído en un nuevo Label.