Universidade de Braslia

Arquitetura de
Processadores
Digitais
Prova 03

Sumrio
DMA .............................................................................................................................................. 2
DMA........................................................................................................................................... 4
ADC + DAC + DMA + 8253 ......................................................................................................... 4
PROVA TREINO ............................................................................................................................. 8
Consideraes gerais: ......................................................................................................... 10
Circuito interface: ............................................................................................................... 11
Rotina void dma_adc (void) ............................................................................................... 12
Rotina rmediap (void)......................................................................................................... 14
Rotina int_eoc (void) .......................................................................................................... 15
Rotina interrupt int_serial (void) ....................................................................................... 16
Rotina interrupt int_paralela (void)................................................................................... 17
Rotina interrupt paralela (void) ......................................................................................... 18
Rotina main (void) .............................................................................................................. 19
Completo ............................................................................................................................. 21
INTERRUPO............................................................................................................................. 25
INTERUPO ........................................................................................................................... 32
INTERRUPO SERIAL ............................................................................................................. 34
INTERRUPO PARALELO........................................................................................................ 36
LABORATRIO ............................................................................................................................ 39
Interrupo.............................................................................................................................. 39
Serial ........................................................................................................................................ 41
Linguagem C ................................................................................................................................ 44
Comandos................................................................................................................................ 44
Switch Case.............................................................................................................................. 44
Farmalloc ................................................................................................................................. 45

DMA

OPERAO DE DMA PASSO A PASSO:

DMA
#include <dos.h>
#include <stdio.h>
void main(void){
long end20, off, seg;
char far *pt;
pt = farmalloc(2*10k);
seg = FP_SEG(pt);
off = FP_OFF(pt);
end20 = seg<<4 + off;
if((end20&0xF0000)!=((end20+10k)&0xF0000))
end20 = end20+10k;
outportb(0x0B,0x45);//modo
outportb(0x0C,0);//FFAB
outportb(3,10k-1);//LSB QTD
outportb(3,(10k-1)>>8);//MSB QTD
outportb(2,end20);//endereo
outportb(2,end20>>8);//endereo
outportb(0x83,end20>>16);//endereo
outportb(0x0A,1);//apaga mscara
while((inportb(8)&2)==0);
outportb(0x0A,5);//ativa mscara
}
while((inportb(8)&2)==0){ //para ver quantas converses foram feitas
x = inportb(3);
x = (x<<8)+inportb(3);
printf("%d/n",(10k-1)-x);
}

ADC + DAC + DMA + 8253

