Arquitetura de Computadores, Teses de Análise e Design de Sistemas de Informação
samara.santos.18400
samara.santos.1840027 de Setembro de 2014

Arquitetura de Computadores, Teses de Análise e Design de Sistemas de Informação

PDF (1.3 MB)
29 páginas
1Números de download
1000+Número de visitas
Descrição
Trabalho sobre Arquitetura de Computadores
20pontos
Pontos de download necessários para baixar
este documento
baixar o documento
Pré-visualização3 páginas / 29
Esta é apenas uma pré-visualização
Consulte e baixe o documento completo
Esta é apenas uma pré-visualização
Consulte e baixe o documento completo
Pré-visualização finalizada
Consulte e baixe o documento completo
Esta é apenas uma pré-visualização
Consulte e baixe o documento completo
Esta é apenas uma pré-visualização
Consulte e baixe o documento completo
Pré-visualização finalizada
Consulte e baixe o documento completo

IFAM -CAMPUS MANAUS DISTRITO INDUSTRIAL

PROF.: VITOR BREMGARTNER

DISCIPLINA: ARQUITETURA DE

COMPUTADORES

ANTONIO MARCOS TEIXEIRA DE ARAUJO (TST)

RENATO DE SOUZA (TST)

RELATÓRIO DE LABORATÓRIO

EMU8086 - LINGUAGEM ASSEMBLY

Manaus – AM

JUL/2014

1. Hello World

nome "oi mundo"

; Neste exemplo imprime "Olá mundo!"

; escrevendo diretamente para a memória de vídeo.

; na memória vga: primeiro byte é o caráter ascii, byte que se segue é atributo

personagem.

; se você mudar o segundo byte, você pode mudar a cor das

; o personagem mesmo depois de ser impresso.

; atributo de caractere é um valor de 8 bits,

; altos 4 bits definido cor de fundo e baixos de 4 bits definir a cor de primeiro plano.

; hex cor bin

;

; 0 0000 preto

; 1 0001 azul

; 2 0010 verde

; 3 0011 cyan

; 4 0100 vermelho

; 5 0101 magenta

; 6 0110 marrom

; 7 0111 cinza claro

; 8 1000 cinza escuro

; 9 1001 luz azul

; uma luz verde 1010

; b 1011 ciano claro

; c 1100 luz vermelha

; d 1101 luz magenta

; e 1110 amarelo

; f 1111 branco

org 100h

; definir o modo de vídeo

mov ax, 3; 80x25 modo texto, 16 cores, 8 páginas (ah = 0, al = 3)

int 10h; fazê-lo!

; cancelar a piscar e permitir que todos os 16 cores:

mov ax, 1003h

mov bx, 0

int 10h

; registrador de segmento set:

mov ax, 0b800h

mov ds, ax

; imprimir "Olá mundo"

; primeiro byte é o código ascii, segundo byte é um código de cores.

mov [02h], 'H'

mov [04h], 'e'

mov [06h], 'l'

mov [08h], 'l'

mov [0AH], 'o'

mov [0Ch], ','

mov [0Eh], 'W'

mov [10h], 'o'

mov [12h], 'r'

mov [14h], 'l'

mov [16h], 'd'

mov [18h], '!'

; colorir todos os personagens:

mov cx, 12; número de caracteres.

mov di, 03h; começar a partir de byte após 'h'

c: mov [di], 11101100b; luz vermelha (1100) em amarelo (1110)

adicionar di, 2; pular próximo código ascii na memória vga.

laço c

; esperar para pressionar qualquer tecla:

mov ah, 0

int 16h

ret

2. My Code

org 100h

;apresentacao do prompt '?'

MOV AH,2h ;funcao para exibir caracter

MOV DL,'?' ;caracter '?'

INT 21H ;exibir

;entrada do caracter pelo teclado

MOV AH,1h ;funcao para leitura de caracter

INT 21H ;caracter e' lido em AL

MOV BL,AL ;salvando-o em BL

;movendo de linha

MOV AH,2 ;funcao DOS para exibir caracter

