PBStoCondor Results - Developing a trusted computational grid

/******************************************************************************

IRQ7_4.CPP: (Emplea la interrupción IRQ7 para leer el ADC)

Este programa muestrea a intervalos de 2 seg. un voltaje analógico (0V-5V) de un

potenciómetro y lo imprime en la pantalla, además envía el dato en binario al

PortA (puede ser B o C) del PPI para que se vea en los 8 leds.

El retardo de DOS segundos se genera llamando a la función delay.

El programa termina cuando se pulse ESC(escape)

Descripción:

a) Implemente un circuito con un potenciómetro entre 0 y 5V.

b) El punto central de éste conéctelo al terminal (VI+) de la bornera azul o al

molex.

c) El terminal VI-, conéctelo a tierra.

d) El terminal AGND conéctelo a tierra.

e) El terminal VREF puede conectarse a otro potenciómetro con un voltaje de

salida aproximado de 2.5 voltios. Con esto se consigue mayor exactitud en la

toma de muestras.

f) Cargue el programa Turbo C++ 3.0 y abra el programa ADC_5, luego compile con

ALT+F9, y ejecute el programa con CTRL+F9.

Autor: Ing. Javier Barriga Hoyle

******************************************************************************/

#include

#include <dos.h> <dos.h> // Librería DOS para el Turbo C++// Librería DOS para el Turbo C++

#include

#include <conio.h> <conio.h> #include

#include <stdio.h> <stdio.h> #include

#include "BymDOS.h" "BymDOS.h" // Librería para la tarjeta LPT V2.0// Librería para la tarjeta LPT V2.0

int

int Base = 0x378; Base = 0x378; // Dirección base del puerto paralelo// Dirección base del puerto paralelo

#ifdef

#ifdef __cplusplus __cplusplus #define

#define __CPPARGS ... __CPPARGS ... #else

#else

#define

#define __CPPARGS __CPPARGS #endif

#endif

/* Prototipos */

void

void interrupt (*old_adc)(...); interrupt (*old_adc)(...); // Vector antiguo// Vector antiguo

void

void interrupt new_adc(...); interrupt new_adc(...); // Nueva RSI// Nueva RSI

void

void instala_imr_vector( instala_imr_vector(voidvoid);); void

void restaura_imr_vector( restaura_imr_vector(voidvoid);); /* Variables globales */

/* Variables globales */

unsigned

unsigned charchar oldimr, newimr, datolisto, car, dato_adc; oldimr, newimr, datolisto, car, dato_adc; int

int muestras, Fin; muestras, Fin; float

float voltios; voltios; void

