Aquesta placa té un funcionament relativament senzill, la poden utilitzar per possar coses en marxa amb l'ordinador, amb unes petites nocions d'informatica i programació.

Del que es tracta, es de gestionar el port paralel del teu ordinador amb un petit programa per poder activar o desactivar un número determinat de sortides.

La meva placa, te la posibilitat d'obtenir 64 sortides controlades, només amb 8 bits de dades i 3 de control, tenim una placa base, on hi ha la font d'alimentació, els indicadors de les sortides que hi han activades, un conector de 25 pins per la comunicació amb l'ordinador i 8 conectors per les plaques de sortides, on totes les plaques de sortides son identiques i totalment personalitzables, vull dir que es poden possar en qualsevol conector de la placa base. Cada placa de sortides té 8 sortides (8 interuptors oberts, que s'obren o es tanquen) i tenim 8 plaques, doncs el que te que fer el programa es, primer de tot, estriar per la placa que volem sortir, i despres activar les sortides que volguen activar i retenir-les fins activar la següent seqüencia de sortides.

Teoría

Primer i avanç d'entrar en materia practica, hem de coneixer quatre components del nostre treball, tals com el port paralel, comparadors, demultiplexors, memóries, decoders, etc...

El port paralel, un normalment en cada ordinador, encara que hi ha ordinadors que poden tenir fins a tres ports paralels, amb conectors de 25 pins, dels quals només 18 s'utilitzen per transportar dades, la resta son mases, per protegir les dades d'interferencies parasites; el port paralel es divideix en tres registres, el de dades, el de estat i el de control, dels quals només podem modificar dos al nostre gust.

El registre d'estat només es pot llegir, no podem escriure, i van desde la S3 a la S7, que son el pins 15, 13, 12, 10, 11 respectivament.
El registre de dades es de tipus latch de lectura i d'escritura, que son els 8 bits de dades, de la D0 a la D7, que corresponen als pins del 2 al 9 respectivament.
El registre de control pot ser bidireccional (depenen de la placa), son 4 bits que s'anomenen C0 fins a C3, que correponen als pins 1, 14, 16 i 17 respectivament, del cuals C0, C1 i C3 les senyal que surten, surten invertides.
La resta de potes, de 18 a la 25, totes van conectades a masa.

Els comparadors, com el seu nom indica, la seva funció es comparar, te entrada per dues paraules de quatre bits, y tres sortides A>B, A<B i A=B, que s'activen segons les dues paraules, si son iguals o no; per comparar les dues paraules, es comença pels bits de major pes de les dues paraules i es comparen, si son iguals es continua pel bit següent de menor pes, i així fins el final, activan la sortida A=B, si no son iguals, deixa de comparar i activa la sortida que li correspongui, A>B o A<B. També tenen tres entrades més per poder montar-los en serie, quan la paraula a comparar fos més gran de quatre bits.

Els demultiplexors, son uns dispositius per comandar dades o per decodificar-les, tenim, en el cas del SN74154N, quatre entrades de dades, dos entrades d'estrobe i setze sortides, amb les quatre entrades de dades direccionem la sortida que volem, si en aquesta entrada posem 0010, s'activarà la sortida número dos, si posem 1100, activem la sortida 12 i així amb totes les combinacions de 0 al 15, despres les entrades d'estrobe que activa o desactiva tot l'integrat, o el deixa inhibit, com es vulgui dir.

Es poden aconseguir combinacions amb mes sortides, només amb un bit més de dades, i jugan amb els estrobe o enables, i alguna porta lògica, com un inversor.

Els multiplexors, es exactament el mateix que el demultiplexor però al inrevés, tenim moltes entrades, una sortida i unes entrades de control, per els bits de control, seleccionem la entrada que volem posar a la sortida, per exemple, si el control es 0011, a la sortida tindriem el valor de entrada número tres, ja fos un 0 o un 1, igualment tenim unes entrades d'estrobe o enable per deshabilitar el component, o per fer les conbinacions per aconseguir més entrades, només amb un o dos més de control, encara que fan falta més portes lògiques que l'apartat anterior. Aquest dos components, el multiplexors i els demultiplexors, s'utilitzen o son utils per transportar dades, ja que primer es codifiquen, i despres en descodifiquen, amb aixó aconseguim transportar un número important de dades només amb quatre o cinc fils, quan es tindrien que transportar per trenta-dos fils o més.

Les memòries o Latch's, son un dispositius per enmagatzemar dades de forma temporal, tenim un número d'entrades igual al número de sortides, i unes potes de control. Nosaltre posem una senyal a la entrada, li donem pas cap a la sortida amb el bits de control, i ja tenim la senyal d'entrada a la sortida, i aquesta queda retenida i no es modifica encara que cambii la senyal d'entrada, fins que no tornem a donar pas amb els bits de control. Per aconseguir un número major d'entrades i sortides basta amb ajuntar dos o més Latchos i juntar totes les potes de control.