MOV DL,0DH ;caracter ASCII <CR> - return

INT 21H ;executando

MOV DL,0AH ;caracter ASCII <LF> - line feed

INT 21H ;executando

;exibindo na tela o caracter lido

MOV DL,BL ;recuperando o caracter salvo

INT 21H ;exibir

Ret

3. A

4. Add-Sub

Análise:

Linha 1 nomeamos o programa como “add-sub”.

Linha 3 iniciamos o programa após darmos um nome, organiza o offset.

Linha 5 atribui-se à al o valor 5, em binário 00000101b.

Linha 6 atribui-se à bl o valor 10, em hexadecimal 0AH ou binário 00001010b.

Linha 8 é feito a soma dos valores de al e bl, 5 + 10 = 15 (em decimal) ou =

0Fh (hexadecimal) ou = 00001111b (binário).

Linha 10 realiza a subtração de 1 em 15, 15 - 1 = 14 (decimal) ou = 0Eh

(hexadecimal) ou = 00001110b (binário).

Linha 12 impressão, mostra o resultado de nossa operação em binário.

Linha 13 função para impressão.

Linha 15 teste do primeiro bit, atribuido à bl.

Linha 22 imprimiu-se o sufixo binário.

Linha 25 espera que o usuário venha pressionar qualquer tecla.

E encerramos o código na linha 28, retorna para o código.

Na pequena tela preta vemos o resulato 14 mostrado em binário.

5. Traffic Lights

; controlar um dispositivo externo com microprocessador 8086.

; teste realista para c: \ emu8086 \ devices \ Traffic_Lights.exe

# start = Traffic_Lights.exe #

nome "tráfego"

mov ax, all_red

a 4, machado

mov si, situação compensada

em seguida:

mov ax, [si]

a 4, machado

; aguarde 5 segundos (5 milhões de microssegundos)

mov cx, 4Ch; 004C4B40h = 5000000

mov dx, 4B40h

mov ah, 86h

int 15h

adicionar si, 2; seguinte situação

cmp si, sit_end

jb próximo

mov si, situação compensada

jmp próximo

; FEDC_BA98_7654_3210

situação dw 0000_0011_0000_1100b

s1 dw 0000_0110_1001_1010b

s2 dw 0000_1000_0110_0001b

s3 dw 0000_1000_0110_0001b

s4 dw 0000_0100_1101_0011b

sit_end = $

all_red equ 0000_0010_0100_1001b

6. = Led Display Test

; este exemplo mostra como acessar portas virtuais (0 a 65535).

; essas portas são emulados neste arquivo: c: \ emu8086.io

; esta tecnologia permite fazer dispositivos add-on externos

; para emu8086, tais como indicadores LED, robôs, termômetros, de passo-motores,

etc .. etc ..

; qualquer pessoa pode criar um dispositivo virtual animado.

; c: \ emu8086 \ devices \ led_display.exe

# start = led_display.exe #

# # make_bin

nome "LED"

mov ax, 1234

a 199, machado

mov ax, -5678

a 199, machado

; Laço eterno de escrever

; valoriza a porta:

mov ax, 0

x1:

a 199, machado

inc machado

jmp x1

HLT

7. Stepper Motor

; este é um exemplo de instruções para fora.

; ele grava valores para I / O Virtual porto

; que controla o passo-a motor.

; c: \ \ emu8086 dispositivos \ stepper_motor.exe está na porta 7

# start = stepper_motor.exe #

nome "passo"

# # make_bin

steps_before_direction_change = 20h; 32 (decimal)

jmp início

; ========= =============== Dados

; dados bin para ponteiros do relógio

; rotação meio-passo:

datcw db 0000_0110b

db 0000_0100b

db 0000_0011b

db 0000_0010b

; dados bin para contra-relógio-wise

; rotação meio-passo:

datccw db 0000_0011b

db 0000_0001b

db 0000_0110b

db 0000_0010b

; dados bin para ponteiros do relógio

; rotação completa-passo:

datcw_fs db 0000_0001b

db 0000_0011b