ADC + DAC + DMA + 8253
novo canal ADC chega pela porta SERIAL (interrupo) o dado convertido deve ser usado para calcular a mm8 e transmitido
para o DAC e SERIAL
EOC(ADC) => DRQ1(DMA) e IRQ5(PC)
OUT0(DMA) => START(ADC) e DRQ3(DMA)
DACK1(DMA)+IOR() => OE(ADC)
DACK3(DMA)+IOW() => G(DAC)*/
#include <dos.h>
#include <stdio.h>
void interrupt *(vet13)(void);
void interrupt *(vet12)(void);
void mm8(int canal, int taxa){
int n, hab;
char far *pt1, *pt2[1]
/* programao do 8253
canal
seg
modo
bin/bcd
00
11
011
*/
outportb(CS1+3,int taxa);
n = 2E6/taxa;
outportb(CS1,n);
outportb(CS1,n>>8);
//canal AD
outportb(CS0+canal,0);
/* programao da serial
COM1, BR 9600, 8 bits, 2 stops, sem paridade, IRQ4
*/
outportb(LCR,0x80);//DLAB = 1
outportb(DLL,12);//divisor
outportb(DLM,0);//divisor
outportb(LCR,7);//modo
outportb(IER,1);//hab int
outportb(MCR,8);//hab int
// guardar vetores usados nas interrupes
vet13 = getvect(0x0D);

= 36h

vet12 = getvect(0x0C);
setvect(0x0D,rot_eoc);
setvect(0x0C,rot_ser);
hab = inportb(0x21);
outportb(0x21,hab&0xCF);
// programao do dma
pt1 = far malloc(16);
seg = FP_SEG(pt1);
off = FP_OFFF(pt1);
adr20 = (seg<<4)+off;
if((adr20>>16) != ((adr20+8)>>16))//verifica a fronteira de pgina
adr20 = adr20+8;
adrda = (FP_SEG(pt2)<<4)+FP_OFF(pt2);
outportb(0x0C,0);
outportb(3,7);// 8 bits
outportb(3,0);//------outportb(2,adr20);//-------------+
outportb(2,adr20>>8);// endereo +
outportb(0x83,adr20>>16);//------+
outportb(7,0);//-----------------+
outportb(7,0);
outportb(6,adrda);// canal3 +
outportb(6,adrda>>8);
outportb(6,adrda>>16);//---------+
outportb(0x0B,0x55);// modo
outportb(0x0B,0x5B);//----outportb(0x0A,1);// habilitaes
outportb(0x0A,3);//-------------}
void interrupt rot_eoc(void){
sum = 0;
for(i=0;i<8;i++)
sum += pt1[i];
media = sum/8;
outportb(CS0+ncanal,0);
outportb(0x20,0x20);
outportb(TxB,media);}
void interrupt rot_ser(void){
ncanal = inportb(RxB);
outportb(0x20,0x20);}

PROVA TREINO

Consideraes gerais:
#include <conio.h>
#include <dos.h>
#define TxB 0x3F8
#define RxB 0x3F8
#define DLL 0x3F8
#define DLM 0x3F9
DLM
#define LCR 0x3FB
#define IER 0X3F9

// Define o endereo do TxB

// Define o endereo do RxB
// Define o endereo do DLL
// Define o endereo do
// Define o endereo do LCR
// Define o endereo do IER

char far *media,*buffer;

void interrupt (*vet12)(void);
void interrupt (*vet13)(void);
void interrupt (*vet15)(void);

10

Circuito interface:

Fig. 1: Interface 1

Fig. 2: Interface 2

11

Rotina void dma_adc (void)

Executa as inicializaes necessrias para o ADC transferir para a memria via canal 1 de DMA.
void dma_adc (void){
outportb (CS0,0);
buffer = farmalloc (2*8); // aloca 2*8 espaos na memria para buffer
seg = FP_SEG(buffer); // registra o segment de buffer
off = FP_OFF(buffer);
adr20 = (seg<<4) + off;
if((adr20)>>16 != (adr20 + 8)>> 16)
adr20 = adr20 + 8;
outportb(0XC,0);
outportb(2,adr20);
outportb(2,adr20>>8);
outportb(0x83,adr20>>16);
outportb(3,7);
outportb(3,0);
outportb(0XB,5);
outportb(0xA,1);}

12

Rotina void dma_dac (void)

void dma_dac (void){
media = farmalloc(1);
seg = FP_SEG(media);
off = FP_OFF(media);
adr20 = (seg<<4) + off;
outportb(4,adr20);
outportb(4,adr20>>8);
outportb(0x81,adr20>>16);
outportb(5,0);
outportb(5,0);
outportb(0XB,0x5A);
outportb(0xA,2);
}

13

Rotina rmediap (void)

void rmediap(void){
posio = inportb(3);
if (posio = 0){i = 6;}
else if(posio = 1){i = 5;} // dava para usar switch-case
else if(posio = 2){i = 4;}
else if(posio = 3){i = 3;}
else if(posio = 4){i = 2;}
else if(posio = 5){i = 1;}
else if(posio = 6){i = 0;}
else if(posio = 7){i = 7;}
for(j=0,j++,j<8){
soma = soma + peso[j]*buffer[i];
i = (i-1)&7;}
*media = (soma + 4)>>3;}

14

Rotina int_eoc (void)

void interrupt int_eoc(void){
int i,posio,soma = 0;
rmediap();
outportb(CS1,0);
outportb(0X20,0X20);
}

15

Rotina interrupt int_serial (void)

void interrupt int_serial(void){
c = inportb(RxB);
if(c>=0x30 & c<=0x37){
outportb(CS0,(c - 0x30));
}
if(c == 's'){
outportb(0xA,5);
outportb(0xA,6);
}
if(c == 'r'){
outportb(0xA,1);
outportb(0xA,2);
}
outportb(0x20,0x20);
}

16

Rotina interrupt int_paralela (void)

void interrupt int_paralela(void){
canal = (inportb(0x379)>>3)&7;
outportb(CS0+canal,0);
outportb(0x20,0x20);
}

17

Rotina interrupt paralela (void)

void paralela (int dado){
outportb(0X378,dado);
outportb(0X37A,1);
//STRB
while(inportb(0X37A)&2 == 0); // ACK
}

18

Rotina main (void)

int main{
long seg,off,adr20;
int hab,pesos[8] = {64,32,16,8,4,2,1,1};
char c;
//interrupes
vet12 = getvect(12);
vet13 = getvect(13);
vet15 = getvect(15);
setvect(12,int_serial);
setvect(13,int_eoc);
setvect(15,int_paralela);
hab = inportb(0x21);
outportb(0x21,hab&0x4F);
//serial
outportb (LCR, 7); // Define bit de parada e 8 bits
outportb(IER, 1); // Define interrupo por dado disponvel
outportb(LCR, 0x87); // Aciona o acesso ao divisor
outportb (DLL, 12); // Define N = 12, BR = 9600
outportb (DLM, 0); // Define N = 12
outportb (LCR, 7); // Define 2 bits de parada e 8 bits
//DMA
dma_adc();
dma_dac();
while(!kbhit){
*media = dado;
outportb(TxB,dado);
paralela(dado);}
outportb(0xA,5);
outportb(0xA,6);
setvect(12,vet12);
setvect(13,vet13);
setvect(15,vet15);}

19

20

Completo
#include <conio.h>
#include <dos.h>
#define TxB 0x3F8
#define RxB 0x3F8
#define DLL 0x3F8
#define DLM 0x3F9
DLM
#define LCR 0x3FB
#define IER 0X3F9

// Define o endereo do TxB

// Define o endereo do RxB
// Define o endereo do DLL
// Define o endereo do
// Define o endereo do LCR
// Define o endereo do IER

char far *media,*buffer;

void interrupt (*vet12)(void);
void interrupt (*vet13)(void);
void interrupt (*vet15)(void);
void dma_adc (void){
outportb (CS0,0);
buffer = farmalloc (2*8);
// aloca 2*8 espaos na memria para buffer
seg = FP_SEG(buffer);
// registra o segment de buffer
off = FP_OFF(buffer);
adr20 = (seg<<4) + off;
if((adr20)>>16 != (adr20 + 8)>> 16)
adr20 = adr20 + 8;
outportb(0XC,0);
outportb(2,adr20);
outportb(2,adr20>>8);
outportb(0x83,adr20>>16);
outportb(3,7);
outportb(3,0);
outportb(0XB,5);
outportb(0xA,1);
}
void dma_dac (void){
media = farmalloc(1);
seg = FP_SEG(media);
off = FP_OFF(media);
adr20 = (seg<<4) + off;
outportb(4,adr20);
outportb(4,adr20>>8);
outportb(0x81,adr20>>16);
outportb(5,0);
outportb(5,0);
outportb(0XB,0x5A);
outportb(0xA,2);
}

21

void rmediap(void){
posio = inportb(3);
if (posio = 0){
i=6
}
else if(posio = 1){
i=5
}
else if(posio = 2){
i=4
}
else if(posio = 3){
i=3
}
else if(posio = 4){
i=2
}
else if(posio = 5){
i=1
}
else if(posio = 6){
i=0
}
else if(posio = 7){
i=7
}
for(j=0,j++,j<8){
soma = soma + peso[j]*buffer[i];
i = (i-1)&7;
}
*media = (soma + 4)>>3;
}
void interrupt int_eoc(void){
int i,posio,soma = 0;
rmediap();
outportb(CS1,0);
outportb(0X20,0X20);
}
void interrupt int_serial(void){
c = inportb(RxB);
if(c>=0x30 & c<=0x37){
outportb(CS0,(c - 0x30));
}
if(c == 's'){
outportb(0xA,5);
outportb(0xA,6);
}
if(c == 'r'){

22

outportb(0xA,1);
outportb(0xA,2);
}
outportb(0x20,0x20);
}
void interrupt int_paralela(void){
canal = (inportb(0x379)>>3)&7;
outportb(CS0+canal,0);
outportb(0x20,0x20);
}
void paralela (int dado){
outportb(0X378,dado);
outportb(0X37A,1);
//STRB
while(inportb(0X37A)&2 == 0); // ACK
}
int main{
long seg,off,adr20;
int hab,pesos[8] = {64,32,16,8,4,2,1,1};
char c;
//interrupes
vet12 = getvect(12);
vet13 = getvect(13);
vet15 = getvect(15);
setvect(12,int_serial);
setvect(13,int_eoc);
setvect(15,int_paralela);
hab = inportb(0x21);
outportb(0x21,hab&0x4F);
//serial
outportb (LCR, 7);

// Define bit de parada e 8

bits
outportb(IER, 1);
dado disponvel
outportb(LCR, 0x87);
outportb (DLL, 12);
outportb (DLM, 0);
outportb (LCR, 7);
bits
//DMA
dma_adc();
dma_dac();

// Define interrupo por

// Aciona o acesso ao divisor
// Define N = 12, BR = 9600
// Define N = 12
// Define 2 bits de parada e 8

while(!kbhit){
*media = (soma + 64)>>7;
outportb(TxB,dado);
paralela(dado);
}

23

outportb(0xA,5);
outportb(0xA,6);
setvect(12,vet12);
setvect(13,vet13);
setvect(15,vet15);
}

24

INTERRUPO

25

26

27

28

29

30

31

INTERUPO
/* Modulo 3 - Aula 1 - 10 de novembro de 2009
INTERRUPES*/
/*

IRQ2 IRQ5 IRQ2 IRQ5

clk
eoc
-----+-------+-------+-------+------->
DAC
ler AD DAC
start calc. start
mdia
*/
#include <dos.h>
#include <stdio.h>

clk

eoc

int vector[8], i, band, cont, media;

void interrupt *(vetor2)(void);
void interrupt *(vetor5)(void);
void mm8(int canal, int freq){
int n, antigo;
n = 1E6/freq;
/* Registrador de Controle de Modo (43H) do 8253
0011 0110
canal 0
conta em binrio
manda primeiro o LSB
modo 3
binrio
*/
outportb(CS4+3,0x36);
outportb(CS4,n);
outportb(CS4,n>>8); /*8253*/
outportb(CS0+canal,0); /*ADC*/
for(i=0;i<8;i++)
vetor[i]=0;

32

media=i=0;
vetor2 = getvect(0xA); /* A = 13, endereo que atende ao IRQ2*/
vetor5 = getvect(0xD); /* guarda vetores antigos*/
setvect(0xA,Rot_IRQ2); //novos vetores
setvect(0xD,Rot_IRQ5); //novos vetores
antigo = inportb(0x21); //21H = endereo da Palavra de Controle de Operao
OCW1
outportb(0x21,antigo&0xDB);//hab IRQ2 e IRQ5 > XX0X X0XX > mscara 1101 1011
(DBH)
while(!kbhit()){
if(band){
printf("[%d] media = %d \n", aux, media);
band = 0;
}
}
outportb(0x21,antigo|0x24);//desabilta int
setvect(0xA,vetor2);//restaura vetor 2
setvect(0xD,vetor5);//restaura vetor 5
printf("Acabou!");
}
void interrupt Rot_IRQ2(void){
outportb(CS1,0);//start
outportb(CS3,media);//DAC <- media
inportb(CS2);//apaga o pedido de IRQ2
outportb(0x20,0x20);//EOI
}
void interrupt Rot_IRQ5(void){
int x, j;
x = inport(CS0);//ler AD
outportb(CS2,0);//apaga pedido de IRQ5
outportb(0x20,0x20);//EOI
//calcular mdia
vetor[i++] = x;
i &= 7; //mascara os 3 bits
media = 0;
for(j=0;j<8;j++)
media += vetor[j];
media = (media+4)>>3; //divide por 8 com arredondamento
cont++;
if(band==0){
aux = cont;
band = 1;
}
}

33

INTERRUPO SERIAL
/* Aula 2 - Interrupo Serial - 17 de novembro de 2009
LCR - modo
LSR - status
IER - enable interruption
IIR - identify interruption
MCR - controle modem
MSR - status modem
DTR
DSRR
CTS
*/
#include <dos.h>
#include <stdio.h>
void interrupt *(ant4)(void);
int flag, dado, velho, erros, x, z;
int mestre(void){
//inicializao
int n = 115200/9600;
outportb(LCR,0x80); //progamar DLAB = 1
outportb(DLL,n); //lsb do baud rate
outportb(DLM,n>>8); //msb do baud rate
outportb(LCR,7); // 8 bits, sem paridade, 2 stops
outportb(IER,1); //hab interrupo
outportb(MCR,8); // out2 = 1
ant4 = getvect(0x0C);
setvect(0x0C,rot_ser);
velho = inport(0x21);
outportb(0x21,velho&0xEF);
//fim da inicializao
flag = erros = x = 0;
while(!kbhit()){
outportb(TxB,x);
while(!flag);
flag = 0;
z = x^dado;
if(z) erros++;
x++;
printf("erros = %d",erros);
}
outportb(0x21,velho|0x10);
setvect(0x0C,ant4);

34

}
void interrupt rot_ser(void){
dado = inportb(RxB);
flag = 1;
outportb(0x20,0x20);//EOI
}
//==================================================
void interrupt *(ant4)(void);
void rep(void){
//inicializao
int n = 115200/9600;
outportb(LCR,0x80); //progamar DLAB = 1
outportb(DLL,n); //lsb do baud rate
outportb(DLM,n>>8); //msb do baud rate
outportb(LCR,7); // 8 bits, sem paridade, 2 stops
outportb(IER,1); //hab interrupo
outportb(MCR,8); // out2 = 1
ant4 = getvect(0x0C);
setvect(0x0C,rot_ser);
velho = inport(0x21);
outportb(0x21,velho&0xEF);
//fim da inicializao
}
void interrupt rot_ser(void){
int z;
z = inportb(RxB);
outportb(TxB,z);
outportb(0x20,0x20);
}

35

INTERRUPO PARALELO
/* aula 3 - interrupo paralela
AD
DA
REG 378H
7
D7
6
D6
5
D5
4
D4
3
WR
2
OE
1
START
0
ALE
REG 379H
7*
D7
6
EOC (IRQ7)
5
D6
4
D5
3
D4
REG 37AH
3*
D3
D3
2
D2/A2 D2
1*
D1/A1 D1
0*
D0/A0 D0
Mdia mvel 8 no DAC
Teclado - novo canal
Teclado - Tecla 'f' - FIM
IRQ4 Serial - TX(mm8), RX(novo canal), br9600, 8bits, 2 stops
*/
#include <dos.h>
#include <stdio.h>
void interrupt *(vet4)(void);
void interrupt *(vet7)(void);//declarar os vetores q guardaro os valores antigos dos vetores
de interrupo
int vetor[8], i, canal_n, flag, media;
void mm8(void){ int j, taxa, antigo, c;
//zerar variveis
canal_ad(0);
for(j=0;j<7;j++)
vetor[j] = 0;
i = media = 0;
//programar porta serial
taxa = 115200/9600;
outportb(LCR,0x80);
outportb(DLL,taxa);
outportb(DLM,taxa>>8);
outportb(LCR,7);
outport(IER,1);

36

outportb(MCR,8);
outportb(0x37A,0x10);//habilita IRQ7
outportb(0x378,0);
//guarda os vetores antigos
vet4 = getvect(12);
vet7 = getvect(15);
setvect(12,rot_ser);
setvect(15,rot_eoc);
antigo = inportb(0x21);
outportb(0x21,antigo&0x6F);
//lao principal
c = 0;
while(c != 'f'){
if(kbhit()){
c = getch();
if(c >= 0 && c <= 7){
canal_n = c;
flag = 1;
}
}
printf("media = %d \n",media);
}
outportb(0x21, antigo|9);
setvect(12,vect4);
setvect(15,vect7);
}
void canal_ad(int canal){
int x;
outportb(0x37A,(canal&7)^3);//manda o canal
outportb(0x378,1);
outportb(0x378,0);//flanco de descida do ALE
}//tem um erro!
void interrupt rot_ser(void){
int x;
x = inportb(RxB);
if(x >= 0 && x <= 7){
canal_n = x;
flag = 1;
}
outportb(0x20,0x20);//EOI
}
void interrupt rot_eoc(void){
int x, y, z;
//DAC
outportb(0x37A,0x10|media^0x0B);
outportb(0x378,media&0xF0);

37

//flanco de subida do WR
outportb(0x378,(media&0xF0)||8);
outportb(0x378,media&0xF0);
//manda pelo serial
outportb(TxB,media);
//ler ADC
outportb(0x37A,0x10|4);//programa como entrada
outportb(0x378,4);
x = inportb(0x379)^0x80;
y = inportb(0x37A)^0x0B;
x = (x&0x80)+(x&0x38)<<1;//arruma o byte
vetor[i++] = x+y;
i=&7;
soma = 0;
for(j=0;j<8;j++)
soma+=vetor[j];
media = (soma+4)>>3;
if(flag){
flag=0;
canal_ad(canal_n);//trocar canal
}
outportb(0x20,0x20);//EOI
}

38

LABORATRIO
Interrupo
//---------------------------------------------------------------------------------------// UNIVERSIDADE DE BRASILIA
// ARQUITETURA DE PROCESSADORES DIGITAIS
// 1/2016
//---------------------------------------------------------------------------------------// Daniela Aguiar de Carvalho Freitas
// Renato da Silva Paes
//---------------------------------------------------------------------------------------// Experimento 9
// versao 5
#include <dos.h>
#include <stdio.h>
#include <conio.h>
#define
#define
#define
#define
#define
#define
#define
#define

TXB
RXB
DLL
DLM
LCR
LSR
IER
MCR

0x3F8
0x3F8
0x3F8
0x3F9
0x3FB
0x3FD
0x3F9
0x3FC

void interrupt serial_RX(void);

void interrupt (*vet12)(void);
void SERIAL_TXB (void);
void SERIAL_RXB(void);
void INICIALIZA_SERIAL (void);
void INICIALIZA_INTERRUPCAO_SERIAL (void);
int esc = 0x1B;
int flag = 0, fim = 0;
int caracter_Tx, caracter_Rx, habilita;
void main (){
INICIALIZA_SERIAL();
INICIALIZA_INTERRUPCAO_SERIAL ();
vet12 = getvect(12);
setvect(12,serial_RX);
habilita = inportb(0x21);
outportb(0x21, habilita&0xEF);

// corrigido

/*Enquanto no apertar a tecla ESC */

while(fim == 0){
/*Verifica se uma tecla foi pressionada*/
if(kbhit() != 0){

39

SERIAL_TXB();
}
/**/
if (flag == 1){
SERIAL_RXB();
}
}//fim while
printf("ESC foi pressionado.\n");
outportb(0x21,habilita|0x10); /*Bit 4 volta a ser 0*/
setvect(12, vet12);
}// fim main
void SERIAL_TXB (void){
caracter_Tx = getch();
outportb(TXB, caracter_Tx);
if (caracter_Tx = esc)
fim=1;
}// fim serial recebe
void SERIAL_RXB(void){
flag = 0;
printf("%c",caracter_Rx);
if (caracter_Rx = esc)
fim=1;
}
void interrupt serial_RX(void){
caracter_Rx = inportb(RXB);
flag = 1;
outportb(0x20,0x20);
}
void INICIALIZA_SERIAL (void){
/*Habilita acesso ao divisor - 10000000*/
outportb(LCR, 0x80); /*DLAB = 1 autoriza o acesso*/
/*Atualizao dos divisores*/
outportb(DLM, 0);/*menos significativo*/
outportb(DLL, 12); /*mais significativo*/
/*habilita recepcao e transmissao e programa de paridade e bit de parada*/
outportb(LCR, 7); /*8 bits, 2 stops e sem paridade*/
}// fim inicializa serial
void INICIALIZA_INTERRUPCAO_SERIAL (void){
outportb(MCR,9); /*pedido de INT do 8250 seja conectado ? IRQ*/
outportb(IER,1); /*habilita INT por dado dispon?vel*/
}

40

Serial
//---------------------------------------------------------------------------------------// UNIVERSIDADE DE BRASILIA
// ARQUITETURA DE PROCESSADORES DIGITAIS
// 1/2016
//---------------------------------------------------------------------------------------// Daniela Aguiar de Carvalho Freitas
// Renato Paes
//---------------------------------------------------------------------------------------// Experimento 8
// versao 3
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#define
#define
#define
#define
#define
#define

TXB
RXB
DLL
DLM
LCR
LSR

0x3F8
0x3F8
0x3F8
0x3F9
0x3Fb
0x3FD

void MENSAGENS(int m, int ct);

void INICIALIZA_SERIAL(void);
void SERIAL_TXB (void);
void SERIAL_RXB (void);
int caracter = 0; /*Caractere recebido*/
void main (){
MENSAGENS(1,0);
INICIALIZA_SERIAL();
while(caracter != 0x1B){/* Executa enquanto no ESC */
if(kbhit() != 0){ /*Se uma tecla pressionada*/
SERIAL_TXB();
}
else{ /* Se no h tecla*/
SERIAL_RXB();
}
}
MENSAGENS(2,0);
}// fim main

void INICIALIZA_SERIAL (void){

/*Habilita acesso ao divisor - 10000000*/
outportb(LCR, 0x80); /*DLAB = 1 autoriza o acesso*/
/*Atualizao dos divisores*/
outportb(DLM, 0);/*menos significativo*/
outportb(DLL, 12); /*mais significativo*/

41

/*habilita recepcao e transmissao e programa de paridade e bit de parada*/

outportb(LCR, 7); /*8 bits, 2 stops e sem paridade*/
//MENSAGENS(3,0);
}// fim inicializa serial
void SERIAL_TXB (void){
caracter = getch(); /* Recebe o caractere*/
//MENSAGENS(4,caracter);
/*Rotina para enviar catacter*/
outportb(TXB, caracter); /* Transmite pela porta serial*/
while ((inportb(LSR)&0x20) == 0);/* THRE=1 quando byte j foi. */
/*Retorna a 0 automaticamente apos a leitura*/
}// fim serial recebe
void SERIAL_RXB (void){
//MENSAGENS(5,0);
/*Rotina para receber catacter*/
if((inportb(LSR)&1)!=0){ /*Se DR=1, dado est pronto*/
caracter = inportb(RXB);
/* Recebe pela porta serial*/
if(caracter==0x0D){
/* Se ENTER for pressionada -> Carriage Return (0DH)*/
MENSAGENS(6,0);
}else {
/* Se no, printa caractere*/
MENSAGENS(7,caracter);
}//if-esle
}//if
}// fim serial transmite
void MENSAGENS(int m, int ct){
switch (m){
case 1:
printf("Inicio da transmissao\n");
break;
case 2:
printf("Fim da transmissao\n");
break;
case 3:
printf("Comunicao serial habilitada\n");
break;
case 4:
printf("Enviando caracter via SERIAL:");
printf("%c", ct);
printf("\n");
break;
case 5:
printf("Recendo caracter via SERIAL:\n");
break;
case 6:
printf("\n"); /*Line Feed (0AH).*/
break;
case 7:
printf("%c", ct);
break;

42

default:
printf("...\n");
}// fim switch case
}// fim das mensagens

43

Linguagem C
Comandos

Switch Case
switch (varivel)
{
case constante1:
Instrues;
break;

44

case constante2:
Instrues;
break;

default
Instrues;
}

Farmalloc
#include<alloc.h>
void *farmalloc (unsigned long nbytes);

farmalloc reserva um bloco de memria de tamanho n bytes do heap

45

IO

if(inportb(LSR)&1)==1){canal_ad =inport(RXB)}