Els decodificadors/excitadors de set segments, com el seu nom indica, decodifica una senyal d'entrada, i excita unes sortides per activar un visualitzador de set segment o display. Te quatre entrades, A, B, C i D que correspondrien a E0, E1, E2 i E3 respectivament, on E3 es el bit de major pes i E0 el de menor pes. Les sortides son set, a b, c, d, e, f i g, on cada una d'aquestas sortidas correspondria a un segment del display. També té la opció de una entrada LT (Test Lamp), per comprovar, l'estat de tots els segments, també te una entrada RBI i una sortida RBO, que son per evitar que s'encengui cap número quan no hi ha senyal d'entrada i per avisar, si estigues conectac en cascada amb un altre, que ell no tenia cap numéro a la sortida.Els displays solen tenir aquestes set entrades, una mes que es el punt ( p) i una o dues comunes a totes les entrades, que tant pot ser de cátode com d'ánode comú( - o + ).

Com funciona

El treball, està dividit en dues parts, la placa base i les buit plaques de sortides. A la placa base estarà la font d'alimentació, i tots el indicadors lluminosos, com el de les sortides activades, i a quina placa estan activades. A les plaques de sortides, hi haurà una petita estabilització, un switch per identificar cada placa i els reles que activaran les sortides corresponents, amb un indicador d'estat cada relé. Totes les plaques de sortida son identiques.

Primer de tot, hem de pasar de 220 V a 5 V, que es l'alimentació que utilitzan tots el components del nostre circuit, ja que tots el circuits integrats, reles, visualitzadors, etc.. els em buscat per que treballin a 5 V. Per aixó fem servir un petit transformador que pasa de 220 a 9 volts, els quals tenim que rectificar amb un pont de diodes y filtrar amb un condensador electrolític. Ara ja tenim uns 11 volts cuasi filtrats del tot, només queda estabilitzar-los amb un 7805, i amb els seus corresponents condensadors antiparasits, i un petit condensador electrolític a la sortida. Aquests 11 V els utilitzarem per alimentar a totes les plaques de sortides ( no utilitzem els 5 volt, per posibles perdues d'alimentació ).

Ara, a la placa base, tenim un connector de 25 pins (el del port paralel), per on vindran unes dades, les 8 sortides, tres de direccionament i una de gravació de memòria, tots aquests pins els portem directament als conectors de 18 pins, on aniran les plaques de sortides. Els tres bits de direccionament, del quals dos surten negats del ordinador i els tenim que invertir previament amb un 7404 per no tenir problemes, els posem a l'entrada d'un 7447, on l'entrada de major pes l'hem conectat a masa, perque només hem de visualitzar un número de tres bits y a la sortida del 7447 un display de set segments d'anode comú, perque les sortides del decodificador/excitador son actives a nivell baix, aixó vol dir que surten 0 a les sortides actives. També tenim buit Leds, cada un amb la seva resistencia limitadora, per visualitzar le sortides actives.

La placa de sortida, es més complicada, tenim un conector IBM a la mateixa placa de 18 pins, per aquí venen totes les dades. De les tres de direccionament, dos venen negades, doncs les invertim, ara amb un 7402, que son portes NOR, ho fem així per estalviarnos components a la placa; aquests tres bits els posem a la part A d'un comparador, un 7485, a la part B, tenim conectat un switch de 4 conectat a masa i unes resistencies conectades a 5V, si un switch està conectat, al comparador tenim un 0, i si no està conectat, tenim un 1, perque la resistencia no condueix, i te la mateixa tensió a una pota que a l'altre. Així doncs, podem posar un nom a la nostra placa, i fins que no posem a la part A del comparador el mateix codi que a la part B, no treballarem en aquesta placa perque la sortida A=B del comparador no estarà activa.

També tenim dos Latchos de 4 bits, dos 7475, en total 8 bits, del 0 al 7, doncs el posem de manera que repartim els buit bits de dades entre els dos, de 0 al 3 en un i 4 al 7 en l'altre, aixó a les entrades, els bits de gravació del dos Latchos, els unim i el portem a la sortida d'un porta NOR, del 7402 d'avans, una de les entrades de la mateixa porta la conectem la sortida del comparador, però avans l'hem d'invertir amb un 7402, i l'altre entrada la portem directament del bit de gravació del conector IBM de 18 pins.

Les buit sortides dels dos Latchos, els 7475, les portem a uns inversors, un TD62083AP, que son buit inversor que aguanten mes intensitat que els tipics 7404, les sortides del inversors, ja estan preparades per activar els reles, que estan conectats directament una de les dos potes de la bobina a 5V, i l'altre a l'inversor; activen així els reles per no carregar el cosum dels reles a l'ordinador, així els reles entan alimentats per la nostra placa. A les potes d'alimentació del relé conectaren un diodes per protegir el nostre circuit de les descarregues inductives que produeix el relé al desconectar-se, també posarem un LED amb la seva resistencia limitadora, per indicar que el relé està actiu, i només queden les sortides, que es tan facil com portar el contactes dels reles a unes regletes per poder conectar el que volguem, sense passarnos del consum màxim que puguin aguantar els reles.

