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 MB)
29 páginas
5Números de download
1000+Número de visitas
1Número de comentários
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
3 shown on 29 pages
baixar o documento
Esta é apenas uma pré-visualização
3 shown on 29 pages
baixar o documento
Esta é apenas uma pré-visualização
3 shown on 29 pages
baixar o documento
Esta é apenas uma pré-visualização
3 shown on 29 pages
baixar o documento

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

comentários (1)
Esta é apenas uma pré-visualização
3 shown on 29 pages
baixar o documento