void serial(void){

outportb(IER,1); //habilita interrupo

outportb(MCR,8); // out2 = 1

//habilita recepo e transmisso e programa paridade e bits

de parada
outportb(LCR,7); // 8 bits, sem paridade, 2 stops

//progamar DLAB = 1 e LCR =0x2FB

//habilita acesso ao divisor

//inicializao prepara_serial
int n = 115200/9600;

IOR -> in (l) e IOW ->out (escreve)

int ler_adc(){if((inportb(CS1)&0x80)==0){return0;}
else{val_ad = inportb(CS2); return 1;}

outportb(DLL,n); //lsb BR e DLL = 0x2F8

outportb(DLM,n>>8); //msb BR e DLL = 0x2F9

SERIAL

//atualizao dos divisores

Transceiver

outportb(LCR,0x80);

Latch
Transmiter
ou receiver

TEMPORIZADOR

40h
41h
42h
43h

PREPARA 8253/8254
N = 2E6/taxa
outportb(CS0+6,0x36);
outportb(CS0,N); /*Carga byte LSB*/
outportb(CS0,N>>8); /*Carga byte LSB*/

Rotinas para transmitir e receber caracteres:

/*Rotina para transmitir caracter*/
while(!(inport(0x2FD)&0x20));/*aguarda o bit THREE ir para 1*/
ouportb(0x2f8,caracter);/*escreve no regist. de transmisso*/

/*1: Definio da operao: canal 2, modo 3 e divisor freq.0180h*/

outportb(0x43,0xB6); /*Escrita da palavra de controle 10110110*/
/*2 Carga do divisor de frequncia no endereo do canal 2*/
outportb(0x42,0x80); /*Carga byte LSB*/
outportb(0x42,0x01); /*Carga byte LSB*/

/*Rotina para receber caracter*/

while(!(inport(0x2FD)&0x01));/*aguarda o bit DR ir para 1*/
caracter = inportb(0x2f8);/*l dado recebido*/

46

while((inport(0x379)&0x80)==0);/*1 aguarda a impressora ficar desocupada*/

outportb(0x378,caracter);/*2 disponibiliza o caracter*/
/*3 gerar um pulso de strobe*/
/*Deve-se manter *SLCT IN em baixo, *INT em alto e *AUTO FEED em alto*/
outportb(0x37A,0x0D);/*abaixa o *STROBE*/
outportb(0x37A,0x0C);/*levanta o *STROBE*/
Interrupo via *ACK substitui as ultimas duas linhas por:
outportb(0x37A,0x1D);/*abaixa o *STROBE, habilitando interrupo*/
outportb(0x37A,0x1C);/*levanta o *STROBE, habilitando interrupo*/

PARALELA
Para PC se conectar com impressoras paralelas. Composta por 3
registradores.
Pode ser usada como entrada ou sada. 3 modos de operao SPP, EPP,
ECP. Endereos consagrados: 378H, 278H ou 3BCH.

Rotina para transmitir um caractere para impressora via LPT1:

CONCEITOS
Relao entre o tamanho do cache e o desempenho do processador: quanto
maior o tamanho do cache, maior vai ser o nmero de dados que o processador
no precisar trabalhar com a memria DRAM, mais lenta. Porm, se o tamanho
do cache for igual ao da memria principal, o motivo pela qual ela foi
implementada ter sido em vo pois ela gasta mais potncia prejudicando o
desempenho do processador. Ou seja, existe um limite para o aumento de
desempenho e, portanto, no linear a relao.
Um processador que usa pipeline com grande nmero de estgios precisa de
um bom preditor de desvios: Porque se errar o prognstico, ocorre um desvio
desnecessrio, perde-se tudo que havia no pipeline tendo, assim, que esperar
uma nova instruo levando um tempo que poderia ter sido usado para fazer
vrias, a quantidade de estgios , instrues.
Porque existe grande relao entre um processador RISC e seu compliador: O
compilador fica a cargo de organizar o conjunto de instrues RISC, que ocorrem
em paralelo, para que o mundo externo perceba-as como sequnciais. A
complexidade do programa foi transferida para o compilador.
Porque os fabricantes de processadores no levam de uma vez o relgio de seus
processadores para 10GHz: Porque o tempo de acesso das memrias e
perifricos ainda no to rpido por limitaes fsicas (corrente de fuga,
dissipao de calor, interferncia eletromagntica, reflexo pelas linhas, retardo
introduzido pelos Cis).

47

DRAM: Alta densidade integrao Baixo consumo Pouco calor Baixo

custo Baixa velocidade Esquece(uso de refresh) T acesso = 5 a 70 ns SRAM :
20ns
CACHE: CPUs muito mais rpidas que as memrias (DRAM).
MDIA MVEL
Inicializa tudo que for necessrio
void preps (int canal, int taxa, int bps){
prepara_canal();
prepara_8253();/*taxa*/
prepara_serial();/*bps*/apaga_EOC();}
prepara_canal(){ escreva zero no valor de CSX[ativa ALE ADC0808]l ; e zero}
prepara_8253(){
escreva o valor controle no CSX[ativa /CS 8253]+ 6 // elimina bit 7
n = 200000/taxa
escreva n no CSX[ativa /CS 8253])
escreva n>>8 no CSX[ativa /CS 8253])
}
Prepara_serial(){
Escreve 0x80 no LCR
n=115200/bps
Escreve n no DLL
Escreve n>>8 no DLM
Escreve 0x00, 0x01,0x02 ou 0x03 no LCR}
Se bit EOC_OK=1 ento l ADC, atualiza val_ad e retorna 1, seno retorna 0.
int le_ADC{
se (CS1 estiver ok){
pegue (l) o valor de CS2 e guarde em numa varivel
escreva no CS2 (+ mudana no canal) o valor zero
retorne 1}
caso contrrio {retorne 0}}
Atualiza o DAC com o novo valor da mdia e ainda a envia pela porta serial.
void escr_dac (void){
escreve (transmite) em CS1 o valor da mdia
escreve (transmite) em TXB o valor da mdia}
Verifica se chegou o nmero do novo canal do ADC e atualiza a varivel
canal_ad.
void rec_serial (void){
se o valor LSR (l valor) AMND 1 for igual a 1{
pegue (l) o valor de RXB e guarde em numa varivel(canal_ad) }}
Verifica as chaves, para (congela) tudo enquanto CH0 estiver pressionada e
ainda incrementa o nmero do canal do ADC a cada acionamento de CH1.
void chaves (void){
enquanto se l o valor de CS1 e for zero fique parado
pegue (l) o valor de CS1 e guarde em numa varivel(chave)
se varivel chave na posio para mudar o canal{
varivel(canal_ad) ++
faa um and com 7 ( garante 1 em uma das ultimas 3 posies de dados)
faa a chave voltar para posio inicial para no ficar mudando de
posio}
se o valor lido for o para habilitar o EOC{
faa a chave igual o valor para habilitar o EOC}}
PORTA PARALELA
int le_ad (int qual_ad, int canal){

se qual_ad for igual a zero{// canal e ale

escreva canal&7 no valor 0X37A
escreva XX no valor 0X37A; escreva XX no valor 0X37A
enquanto (l 0x037A&8 for igual XX)
escreva XX no valor 0X378
l 0x379 e guarde numa varivel X; l 0x37A e guarde numa varivel Y;
x = x^0x80; y=y^3; retorne x&0xF8+(y&3)}
Prova treino: Usar mux e usar
decoder; usar bits de expanso

48