Tots els components estan alimentats per una petita font, que agafa el 11 V del conector i els estabilitza amb un 7805 amb els seus corresponents condensadors antiparasits, i un petit condensador electrolític a la sortida.

Components

TD62083AP

Este integrado está compuesto de ocho buffers inversores, que responden a la lógica
donde Y es la salida y A es la entrada.

7402

Este integrado está compuesto de cuatro puertas NOR de dos entradas, su lógica es tan sencilla como decir que
donde Y es la salida y A y B son las entradas, entonces la salida solo será 1 cuando las dos entradas sean 0.

7404

Este integrado está compuesto de seis buffers inversores, que responden a la lógica
donde Y es la salida y A es la entrada.

7447

Este integrado es un decodificador/excitador BCD a siete segmentos, este decoder posee cuatro entradas para introducir señales en BCD, las cuales transformas en un código que es posible leerlo con un display de siete segmentos, el cual puede ser de ánodo o de cátodo común, según las salidas del decoder, ya sean activas a nivel alto o bajo.

7475

Este integrado es un latch de 4 bits, que se utiliza como almacenamiento temporal de información binaria entre la entrada y la salida, su funcionamiento es muy sencillo, tenemos cuatro entradas, cuatro salidas y dos controles de grabación, ponemos una señal de entrada de cuatro bits, cuando accionemos el control la señal de la entrada pasa a la salida, aunque desconectemos el control y la señal de entrada, la salida se mantiene hasta que accionamos nuevamente el control de grabación, por eso se habla de una cierta memoria, porque se mantiene la señal un cierto tiempo.

7485

Este integrado es un comparador de dos palabras de cuatro bits, su funcionamiento es muy sencillo, tenemos una señal A en una de las entradas, y otra señal B en la otra entrada, el integrado compara las dos palabras y nos activa la salida correspondiente, según sea A más grande, más pequeña o igual a B. También ofrece la posibilidad de conectar dos comparadores en cascada, cuando tenemos que comparar más de cuatro bits, si solo queremos comparar cuatro bits, tenemos que poner las entradas A=B a 1, y A>B y A<B a 0, para poder compararlas.

Resistencies

Totes les resistencies limitadores dels Leds o dels Displays seràn de 470, i les del multiswitch, les calcularem perque tinguin un consum de 10mA,
on V son els 5V que hi hauran a la resistencia i I la intensitat que imponem, de 10mA. Així la resistencia serà també de 470.

LEDS i Diplays

Tots els Led seràn de 5mm, i vermells, menys el de les fonts d'alimentació que seràn verds. Els Display seràn d'anode comú, per facilitar el disseny i el muntatge.

Llista de components

Placa base:

C1 2200F Electrolitic

C4 220F Electrolitic

C2,C3 100F Ceramic

DYS1 HP317H+

PD1 Pont Rectificador 1500mA

D2,D3,D4,D5,D6,D7,D8,D9,D10 LED 5mm

J1,J3,J4,J5,J6,J7,J8,J9 Conector IBM 18 pins

J2 Conector Regleter de 2

P1 Conector DB25H Port paralel

R1,R2,R3,R4,R5,R6,R7,R8,

R9,R10,R11,R12,R13,R14,

R15,R16 470 ¼ W

T1 Tranformador CROVISA 20A69 12VA

U1 7404

U2 7447

U3 LM7805CT

Placa de sortides:

C2,C1 100F

D1....D9 LED 5mm

D10.....D18 1N4001

J1,J2,J3,J4,J5,J6,J7,J8 Conector regleter de 2

R1....R12 470 ¼ W

S1 Switch de 3 contactes

U1 7402

U2 7485

U3,U4 7475

U5 TD62083AP

U6 LM7805CT

K1....K8 Rele 5V ,un contacte obert