db 0000_0110b

db 0000_0000b

; dados bin para contra-relógio-wise

; rotação completa-passo:

datccw_fs db 0000_0100b

db 0000_0110b

db 0000_0011b

db 0000_0000b

start:

bx mov, datcw compensados; iniciar a partir de meia-passo no sentido horário.

mov si, 0

mov cx, 0; contador de passos

next_step:

; Motor define top pouco quando ele está pronto para aceitar novo comando

esperar: em al, 7

Teste ai, 10000000b

jz esperar

mov al, [bx] [si]

a 7, al

inc si

cmp si, 4

jb next_step

mov si, 0

inc cx

cmp cx, steps_before_direction_change

jb next_step

mov cx, 0

adicionar bx, 4; próximo dados bin

cmp bx, offset datccw_fs

jbe next_step

bx mov, datcw compensados; voltar ao meio-passo no sentido horário.

jmp next_step

8. Bin2Dec.asm

; input8 mordeu número binário e imprimir decimal para a tela.

; zeros e uns -> valor decimal

ORG 100h

; macro

; esta macro imprime um caractere em AL e avança

; a posição atual do cursor:

Putc caractere MACRO

TOQUE AX

MOV AL, char

MOV AH, 0Eh

INT 10h

POP AX

ENDM

. dados

; nulo cadeia de entrada terminados:

DB "0"

s1 DB "00000000", 0

Resumindo DW 0; resultado.

bandeira DB 0

. código

impressão CHAMADA

DB 0DH, 0AH, "binário de 8 bits:", 0

; obter string:

MOV DX, 9; tamanho do buffer (1 + para zero, terminator).

LEA DI, s1

get_string CHAMADA

; verifique se realmente tem oito zeros e uns

MOV CX, 8

MOV SI, OFFSET s1

check_s:

CMP [SI], 0

ok0 JNE

Bandeira MOV, 1; terminada.

JMP converso

ok0:

CMP [SI], 'b'

ok1 JNE

Bandeira MOV, 1; terminada.

JMP converso

ok1:

; dígito errado? Não é de 1/0?

CMP [SI], 31h

OK2 JNA

JMP error_not_valid

OK2:

INC SI

check_s LOOP

; iniciar a conversão de string para valor na variável SUM.

converter:

MOV BL, 1; multiplicador.

MOV CX, SI

SUB CX, DESVIO s1

dezembro SI

JCXZ stop_program

next_digit:

MOV AL, [SI]; obter dígito.

SUB AL, 30h

MUL BL; nenhuma mudança para AX.

ADD SUM, AX

SHL BL, 1

Dezembro SI; ir para o dígito anterior.

LOOP next_digit

; feito! número convertido é SUM.

; verificar se assinado

Soma TEST, 0000_0000_1000_0000b

JNZ print_signed_unsigned

print_unsigned:

impressão CHAMADA

DB 0DH, 0AH, "decimal:", 0

MOV AX, SUM

PRINT_NUM_UNS CHAMADA

JMP stop_program

print_signed_unsigned:

impressão CHAMADA

0DH DB, 0AH ", decimal não assinado:", 0

; imprimir sem sinal:

MOV AX, SUM

PRINT_NUM_UNS CHAMADA

impressão CHAMADA

DB 0DH, 0AH ", assinado decimal:", 0

; imprimir chamuscado:

MOV AX, SUM

CBW; converter byte na palavra.

PRINT_NUM CHAMADA

JMP stop_program

error_not_valid:

impressão CHAMADA

DB 0DH, 0AH, "Erro: Apenas zeros e uns são permitidos", 0

stop_program:

; esperar por qualquer tecla ....

impressão CHAMADA

DB 0DH, 0AH ", pressione qualquer tecla ...", 0

MOV AH, 0

INT 16h

RET

; procedimentos

; copiado de c: \ emu8086 \ emu8086.inc

Get_string PROC NEAR

TOQUE AX

TOQUE CX

TOQUE DI

TOQUE DX

MOV CX, 0; balcão de char.

CMP DX, 1; Buffer muito pequeno?