void main( main(voidvoid)) {

{

clrscr();

clrscr(); // Borra pantalla// Borra pantalla

inicio_tarjeta();

inicio_tarjeta(); // Inicializa tarjeta de interfase LPT V2.0// Inicializa tarjeta de interfase LPT V2.0

xout(0x7B,0x80);

xout(0x7B,0x80); // Configura PPI como PA = PB = PC = outs// Configura PPI como PA = PB = PC = outs

instala_imr_vector();

instala_imr_vector(); // Modifica IMR e instala vector de IRQ7// Modifica IMR e instala vector de IRQ7

/* Habilita la IRQ_EN del puerto paralelo, poniendo en UNO el bit 4 del puerto

0x37A (base+2) */

outportb(0x37A, inportb(0x37A) | 0x10);

outportb(0x37A, inportb(0x37A) | 0x10); // IRQ_EN = 1// IRQ_EN = 1

printf("\n"); printf("\n");

printf("\t*********************************************************\n"); printf("\t*********************************************************\n"); printf("\t*

printf("\t* PROGRAMA QPROGRAMA QUE CAPTURA UE CAPTURA SEÑALES SEÑALES ANALOGICAS ANALOGICAS PROVENIENTES PROVENIENTES *\n");*\n"); printf("\t*

printf("\t* DE DE UN UN POTENCIOMETRO, POTENCIOMETRO, USANDO USANDO LA LA INTERRUPCION INTERRUPCION IRQ7 IRQ7 *\n");*\n");

printf("\t* *\n");

printf("\t*

printf("\t* El El valor valor obtenido obtenido se se envía envía a a la la pantalla pantalla y y al al PortA PortA *\n");*\n"); printf("\t*

printf("\t* del del PPI. PPI. Las Las muestras muestras se se realizan realizan cada cada 2 2 segundos. segundos. *\n");*\n"); printf("\t*

printf("\t* Para Para salir salir del del programa, programa, pulse pulse ESC(escape). ESC(escape). *\n");*\n"); printf("\t*********************************************************\n\n"); printf("\t*********************************************************\n\n"); Fin = 0;

muestras = 0; muestras = 0; while

while(!Fin)(!Fin) // El programa termina cuando se pulse ESC// El programa termina cuando se pulse ESC

{ {

xout(0x6C, 0x00);

xout(0x6C, 0x00); // Inicia conversión del ADC// Inicia conversión del ADC

if(datolisto == 1)(datolisto == 1) // ¿Terminó conversión INT = 0?// ¿Terminó conversión INT = 0?

{ {

dato_adc = xin(0x6C);

dato_adc = xin(0x6C); // SI, procede a leerse el dato// SI, procede a leerse el dato

xout(0x78, dato_adc);

xout(0x78, dato_adc); // Envía dato leído al PortA del PPI// Envía dato leído al PortA del PPI

voltios = (

voltios = (floatfloat)dato_adc * 5 / 255;)dato_adc * 5 / 255; // Convierte a flotante// Convierte a flotante

gotoxy(22,12); gotoxy(22,12);

printf("lectura ADC(%d) = %0.4f voltios",muestras,voltios);

printf("lectura ADC(%d) = %0.4f voltios",muestras,voltios); //4 decimales//4 decimales

datolisto = 0;

datolisto = 0; // Borra flag para otra interrupción// Borra flag para otra interrupción

delay(2000);

delay(2000); // Retardo de 2 segundos// Retardo de 2 segundos

if(kbhit())(kbhit()) // ¿Se activó alguna tecla?// ¿Se activó alguna tecla?

{ {

car = getch();

car = getch(); // SI, entonces se lee la tecla y si es ESC// SI, entonces se lee la tecla y si es ESC

if(car == 27) Fin=1;(car == 27) Fin=1; // salir del programa// salir del programa

} } } } } } restaura_imr_vector();

restaura_imr_vector(); /* Termina el programa, recupera la máscara/* Termina el programa, recupera la máscara

y el vector original */

}

} // Fin de main// Fin de main

void

void interrupt new_adc(...) interrupt new_adc(...) // Rutina de servicio de interrupción// Rutina de servicio de interrupción

{ {

old_adc();

old_adc(); // Llama al vector original// Llama al vector original

datolisto = 1;

datolisto = 1; // Flag, indica que se activó interrupción// Flag, indica que se activó interrupción

muestras++;

muestras++; // Incrementa número de muestras// Incrementa número de muestras

outportb(0x20,0x20);

outportb(0x20,0x20); // Envía el EOI// Envía el EOI

} } void

void instala_imr_vector( instala_imr_vector(voidvoid)) {

{

disable();

disable(); // Deshabilita interrupciones// Deshabilita interrupciones

oldimr = inportb(0x21);

oldimr = inportb(0x21); // Lee la máscara IMR// Lee la máscara IMR

newimr = 0x7F & oldimr;

newimr = 0x7F & oldimr; // Activa IRQ7 = 0111 1111// Activa IRQ7 = 0111 1111

outportb(0x21,newimr);

outportb(0x21,newimr); // Envía nueva IMR al PIC// Envía nueva IMR al PIC

old_adc = getvect(0x0F);

old_adc = getvect(0x0F); // Lee vector original// Lee vector original

setvect(0x0F,new_adc);

setvect(0x0F,new_adc); // Instala nuevo vector// Instala nuevo vector

enable();

enable(); // Habilita interrupciones// Habilita interrupciones

} } void

void restaura_imr_vector( restaura_imr_vector(voidvoid)) {

{

disable();

disable(); // Deshabilita interrupciones// Deshabilita interrupciones

setvect(0x0F,old_adc);

setvect(0x0F,old_adc); // Restaura vector original// Restaura vector original

outportb(0x21,oldimr);

outportb(0x21,oldimr); // Restaura IMR original// Restaura IMR original

enable();

enable(); // Habilita interrupciones// Habilita interrupciones

} }

Programa 13.8

Programa 13.8::

(IRQ7_5.CPP) Uso de las interrupciones IRQ7 (ADC) e IRQ0 (TIMER de la (IRQ7_5.CPP) Uso de las interrupciones IRQ7 (ADC) e IRQ0 (TIMER de la PC).PC).

Utilice el circuito

Utilice el circuito del programa IRQ7_4.CPPdel programa IRQ7_4.CPP

/******************************************************************************

IRQ7_5.CPP: (Emplea las interrupciones IRQ0 y IRQ7)

Este programa muestrea a intervalos de 1 seg. un voltaje analógico (0V-5V) de un

potenciómetro y lo imprime en la pantalla, además envía el dato en binario al

PortA (puede ser B o C) del PPI para que se vea en los 8 leds.

El retardo de 1 segundo se genera programando la interrupción IRQ0.

La línea INTR del ADC se conecta a la interrupción IRQ7.

El programa termina cuando se pulse ESC(escape).

Descripción:

a) Implemente un circuito con un potenciómetro entre 0 y 5V.

b) El punto central de éste conéctelo al terminal (VI+) de la bornera azul o al

molex;

c) El terminal VI-, conéctelo a tierra.

d) El terminal AGND conéctelo a tierra.

e) El terminal VREF puede conectarse a otro potenciómetro con un voltaje de

salida aproximado de 2.5 voltios. Con esto se consigue mayor exactitud en la

toma de muestras.

Autor: Ing. Javier Barriga Hoyle

******************************************************************************/

##include

##include <dos.h> <dos.h> // Librería DOS para el Turbo C++// Librería DOS para el Turbo C++

#include

#include <conio.h> <conio.h> #include

#include <stdio.h> <stdio.h> #include

#include "BymDOS.h" "BymDOS.h" // Librería para la tarjeta LPT V2.0// Librería para la tarjeta LPT V2.0

int

int Base = 0x378; Base = 0x378; // Dirección base del puerto paralelo// Dirección base del puerto paralelo

#ifdef

#ifdef __cplusplus __cplusplus #define

#define __CPPARGS ... __CPPARGS ... #else

#else

#define

#define __CPPARGS __CPPARGS #endif

#endif

/* Prototipos */

void

void interrupt (*old_adc)(...); interrupt (*old_adc)(...); // Vector antiguo IRQ7// Vector antiguo IRQ7

void

void interrupt new_adc(...); interrupt new_adc(...); // Nueva RSI// Nueva RSI

void

void interrupt (*old_timer)(...); interrupt (*old_timer)(...); // Vector antiguo IRQ0// Vector antiguo IRQ0

void

void interrupt new_timer(...); interrupt new_timer(...); // Nueva RSI// Nueva RSI

void

void instala_imr_vector( instala_imr_vector(voidvoid);); void

void restaura_imr_vector( restaura_imr_vector(voidvoid);); /* Variables globales */

/* Variables globales */

unsigned

unsigned charchar oldimr, newimr, datolisto, car, dato_adc; oldimr, newimr, datolisto, car, dato_adc; int

int Fin, num_int, muestras; Fin, num_int, muestras; float

float voltios; voltios; void

void main( main(voidvoid)) // Inicia programa principal// Inicia programa principal

{ {

clrscr();

clrscr(); // Borra pantalla// Borra pantalla

inicio_tarjeta();

inicio_tarjeta(); // Inicializa tarjeta de interfase LPT V2.0// Inicializa tarjeta de interfase LPT V2.0

instala_imr_vector();

instala_imr_vector(); // Modifica IMR e instala el vector de IRQ7// Modifica IMR e instala el vector de IRQ7

xout(0x7B,0x80);

xout(0x7B,0x80); // Configura PPI como PA = PB = PC = out// Configura PPI como PA = PB = PC = out

/* Habilita la IRQ_EN del puerto paralelo, poniendo en UNO el bit 4 del puerto

0x37A (base+2) */

outportb(0x37A, inportb(0x37A) | 0x10);

outportb(0x37A, inportb(0x37A) | 0x10); // IRQ_EN = 1// IRQ_EN = 1

printf("\n"); printf("\n");

printf("\t*********************************************************\n"); printf("\t*********************************************************\n"); printf("\t*

printf("\t* PROGRAMA PROGRAMA QUE CAPTURA QUE CAPTURA SEÑALES SEÑALES ANALOGICAS ANALOGICAS PROVENIENTES PROVENIENTES *\n");*\n"); printf("\t* DE UN POTENCIOMETRO, USANDO LAS INTERRUPCIONES IRQ0-7 *\n"); printf("\t* DE UN POTENCIOMETRO, USANDO LAS INTERRUPCIONES IRQ0-7 *\n");

printf("\t* *\n");

printf("\t* El valor obtenido se envía a la pantalla y al PortA *\n"); printf("\t* del PPI. Las muestras se realizan cada 1 segundo. *\n"); printf("\t* Para salir del programa, pulse ESC(escape). *\n"); printf("\t*********************************************************\n\n");

muestras = 0; // Inicia contador de muestras en cero

num_int = 0; // Inicia Contador de interrupciones a cero

Fin = 0; // Flag de fin

xout(0x6C, 0x00); // Inicia conversión del ADC en t = 0 seg

while(!Fin) // Programa continua hasta que se pulse ESC

{

if(datolisto == 1) // ¿Terminó conversión INTR = 0?

{

dato_adc = xin(0x6C); // SI, procede a leerse el dato

xout(0x78, dato_adc); // Envía dato leído al PortA del PPI

voltios = (float)dato_adc * 5 / 255; // Convierte a flotante gotoxy(22,12);

printf("lectura ADC(%d) = %0.4f voltios",muestras,voltios); //4 decimales

datolisto = 0; // Borra flag para otra interrupción

if(kbhit()) // ¿Se activó alguna tecla?

{

car = getch(); // SI, entonces se lee la tecla

if(car == 27) Fin=1; // Salir del programa

} } }

restaura_imr_vector(); /* Termina el programa, recupera la mascara

y el vector original */ } // Fin de main

void interrupt new_timer(...) // Rutina de servicio de interrupción {

old_timer(); // Llama al vector original

num_int++; // Incrementa número de interrupciones

if(num_int == 18) // ¿Pasó 1 segundo?

{

num_int = 0; // Reinicia contador de interrupciones

xout(0x6C, 0x00); // Inicia conversión del ADC

muestras++; // Incrementa número de muestras

}

outportb(0x20,0x20); // Envía el EOI

}

void interrupt new_adc(...) // Rutina de servicio de interrupción

{

old_adc(); // Llama al vector original

datolisto = 1; // Flag que indica que termino conversión

outportb(0x20,0x20); // Envía el EOI

}

void instala_imr_vector(void) {

disable(); // Deshabilita interrupciones

oldimr = inportb(0x21); // Lee la máscara IMR

newimr = oldimr & 0x7E; // Activa IRQ7 e IRQ0 (0111 1110)

outportb(0x21,newimr); // Envía nueva IMR al PIC

old_timer = getvect(0x08); // Lee vector 8 original

setvect(0x08,new_timer); // Instala nuevo vector

old_adc = getvect(0x0F); // Lee vector 15 original

setvect(0x0F,new_adc); // Instala nuevo vector

enable(); // Habilita interrupciones

}

void restaura_imr_vector(void) {

disable(); // Deshabilita interrupciones

setvect(0x08,old_timer); // Restaura vector 8 original

setvect(0x0F,old_adc); // Restaura vector 15 original

outportb(0x21,oldimr); // Restaura IMR original

enable(); // Habilita interrupciones

}

Programa 13.9:

(IRQ7_6.CPP) Uso de las interrupciones IRQ7 (ADC) e IRQ0 (TIMER de la PC).

Los datos muestreados serán almacenados en un archivo “muestreo.txt”. Utilice el circuito del

programa IRQ7_4.CPP

/****************************************************************************** IRQ7_6.CPP: (Emplea las interrupciones IRQ0 y IRQ7)

Este programa muestrea a intervalos de 1/2 seg un voltaje analógico (0V-5V) de un potenciómetro y lo imprime en la pantalla, además envía el dato en binario al PORT A (puede ser B o C) del PPI para que se vea en los 8 leds.

El retardo de 1/2 segundo se genera programando la interrupción IRQ0. La línea INT del ADC se conecta a la interrupción IRQ7.

El programa termina cuando se alcance las 200 muestras. Los datos se almacenan en el archivo “muestreo.txt”.

Descripción:

a) Implemente un circuito con un potenciómetro entre 0 y 5V.

b) El punto central de éste conéctelo al terminal (VI+) de la bornera azul o al molex;

c) El terminal VI-, conéctelo a tierra. d) El terminal AGND conéctelo a tierra.

e) El terminal VREF puede conectarse a otro potenciómetro con un voltaje de

salida aproximado de 2.5 voltios. Con esto se consigue mayor exactitud en la toma de muestras.

Autor: Ing. Javier Barriga Hoyle

******************************************************************************/

#include <dos.h> // Librería DOS para el Turbo C++

#include <conio.h> #include <stdio.h>

#include "BymDOS.h" // Librería para la tarjeta LPT V2.0

int Base = 0x378; // Dirección base del puerto paralelo

#ifdef __cplusplus #define __CPPARGS ... #else #define __CPPARGS #endif /* Prototipos */

void interrupt (*old_adc)(...); // Vector antiguo IRQ7

void interrupt new_adc(...); // Nueva RSI

void interrupt (*old_timer) (...); // Vector antiguo IRQ0

void interrupt new_timer(...); // Nueva RSI

void instala_imr_vector(void); void restaura_imr_vector(void);

/* Declaración de variables globales */

unsigned char oldimr, newimr, datolisto, car, dato_adc; int Fin, num_int, muestras;

float voltios;

void main(void) // Inicia programa principal

{

FILE *archivo;

clrscr(); // Borra pantalla

inicio_tarjeta(); // Inicializa tarjeta LPT V2.0

printf("\n");

printf("\t**********************************************************\n"); printf("\t* PROGRAMA QUE CAPTURA SEÑALES ANALOGICAS PROVENIENTES *\n"); printf("\t* DE UN POTENCIOMETRO, USANDO LAS INTERRUPCIONES IRQ0-7 *\n");

printf("\t* *\n");

printf("\t* El valor obtenido se envia a la pantalla y al PortA *\n"); printf("\t* del PPI. Ademas, cada muestra se guarda en un archivo. *\n”);

printf(“\t* Las muestras se realizan cada 1/2 segundo. *\n");

printf("\t* El programa termina cuando se pulse ESC(escape) o *\n");

printf("\t* cuando se alcance las 200 muestras. *\n");

printf("\t**********************************************************\n\n");

instala_imr_vector(); // Modifica IMR e instala el vector de IRQ7

/* Habilita la IRQ_EN del puerto paralelo, poniendo en UNO el bit 4 del puerto 0x37A (base+2) */

outportb(0x37A, inportb(0x37A) | 0x10); // IRQ_EN = 1

muestras = 0; // Inicia contador de muestras en cero

num_int = 0; // Inicia Contador de interrupciones a cero

Fin = 0; // Flag de fin

archivo = fopen("d:\\tc\\destino\\muestreo.txt","w+"); // Crea archivo

xout(0x6C,0x00); // Inicia conversión del ADC en t = 0

while(muestras <= 200) /* Programa continúa hasta que se pulse ESC ó cuando se alcance 200 muestras */ {

if(datolisto == 1) // ¿Terminó conversión INTR = 0?

{

dato_adc = xin(0x6C); // SI, procede a leerse el dato

xout(0x78, dato_adc); // Envía dato leído al PortA del PPI

voltios = (float)dato_adc * 5 / 255; // Convierte a flotante

fprintf(archivo,"%f\n",voltios); // Almacena dato en el archivo gotoxy(22,12);

printf("lectura ADC(%d) = %0.4f voltios",muestras,voltios); //4 decimales

datolisto = 0; // Borra flag para otra interrupción

if(kbhit()) // ¿Se activó alguna tecla?

{

car = getch(); // SI, entonces se lee la tecla

if(car == 27) Fin=1; // Salir del programa

} } }

fclose(archivo); // Cierra archivo “muestreo.txt”

restaura_imr_vector(); /* Termina el programa, recupera la mascara

y el vector original */ } // Fin de main

void interrupt new_timer(...) // Rutina de servicio de interrupción {

old_timer(); // Llama al vector original

num_int++; // Incrementa número de interrupciones

if(num_int == 9){ // ¿Pasó 1/2 segundo?

num_int = 0; // SI, reinicio contador de interrupciones

xout(0x6C,0x00); // Captura dato del ADC e inicia conversión

muestras++; // Incrementa número de muestras

}

outportb(0x20,0x20); // Envía el EOI

}

void interrupt new_adc(...) // Rutina de servicio de interrupción

{

old_adc(); // Llama al vector original

datolisto = 1; // Flag que indica que termino conversión

outportb(0x20,0x20); // Envía el EOI

void instala_imr_vector(void) {

disable(); // Deshabilita interrupciones

oldimr = inportb(0x21); // Lee la máscara IMR

newimr = oldimr & 0x7E; // Activa IRQ7 e IRQ0 (0111 1110)

outportb(0x21,newimr); // Envía nueva IMR al PIC

old_timer = getvect(0x08); // Lee vector 8 original

setvect(0x08,new_timer); // Instala nuevo vector

old_adc = getvect(0x0F); // Lee vector 15 original

setvect(0x0F,new_adc); // Instala nuevo vector

enable(); // Habilita interrupciones

}

void restaura_imr_vector(void) {

disable(); // Deshabilita interrupciones

setvect(0x08,old_timer); // Restaura vector 8 original

setvect(0x0F,old_adc); // Restaura vector 15 original

outportb(0x21,oldimr); // Restaura IMR original

enable(); // Habilita interrupciones

14. Aplicaciones del DAC 0830

Programa 14.1: (DAC_1.CPP) Programa de prueba del DAC. Se le envía datos binarios para

obtener voltajes de salida entre 0V hasta +5V. Realice la siguiente conexión.

ADC0804 L P T D B 2 5 DAC0830 P P I 8 2 C 5 5 TIMER 82C54 _P A P B P C G 2 G 1 C L K 2 C L K 1 O U T 2 O U T 1 G 2 G 1 C L K 2 C L K 1 V I + V I - V R E F A G N D V R E F A G N D R F B O U T 2 O U T 1 IRQ7 LIBRE ADC J10 3 2 1 + 5 V G N D 8 MHZ Power E/S Timer SW Timer + - + - +5V 3 2 10K 10K Inversor +V -V

El esquemático completo puede verlo en la figura E8, del apéndice E.

LM741

In document Developing a trusted computational grid (Page 89-110)