Esquema teòric de la placa base (tret directament de l'ORCAD ESP).

Esquema teòric de la placa de sortida (tret directament de l'ORCAD ESP).

Cada modul de sortida equival al dibuix de sota, tots els moduls son identics.

Esquema practic de la placa base (tret directament de l'ORCAD PCB).

Esquema practic de la placa de sortides (tret directament de l'ORCAD PCB).

Presentació del programa per controlar la placa pel port paralel.

Programa tret del Borland Turbo C++

#include <conio.h>

#include <stdio.h>

#include <stdlib.h>

#include <dos.h>

#include <graphics.h>

#include <sarda.h>

void inicio();

void final(void);

void presenta(void);

void ratoli(void);

void main()

{

inicio();

presenta();

final();

}

void inicio()

{

int driver,modo,codi_error;

clrscr();

driver=DETECT;

modo=0;

initgraph(&driver,&modo,"C:\\UTILES\\TC\\BGI");

codi_error = graphresult();

if (codi_error != grOk)

{

printf("Error gr…fico : %s\n", grapherrormsg(codi_error));

printf("Pulse una tecla para continuar.....");

getch();

exit(1);

}

void final()

{

closegraph();

clrscr();

printf("\n\t **** Gracias por utilizar esta aplicaci¢n. ****");

printf("\n\n\t\t\t\t¸ D.S.A.©\n\n\n\n\n\n\n\n\n");

printf("\n\n\n\n\n\n\n\n\n\n\t\t Pulse una tecla para finalizar...");

getch();

clrscr();

}

void presenta()

{

int n,i,a,b,c,d,boto_p[8][4]={a,b,c,d},boto_s[8][4]={a,b,c,d},salir[4]={a,b,c,d},enviar[4]={a,b,c,d};

int valor_s[8]={0,0,0,0,0,0,0,0}; int valor_p[8]={0,0,0,0,0,0,0,0}; int valor_salir=0,valor_enviar=0;

int valor_sal[9]={0,1,2,4,8,16,32,64,128},valor_pla[8]={0,2,4,6,8,10,12,14};

int sal=1,nn,sal_datos=0,sal_placa=0;

//Dibuja los 8 botones de las placas//

a=25; b=100; c=90; d=165;

for (n=0;n<8;n++)

{

boto_p[n][0]=a; boto_p[n][1]=b; boto_p[n][2]=c; boto_p[n][3]=d;

dib_requadre(boto_p[n],WHITE);

a=a+75;

c=c+75;

setfillstyle(9,BLACK);

}

//Dibuja los 8 botones de las salidas//

a=25; b=250; c=90; d=315;

for (n=0;n<8;n++)

{

boto_s[n][0]=a; boto_s[n][1]=b; boto_s[n][2]=c; boto_s[n][3]=d;

dib_requadre(boto_s[n],WHITE);

a=a+75;

c=c+75;

setfillstyle(9,BLACK);

}

//Dibuja los botones de salir y enviar//

a=465; b=400; c=580; d=448;

salir[0]=a; salir[1]=b; salir[2]=c; salir[3]=d;

a=245; b=400; c=397; d=448;

enviar[0]=a; enviar[1]=b; enviar[2]=c; enviar[3]=d;

dib_requadre(enviar,WHITE);

rectangle(466,401,579,447);

dib_requadre(salir,WHITE);

rectangle(246,401,396,447);

settextstyle(1,0,5);

setfillstyle(1,BLUE);

floodfill((enviar[0]+enviar[2])/2,(enviar[1]+enviar[3])/2,WHITE);

floodfill((salir[0]+salir[2])/2,(salir[1]+salir[3])/2,WHITE);

setcolor(YELLOW);

outtextxy(470,397,"SALIR");

outtextxy(250,397,"ENVIAR");

outtextxy(250,50,"PLACAS");

outtextxy(245,200,"SALIDAS");

settextstyle(2,0,5);

outtextxy(490,10,"Desing by D.S.A.(C)");

settextstyle(1,0,5);

setcolor(BLUE);

rectangle(1,1,639,479);

rectangle(5,50,635,180);

rectangle(5,200,635,330);

setcolor(LIGHTBLUE);

rectangle(3,3,637,477);

rectangle(7,52,633,178);

rectangle(7,202,633,328);

ratoli();

setcolor(YELLOW);

outtextxy(boto_s[0][0]+23,boto_s[0][1]+6,"0");outtextxy(boto_s[1][0]+23,boto_s[1][1]+6,"1");

outtextxy(boto_s[2][0]+23,boto_s[2][1]+6,"2");outtextxy(boto_s[3][0]+23,boto_s[3][1]+6,"3");

outtextxy(boto_s[4][0]+23,boto_s[4][1]+6,"4");outtextxy(boto_s[5][0]+23,boto_s[5][1]+6,"5");

outtextxy(boto_s[6][0]+23,boto_s[6][1]+6,"6");outtextxy(boto_s[7][0]+23,boto_s[7][1]+6,"7");

outtextxy(boto_p[0][0]+23,boto_p[0][1]+6,"0");outtextxy(boto_p[1][0]+23,boto_p[1][1]+6,"1");

outtextxy(boto_p[2][0]+23,boto_p[2][1]+6,"2");outtextxy(boto_p[3][0]+23,boto_p[3][1]+6,"3");

outtextxy(boto_p[4][0]+23,boto_p[4][1]+6,"4");outtextxy(boto_p[5][0]+23,boto_p[5][1]+6,"5");

outtextxy(boto_p[6][0]+23,boto_p[6][1]+6,"6");outtextxy(boto_p[7][0]+23,boto_p[7][1]+6,"7");

//* SELECCION DE SALIDA *//

{

n=0;

while (n<8)

{

if ((selec_requadre(boto_s[n])) && (valor_s[n]==0))

{

amaga_ratoli();

setfillstyle(1,BLUE);

floodfill( boto_s[n][0]+5 , boto_s[n][1]+5 , WHITE );

valor_s[n]=1;

outtextxy(boto_s[0][0]+23,boto_s[0][1]+6,"0");

outtextxy(boto_s[1][0]+23,boto_s[1][1]+6,"1");

outtextxy(boto_s[2][0]+23,boto_s[2][1]+6,"2");

outtextxy(boto_s[3][0]+23,boto_s[3][1]+6,"3");

outtextxy(boto_s[4][0]+23,boto_s[4][1]+6,"4");

outtextxy(boto_s[5][0]+23,boto_s[5][1]+6,"5");

outtextxy(boto_s[6][0]+23,boto_s[6][1]+6,"6");

outtextxy(boto_s[7][0]+23,boto_s[7][1]+6,"7");

ensenya_ratoli();

delay(200);

}

if ((selec_requadre(boto_s[n])) && (valor_s[n]==1))

{

amaga_ratoli();

setfillstyle(1,BLACK);

floodfill( boto_s[n][0]+5 , boto_s[n][1]+5 , WHITE );

valor_s[n]=0;

outtextxy(boto_s[0][0]+23,boto_s[0][1]+6,"0");

outtextxy(boto_s[1][0]+23,boto_s[1][1]+6,"1");

outtextxy(boto_s[2][0]+23,boto_s[2][1]+6,"2");

outtextxy(boto_s[3][0]+23,boto_s[3][1]+6,"3");

outtextxy(boto_s[4][0]+23,boto_s[4][1]+6,"4");

outtextxy(boto_s[5][0]+23,boto_s[5][1]+6,"5");

outtextxy(boto_s[6][0]+23,boto_s[6][1]+6,"6");

outtextxy(boto_s[7][0]+23,boto_s[7][1]+6,"7");

ensenya_ratoli();

delay(200);

}

n++;

}

//* SELECCION DE PLACA *//

n=0;

while (n<8)

{

if ((selec_requadre(boto_p[n])) && (valor_p[n]==0))

{

amaga_ratoli();

setfillstyle(1,BLUE);

floodfill( boto_p[n][0]+5 , boto_p[n][1]+5 , WHITE );

ensenya_ratoli();

for (i=0;i<8;i++)

{

if (valor_p[i]==1)

{

amaga_ratoli();

setfillstyle(1,BLACK);

floodfill( boto_p[i][0]+5 , boto_p[i][1]+5 , WHITE );

valor_p[i]=0;

outtextxy(boto_p[0][0]+23,boto_p[0][1]+6,"0");

outtextxy(boto_p[1][0]+23,boto_p[1][1]+6,"1");

outtextxy(boto_p[2][0]+23,boto_p[2][1]+6,"2");

outtextxy(boto_p[3][0]+23,boto_p[3][1]+6,"3");

outtextxy(boto_p[4][0]+23,boto_p[4][1]+6,"4");

outtextxy(boto_p[5][0]+23,boto_p[5][1]+6,"5");

outtextxy(boto_p[6][0]+23,boto_p[6][1]+6,"6");

outtextxy(boto_p[7][0]+23,boto_p[7][1]+6,"7");

ensenya_ratoli();

delay(200);

}

valor_p[n]=1;

outtextxy(boto_p[0][0]+23,boto_p[0][1]+6,"0");

outtextxy(boto_p[1][0]+23,boto_p[1][1]+6,"1");

outtextxy(boto_p[2][0]+23,boto_p[2][1]+6,"2");

outtextxy(boto_p[3][0]+23,boto_p[3][1]+6,"3");

outtextxy(boto_p[4][0]+23,boto_p[4][1]+6,"4");

outtextxy(boto_p[5][0]+23,boto_p[5][1]+6,"5");

outtextxy(boto_p[6][0]+23,boto_p[6][1]+6,"6");

outtextxy(boto_p[7][0]+23,boto_p[7][1]+6,"7");

delay(200);

}

if ((selec_requadre(boto_p[n])) && (valor_p[n]==1))

{

amaga_ratoli();

setfillstyle(1,BLACK);

floodfill( boto_p[n][0]+5 , boto_p[n][1]+5 , WHITE );

valor_p[n]=0;

outtextxy(boto_p[0][0]+23,boto_p[0][1]+6,"0");

outtextxy(boto_p[1][0]+23,boto_p[1][1]+6,"1");

outtextxy(boto_p[2][0]+23,boto_p[2][1]+6,"2");

outtextxy(boto_p[3][0]+23,boto_p[3][1]+6,"3");

outtextxy(boto_p[4][0]+23,boto_p[4][1]+6,"4");

outtextxy(boto_p[5][0]+23,boto_p[5][1]+6,"5");

outtextxy(boto_p[6][0]+23,boto_p[6][1]+6,"6");

outtextxy(boto_p[7][0]+23,boto_p[7][1]+6,"7");

ensenya_ratoli();

delay(200);

}

//Pinta enviar//

if (selec_requadre(enviar))

{

amaga_ratoli();

setfillstyle(1,RED);

floodfill(enviar[0]+5 , enviar[1]+5 , WHITE);

setcolor(YELLOW);

outtextxy(250,397,"ENVIAR");

ensenya_ratoli();

valor_enviar=1;

delay(400);

amaga_ratoli();

setfillstyle(1,BLUE);

floodfill(enviar[0]+5 , enviar[1]+5 , WHITE);

setcolor(YELLOW);

outtextxy(250,397,"ENVIAR");

ensenya_ratoli();

//Enviar datos y placa//

outp (trobar_port(1),0);

outp (trobar_port(1)+2,0);

sal_datos=0;

for (nn=0;nn<9;nn++)

{

if (valor_s[nn]==1) sal_datos=sal_datos+valor_sal[nn+1];

if (valor_p[nn]==1) sal_placa=valor_pla[nn];

}

outp (trobar_port(1),sal_datos);

outp (trobar_port(1)+2,sal_placa);

outp (trobar_port(1)+2,sal_placa+1);

outp (trobar_port(1)+2,sal_placa);

}

n++;

}

while (!selec_requadre(salir));

amaga_ratoli();

setfillstyle(1,RED);

floodfill(salir[0]+5 , salir[1]+5 , WHITE);

setcolor(YELLOW);

outtextxy(470,397,"SALIR");

ensenya_ratoli();

delay(400);

}

void ratoli(void)

{

union REGS estado;

estado.x.ax = 0x00; // mirar si hi ha ratoli instal.lat //

int86 (0x33, &estado, &estado);

estado.x.ax = 0x01; // mostra el ratoli a la pantalla //

int86 (0x33, &estado, &estado);

}

Les llibreries personals utilitzades al programa son SARDA.H, aquesta inclou o crida altres llibreries, també especials, com es el cas del BASIC.H, el qual es presenta ara:

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

Programa font que cont les següents funcions estandars :

void dibuixa_escut(void) : Dibuixa l'escut de la Generalitat.

void escriu_text(char escola[25],char autor[25],char any[25],int codi) : Reb

tres strings encriptats i el codi d'encriptaci¢, i els escriu

correctament en la pantalla

void presentacio(char escola[25],char autor[25],char any[25],int codi) :

Funci¢ que prepara una pantalla de presentaci¢

escola[25] : Nom de l'escola/empresa (m…x. 25 car…cters)

autor[25] : Nom de l'autor del programa.

any[25] : Data de finalitzaci¢ del programa.

codi : Codi d'encriptaci¢.

Crida a les funcions 'dibuixa_escut()' i 'escriu_text()'

int trobar_port(int n_port) Retorna l'adresa del port paralúlel

void ensenya_ratoli(void) Presenta el ratoli a pantalla

Aquesta funci¢ crida l'interrupci¢ 0x33 referida al ratol¡ amb la funci¢

0x01 que mostra el ratoli

void amaga_ratoli(void) Amaga el ratoli

Aquesta funci¢ crida l'interrupci¢ 0x33 referida al ratol¡ amb la funci¢

0x02 que oculta el ratoli

void llegeix_ratoli(void) Llegeix el ratoli

Aquesta funci¢ crida l'interrupci¢ 0x33 referida al ratol¡ amb la funci¢

0x03, aquesta retorna:

- sor.x.bx=estat dels botons del ratoli

bit0=activat si bot¢ esquerra apretat

bit1=activat si bot¢ dret apretat

bit2=activat si bot¢ centra apretat

- sor.x.cx=posicio x del ratol¡ referida a la pantalla

- sor.x.dx=posicio y del ratol¡ referida a la pantalla

void esc_coord(int coor[4],int color)

Funci¢ que escriu les coordenades en que es troba el ratol¡.

int coor[4] : £s un vector que indica el punt on s'escriu :

coor[0] : esquerra

coor[1] : dalt

coor[2] : dreta

coor[3] : baix

int color : Color en que s'escriu les coordenades.

int mou_ratoli(void) Funci¢ que mira si es mou el ratol¡

retorna 1 si s'ha mogut

retorna 0 si NO s'ha mogut

void dib_requadre(int coor[4],int color) Funci¢ que dibuixa un requadre.

int coor[4] : £s un vector que indica les cantonades del requadre.

coor[0] : esquerra

coor[1] : dalt

coor[2] : dreta

coor[3] : baix

int color : Color en que es dibuixa el requadre.

int selec_requadre(int coor[4]) Funci¢ que mira si s'ha seleccionat un

requadre.

(Aquesta selecci¢ implica que el ratol¡ est… dins del requadre

i es prem el bot¢ esquerra del ratol¡)

retorna 1 si s'ha seleccionat

retorna 0 si NO s'ha seleccionat

Desenvolupat en l'I.E.S. Mil… i Fontanals per Jaume Bacardit

Nom : basic.h

£ltima revisi¢ : Gener 1998

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

#include<graphics.h>

#include<conio.h>

#include<string.h>

#include<stdio.h>

#include<dos.h>

#include<stdlib.h>

#define CODI_ENC 5

#define COLOR_FONS YELLOW

#define COLOR RED

#define TIPUS_LLETRA SMALL_FONT

void dibuixa_escut(void);

void escriu_text(char escola[25],char autor[25],char any[25],int codi);

int mou_ratoli(void);

union REGS ent,sor; //Variables d'interrupci¢

unsigned int cx=0,dx=0;

void presentacio(char escola[25],char autor[25],char any[25],int codi)

{

int driver,modo,codi_error;

clrscr();

driver=DETECT;

modo=0;

initgraph(&driver,&modo,"");

codi_error = graphresult();

if (codi_error != grOk) {

printf("Error gr…fic : %s\n", grapherrormsg(codi_error));

printf("Prem una tecla per continuar.....");

getch();

exit(1);

}

dibuixa_escut();

escriu_text(escola,autor,any,codi);

getch();

printf("\nPrem una tecla per continuar.....");

closegraph();

}

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

Funci¢ que dibuixa l'escut de la Generalitat

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

void dibuixa_escut(void)

{

char text_escut[][50]={

"Ljsjwfqnyfy%ij%Hfyfqzs~f",

"Ijufwyfrjsy%i,Jsxjs~frjsy",

"Nsxynyzy%i,Jsxjs~frjsy%Xjhzsifwn",

"RnqŠ%n%Ktsyfsfqx",

};

int i,j;

setbkcolor(COLOR_FONS);

setcolor(COLOR+8);

ellipse(100,100,0,360,30,35);

ellipse(100,100,0,360,33,38);

setfillstyle(SOLID_FILL,COLOR+8);

floodfill(131,100,COLOR+8);

ellipse(100,100,0,360,28,33);

/***************** 4 barres ******************/

line(77,72,84,70);

line(84,70,84,130);

line(84,130,77,128);

line(77,128,77,72);

floodfill(78,100,COLOR+8);

line(90,65,97,66);

line(97,66,97,135);

line(97,135,90,134);

line(90,134,90,65);

floodfill(93,100,COLOR+8);

line(103,65,110,66);

line(110,66,110,135);

line(110,135,103,134);

line(103,134,103,65);

floodfill(105,100,COLOR+8);

line(116,72,123,74);

line(123,74,123,128);

line(123,128,116,126);

line(116,126,116,72);

floodfill(120,100,COLOR+8);

/********************* 1¦ sanefa ********************/

arc(67,66,0,90,3);

arc(70,63,180,270,3);

arc(81,76,73,196,15);

arc(75,51,253,315,15);

arc(56,70,315,18,15);

/********************* 2¦ sanefa ********************/

arc(133,66,90,180,3);

arc(130,63,270,0,3);

arc(118,76,-16,100,15);

arc(125,51,-135,-71,15);

arc(143,70,165,-135,15);

/********************* 3¦ sanefa ********************/

arc(67,134,270,0,3);

arc(70,137,90,180,3);

arc(81,124,165,-72,15);

arc(56,130,-17,45,15);

arc(75,149,45,100,15);

/********************* 4¦ sanefa ********************/

arc(133,134,180,270,3);

arc(130,137,0,90,3);

arc(118,124,-116,16,15);

arc(143,130,135,-163,15);

arc(125,149,73,135,15);

/********************* omplir sanefes ********************/

floodfill(68,75,COLOR+8); floodfill(77,63,COLOR+8);

floodfill(122,63,COLOR+8); floodfill(131,75,COLOR+8);

floodfill(68,127,COLOR+8); floodfill(77,137,COLOR+8);

floodfill(132,127,COLOR+8); floodfill(122,137,COLOR+8);

floodfill(68,64,COLOR+8); floodfill(69,65,COLOR+8);

floodfill(132,64,COLOR+8); floodfill(131,65,COLOR+8);

floodfill(68,136,COLOR+8); floodfill(69,135,COLOR+8);

floodfill(132,136,COLOR+8); floodfill(131,135,COLOR+8);

for(i=0;i<4;i++)

for(j=0;j<strlen(text_escut[i]);j++)

text_escut[i][j]=text_escut[i][j]-CODI_ENC;

settextstyle(TIPUS_LLETRA,0,4);

outtextxy(140,70,text_escut[0]);

outtextxy(140,80,text_escut[1]);

outtextxy(140,90,text_escut[2]);

outtextxy(140,100,text_escut[3]);

setcolor(COLOR);

}

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

Funci¢ que escriu un text encriptat en la pantalla de

presentaci¢

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

void escriu_text(char escola[25],char autor[25],char any[25],int codi)

{

int i,j;

char text[][75]={

"Uwtlwfrf%ijxjs{tqzufy%js%q,",

"ujw%",

"Q,fzytw1%htr%f%uwtunjyfwn%ijq%uwtlwfrf%js%ujwrjy%",

"qf%htunf%n%qqnzwj%inxywngzhn§%ujwš1%fqmtwf1%",

"uwtmngjn}%vzfqxj{tq%rtinknhfhn§%ijq%rfyjn}3",

"Nlzfqfif%2%",

"Ujw%htsynszfw1%uwjr%zsf%yjhqf33333",

};

/****************** encripta textos estandard ****************/

for (i=0;i<7;i++)

for(j=0;j<strlen(text[i]);j++) text[i][j]=text[i][j]-CODI_ENC;

/****************** afegeix text als estandard ***************/

for(i=0;i<strlen(escola);i++) escola[i]=escola[i]-codi;

for(i=0;i<strlen(autor);i++) autor[i]=autor[i]-codi;

for(i=0;i<strlen(any);i++) any[i]=any[i]-codi;

strcat(text[0],escola);

strcat(text[1],autor);

strcat(text[5],any);

/****************** escriu textos *********************/

settextstyle(TIPUS_LLETRA,0,5);

outtextxy(100,180,text[0]);

outtextxy(100,200,text[1]);

outtextxy(100,240,text[2]);

outtextxy(100,260,text[3]);

outtextxy(100,280,text[4]);

outtextxy(350,320,text[5]);

outtextxy(50,400,text[6]);

}

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

Funci¢ que retorna l'adresa on est… el port de dades del port paralúlel

n_port=1 LPT1

n_port=altra cosa LPT2

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

int trobar_port(int n_port)

{

int adresa,port_dades;

if(n_port==1) adresa=0x408;

else adresa=0x40A;

port_dades=peek(0x00,adresa);

return port_dades;

}

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

// MOSTRA EL RATOLI

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

void ensenya_ratoli(void)

{

_AX=0x01;

geninterrupt(0x33);

}

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

// AMAGA EL RATOLI

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

void amaga_ratoli(void)

{

_AX=0x02;

geninterrupt(0x33);

}

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

// LLEGEIG EL RATOLI

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

void llegeix_ratoli(void)

{

ent.x.ax=0x03;

int86(0x33,&ent,&sor);

}

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

// ESCRIU COORDENADES

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

void esc_coord(int coor[4],int color)

{

char text_cursor[9],*valor;

int puntdec,signe;

float cx,dx;

llegeix_ratoli();

if(mou_ratoli()) {

setviewport(coor[0]+110,coor[1]+1,coor[2]-40,coor[3]-1,0);

clearviewport();

cx=sor.x.cx;

dx=sor.x.dx;

valor=fcvt(cx,0,&puntdec,&signe); //Converteix sor.x.cx en string

strcpy(text_cursor,valor);

strcat(text_cursor," : ");

valor=fcvt(dx,0,&puntdec,&signe);

strcat(text_cursor,valor);

setcolor(color);

outtextxy(0,5,text_cursor);

setviewport(0,0,getmaxx(),getmaxy(),1);

}

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

// FUNCI¢ QUE MIRA SI ES MOU EL RATOL

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

int mou_ratoli(void)

{

if((sor.x.dx!=dx)||(sor.x.cx!=cx)) {

cx=sor.x.cx;

dx=sor.x.dx;

return 1;

}

return 0;

}

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

// FUNCI¢ QUE DIBUIXA REQUADRE

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

void dib_requadre(int coor[4],int color)

{

setcolor(color);

line(coor[0],coor[1],coor[0],coor[3]);

line(coor[0],coor[1],coor[2],coor[1]);

line(coor[2],coor[1],coor[2],coor[3]);

line(coor[2],coor[3],coor[0],coor[3]);

}

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

// FUNCI¢ QUE MIRA SI S'HA SELECCIONAT UN REQUADRE

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

int selec_requadre(int coor[4])

{

unsigned int cx,bx,dx;

llegeix_ratoli();

cx=sor.x.cx;dx=sor.x.dx;bx=sor.x.bx;

if ((cx>=coor[0]&&cx<=coor[2])&&(dx>=coor[1]&&dx<=coor[3])&&((bx&0x1)==1)) return 1;

else return 0;

}

Sortides Controlades

Tal vez te pueda interesar:

Descargar

Enviado por:	Kal Trempat
Idioma:	catalán
País:	España

Palabras clave:

Electrónica Components Placa Multiplexors Esquemes

Te va a interesar