JBE empty_buffer;

Dezembro DX; reserva espaço para o último zero.

; ============================

; loop para obter e processar pressionamento de teclas:

wait_for_key:

MOV AH, 0; obter tecla pressionada.

INT 16h

CMP AL, 13; "Retorno" pressionado?

saída JZ

CMP AL, 8; 'Retrocesso' pressionado?

JNE add_to_buffer

JCXZ wait_for_key; nada para remover!

dezembro CX

dezembro DI

Putc 8; backspace.

Putc ''; posição clara.

Putc 8; retroceder novamente.

JMP wait_for_key

add_to_buffer:

CMP CX, DX; buffer está cheio?

JAE wait_for_key; se assim for esperar 'BACKSPACE' ou 'retorno' ...

MOV [DI], AL

INC DI

INC CX

; imprimir a chave:

MOV AH, 0Eh

INT 10h

JMP wait_for_key

; ============================

saída:

; terminar por nulo:

MOV [DI], 0

empty_buffer:

POP DX

DI POP

POP CX

POP AX

RET

get_string ENDP

; copiado de c: \ emu8086 \ emu8086.inc

PRINT_NUM PROC NEAR

TOQUE DX

TOQUE AX

CMP AX, 0

JNZ not_zero

Putc '0 '

JMP printed_pn

not_zero:

; o sinal de verificação de AX,

; tornar absoluto se é negativo:

CMP AX, 0

JNS positivos

NEG AX

Putc '-'

positivo:

PRINT_NUM_UNS CHAMADA

printed_pn:

POP AX

POP DX

RET

ENDP

; copiado de c: \ emu8086 \ emu8086.inc

PRINT_NUM_UNS PROC NEAR

TOQUE AX

IMPULSO BX

TOQUE CX

TOQUE DX

; bandeira para evitar zeros antes do número de impressão:

MOV CX, 1

; (resultado de "/ 10000" é sempre menor ou igual a 9).

MOV BX, 10000; 2710h - divisor.

; AX é zero?

CMP AX, 0

JZ print_zero

begin_print:

; verificar divisor (se nula ir para end_print):

CMP BX, 0

JZ end_print

; evitar a impressão de zeros antes do número:

CMP CX, 0

JE calc

; se AX <BX então resultar de DIV será zero:

CMP AX, BX

JB pular

calc:

MOV CX, 0; definir bandeira.

MOV DX, 0

DIV BX; AX = DX: AX / BX (DX = resto).

; imprimir último dígito

; AH é sempre zero, por isso é ignorado

ADD AL, 30h; converter em código ASCII.

putc AL

MOV AX, DX; obter restante da última div.

pular:

; calcular BX = BX/10

TOQUE AX

MOV DX, 0

MOV AX, BX

DIV CS: dez; AX = DX: AX / 10 (DX = resto).

MOV BX, AX

POP AX

JMP begin_print

print_zero:

Putc '0 '

end_print:

POP DX

POP CX

POP BX

POP AX

RET

dez DW 10; utilizado como divisor.

ENDP

; imprimir texto que se segue o chamador

impressão PROC

MOV CS: temp1, SI; SI registo loja.

POP SI; obter o endereço de retorno (IP).

IMPULSO AX; loja AX registo.

next_char:

MOV AL, CS: [SI]

INC SI; byte seguinte.

CMP AL, 0

JZ printed_ok

MOV AH, 0Eh; função de teletipo.

INT 10h

JMP next_char; loop.

printed_ok:

POP AX; re-store registo AX.

; SI deve apontar para o próximo comando após

; a instrução CALL e string de definição:

TOQUE SI; salvar novo endereço de retorno na pilha.

MOV SI, CS: temp1; re-store SI registrar.

RET

temp1 DW? ; variável para armazenar o valor original do SI registo.

ENDP

9.fazer um programa para ler dois valores pelo teclado,adiciona~lo e mostrar o

resultado no display de 7-segmentos.

TITLE Numero

.MODEL SMALL

.STACK 100H

.DATA

MSG1 DB 'Digite:','$'

MSG2 DB ' Digite:','$'

MSG3 DB ' A soma e:','$'

NUMERO1 Dw ?

Dw ?

NUMERO2 Dw ?

Dw ?

.CODE

MOV AX,@DATA

MOV DS,AX

;numero 1

LEA DX,MSG1

MOV AH,9

INT 21H

XOR BX,BX

XOR SI,SI

MOV CX,1

M1: MOV AH,1

INT 21H

MOV NUMERO1,Ax

MOV AH,2

INT 21H

ADD SI,2

DEC CX

JNZ M1

MOV CX,1

ADD BX,1

MOV AX,1

CMP BX,AX

;numero 2

LEA DX,MSG2

MOV AH,9

INT 21H

XOR BX,BX

XOR SI,SI

MOV CX,1

M2: MOV AH,1

INT 21H

MOV NUMERO2,Ax

MOV AH,2

INT 21H

ADD SI,2

DEC CX

JNZ M2

MOV CX,1

ADD BX,1

MOV AX,1

CMP BX,AX

;somando

LEA DX,MSG3

MOV AH,9

INT 21H

XOR BX,BX

XOR SI,SI

MOV CX,1

SOMA: XOR DX,DX

XOR AX,AX

MOV DX,NUMERO1

MOV AX,NUMERO2

ADD AX,DX

SUB AX,30H

MOV DX,AX

MOV AH,2

INT 21H

INT 21H

ADD SI,2

DEC CX

JNZ SOMA

MOV CX,1

ADD BX,1

MOV AX,1

CMP BX,AX

MOV AH,4CH

INT 21H

End

10. adapte o programa “stepper_motor”, do emu8086,para que o motor fique

girando 10 vezes para um lado e 10 vezes para o outro lado,ininterruptamente.

; este é um exemplo de instruções para fora.

; ele grava valores para I / O Virtual porto

; que controla o passo-a motor.

; c: \ \ emu8086 dispositivos \ stepper_motor.exe está na porta 7

# start = stepper_motor.exe #

nome "passo"

# # make_bin

steps_before_direction_change = 50h; 80 (decimal) (OBS: AQUI MUDA A

ROTAÇÃO DO MOTOR,10 PARA VEZES PARA UM LADO E 10 VEZES

PARA OUTRO LADO)

jmp início

; ========= =============== Dados

; dados bin para ponteiros do relógio

; rotação meio-passo:

datcw db 0000_0110b

db 0000_0100b

db 0000_0011b

db 0000_0010b

; dados bin para contra-relógio-wise

; rotação meio-passo:

datccw db 0000_0011b

db 0000_0001b

db 0000_0110b

db 0000_0010b

; dados bin para ponteiros do relógio

; rotação completa-passo:

datcw_fs db 0000_0001b

db 0000_0011b

db 0000_0110b

db 0000_0000b

; dados bin para contra-relógio-wise

; rotação completa-passo:

datccw_fs db 0000_0100b

db 0000_0110b

db 0000_0011b

db 0000_0000b

start:

bx mov, datcw compensados; iniciar a partir de meia-passo no sentido horário.

mov si, 0

mov cx, 0; contador de passos

next_step:

; Motor define top pouco quando ele está pronto para aceitar novo comando

esperar: em al, 7

Teste ai, 10000000b

jz esperar

mov al, [bx] [si]

a 7, al

inc si

cmp si, 4

jb next_step

mov si, 0

inc cx

cmp cx, steps_before_direction_change

jb next_step

mov cx, 0

adicionar bx, 4; próximo dados bin

cmp bx, offset datccw_fs

jbe next_step

bx mov, datcw compensados; voltar ao meio-passo no sentido horário.

jmp next_step

comentários (0)
Até o momento nenhum comentário
Seja o primeiro a comentar!
Esta é apenas uma pré-visualização
Consulte e baixe o documento completo
Docsity is not optimized for the browser you're using. In order to have a better experience we suggest you to use Internet Explorer 9+, Chrome, Firefox or Safari! Download Google Chrome