Assembler 8086

Dreyk · Napísal **Dreyk**: 17.05.2009 16:52

Zdar potreboval by som poradit ako vyriesit toto :

Nacitajte z klavesnice retazec znakov ukoncenych znakom konca riadku. Vstup spracuva ako retazec cislic. Nech tento retazec predstavuje cele cislo v sestnastkovej sustave. Zobrazte toto cislo v binarnom doplnkovom kode na 12 bitoch.

Zaujima ma hlavne zdrojovy kod

Dik

shiro · Napísal **shiro**: 17.05.2009 17:40

na domace ulohy mas pouzivat vlastnu hlavu, inac do skoly kde chodis ani chodit nemusis.

Fico · Napísal **Fico**: 17.05.2009 18:18

Nech sa páči

(neprišiel som na jednoduchšie riešenie, sorry)

Kód:

.MODEL small
.STACK 100h

.DATA

    vypis1 DB 'Hexadecimal:', 13, 10, 24h
    vypis2 DB 13, 10, 'Binary:', 13, 10, 24h
    
    retazec DB 08h, 0, 9 dup(24h)   ; 8 znakov + '$'
    
    _0 DB 30h, 30h, 30h, 30h, 24h
    _1 DB 30h, 30h, 30h, 31h, 24h
    _2 DB 30h, 30h, 31h, 30h, 24h
    _3 DB 30h, 30h, 31h, 31h, 24h
    _4 DB 30h, 31h, 30h, 30h, 24h
    _5 DB 30h, 31h, 30h, 31h, 24h
    _6 DB 30h, 31h, 31h, 30h, 24h
    _7 DB 30h, 31h, 31h, 31h, 24h
    _8 DB 31h, 30h, 30h, 30h, 24h
    _9 DB 31h, 30h, 30h, 31h, 24h
    _A DB 31h, 30h, 31h, 30h, 24h
    _B DB 31h, 30h, 31h, 31h, 24h
    _C DB 31h, 31h, 30h, 30h, 24h
    _D DB 31h, 31h, 30h, 31h, 24h
    _E DB 31h, 31h, 31h, 30h, 24h
    _F DB 31h, 31h, 31h, 31h, 24h
  
.CODE

start:

    mov ax, @data
    mov ds, ax
    
    mov ah, 09h
    lea dx, vypis1
    int 21h
    
    mov ah, 0Ah         ; nacitanie retazca
    lea dx, retazec
    int 21h
    
    mov ah, 09h
    lea dx, vypis2
    int 21h
    
    lea bx, retazec
    inc bx
    xor cx, cx
    mov cl, BYTE PTR [bx]
    inc bx

    xor si, si
    
main_loop:

    cmp BYTE PTR [bx+si], 30h
    jne l1
    mov ah, 09h
    lea dx, _0
    int 21h
    jmp lend
    
l1:
    cmp BYTE PTR [bx+si], 31h
    jne l2
    mov ah, 09h
    lea dx, _1
    int 21h   
    jmp lend

l2:
    cmp BYTE PTR [bx+si], 32h
    jne l3
    mov ah, 09h
    lea dx, _2
    int 21h    
    jmp lend

l3:
    cmp BYTE PTR [bx+si], 33h
    jne l4
    mov ah, 09h
    lea dx, _3
    int 21h     
    jmp lend

l4:
    cmp BYTE PTR [bx+si], 34h
    jne l5
    mov ah, 09h
    lea dx, _4
    int 21h       
    jmp lend

l5:
    cmp BYTE PTR [bx+si], 35h
    jne l6
    mov ah, 09h
    lea dx, _5
    int 21h   
    jmp lend

l6:
    cmp BYTE PTR [bx+si], 36h
    jne l7
    mov ah, 09h
    lea dx, _6
    int 21h    
    jmp lend

l7:
    cmp BYTE PTR [bx+si], 37h
    jne l8
    mov ah, 09h
    lea dx, _7
    int 21h    
    jmp lend

l8:
    cmp BYTE PTR [bx+si], 38h
    jne l9
    mov ah, 09h
    lea dx, _8
    int 21h   
    jmp lend

l9:
    cmp BYTE PTR [bx+si], 39h
    jne lA
    mov ah, 09h
    lea dx, _9
    int 21h    
    jmp lend

lA:
    cmp BYTE PTR [bx+si], 41h
    je la_write
    cmp BYTE PTR [bx+si], 61h
    jne lB
    
  la_write:

    mov ah, 09h
    lea dx, _A
    int 21h    
    jmp lend

lB:
    cmp BYTE PTR [bx+si], 42h
    je lb_write
    cmp BYTE PTR [bx+si], 62h
    jne lC
    
  lb_write:
    mov ah, 09h
    lea dx, _B
    int 21h    
    jmp lend

lC:
    cmp BYTE PTR [bx+si], 43h
    je lc_write
    cmp BYTE PTR [bx+si], 63h
    jne lD
    
  lc_write:
    mov ah, 09h
    lea dx, _C
    int 21h   
    jmp lend

lD:
    cmp BYTE PTR [bx+si], 44h
    je ld_write
    cmp BYTE PTR [bx+si], 64h
    jne lE
    
  ld_write:
    mov ah, 09h
    lea dx, _D
    int 21h   
    jmp lend

lE:
    cmp BYTE PTR [bx+si], 45h
    je le_write
    cmp BYTE PTR [bx+si], 65h
    jne lF
    
  le_write:
    mov ah, 09h
    lea dx, _E
    int 21h    
    jmp lend

lF:
    cmp BYTE PTR [bx+si], 46h
    je lf_write
    cmp BYTE PTR [bx+si], 66h
    jne lend
    
  lf_write:
    mov ah, 09h
    lea dx, _F
    int 21h       
    
lend:

    inc si
    loop main_loop
    
    mov ax, 4C00h
    int 21h
    
end start

citro · Napísal **citro**: 18.05.2009 11:39

Program nacita retazec a hlada slovo ktore som definoval v programe. Moze mi niekto poradit ako a kde mam dat slucku, aby nehladalo len jedno slovo ale viac (napr. 10) ? Zatial hladal slovo len o dlzke 5 znakov, keby som chcel hladat slova s roznou dlzkov znakov ako to urobit? Vopred dakujem za rady

Kód:

; -----------------------------
; Startovacia hlavicka pre TASM
; -----------------------------

.model small
.stack 100h

.data

zadaj_retazec   db 'Zadajte retazec : $' 
pocet_slov   db 'Pocet slov : $'
z1      db 0
z2      db 0
z3      db 0
z4      db 0
z5      db 0

.code

put_char proc
mov ah, 02h
int 21h
ret
put_char endp

put_string proc
mov ah, 09h
int 21h
ret
put_string endp

get_char proc
mov ah, 01h
int 21h
ret
get_char endp

new_line proc
mov dl, 10
call put_char
mov dl, 13
call put_char
ret
new_line endp

start:

mov ax, @data      ; inicializacia data segmetu
mov ds, ax
mov ah, 0h
mov al, 7h
int 10h         ; vymazanie obrazovky, nastavenie 80x25

mov dx, offset zadaj_retazec
call put_string
call new_line

mov cl, 0h       ; cl    - pocitadlo spravnych slov

next_word:

mov ch, 0h      ; ch    - stavove slovo
         ;  0    - nic nie je nacitane
         ;  1   - neobsahuje retazec
         ;  2    - obsahuje retazec

mov z1, ch      ; vynulujeme nacitane znaky
mov z2, ch
mov z3, ch
mov z4, ch
mov z5, ch

read_char:      ; nacitanie znaku & jeho vyhodnotenie

cmp cl, 255      ; mame uz plny register
je write_result

call get_char
cmp al,13      ; test na koniec riadku 13 = '\n'
je end_of_read

cmp al,32      ; test na koniec slova 32 = ' '
je end_of_word

mov ah, z2      ; prehodime znaky 2 -> 1, 3 -> 2, 4 -> 3, 4 ->4
mov z1, ah
mov ah, z3
mov z2, ah      
mov ah, z4
mov z3, ah
mov ah, z5
mov z4, ah
mov z5, al      ; nacitany znak -> 5

cmp ch, 0h      ; ak sme este nic nenacitali
jne detect_word
mov ch, 1h      ; zmenime stav

detect_word:

cmp z1, 'b'      ; ak mame nacitane pismena b, r, e ,a, k
jne read_char
cmp z2, 'r'
jne read_char
cmp z3, 'e'
jne read_char
cmp z4, 'a'
jne read_char
cmp z5, 'k'
jne read_char
mov ch, 2h      ; zmenime stav
jmp read_char

end_of_word:       ; koniec slova

cmp ch, 2      ; je spravne ?
jne next_word      ; ak nie, citame dalsie slovo
inc cl         ; inak zaratame dalsie dobre slovo
jmp next_word

end_of_read:            ; koniec riadku

cmp ch, 2      ; posledne slovo musime tiez ohodnotit na spravnost - bolo spravne ?
jne write_result   ; tak nie :)
inc cl         ; zaratame dalsie slovo

write_result:      ; vypis vysledku

call new_line
mov dx, offset pocet_slov
call put_string
         ; vypis poctu slov na obrazovku
         ; musime previest hodnotu na desiatkovu
mov ch, 16      ; ulozime si najvacsi zaklad

convert:
mov ah, 00h             ; ulozime si hodnotu do ax
mov al, cl

div ch         ; vydelime zakladom
mov cl, ah      ; zvysok si ulozime ako pocet slov
mov dl, al      
cmp dl, 9      ; ak je hodnota < 9
jg alpha_value
add dl, '0'      ; posunieme tak, aby 0 bola ASCII '0'
jmp write_char
alpha_value:
add dl, 'A' - 9      ; inak tak, aby 0 bola ASCII 'A'
write_char:
call put_char      ; nasobok vytlacime

cmp ch, 1      ; ak je uz zaklad = 1 => uz sme previedli vsetky cifry
je end_of_write

mov ah, 0h      ; teraz musime zmensit zaklad
mov al, ch
mov dl, 16      ; 16x
div dl
mov ch, al      ; zvysok si ulozime
jmp convert      ; a pokracujeme

end_of_write:

call new_line

mov ax, 4c00h
int 21h
end start

Fico · Napísal **Fico**: 18.05.2009 15:20

Ak ti to nevadí, dovolil som si zjednodušiť tvoj kód , no máš to tak, ako si to popísal hore (v premennej reťazec je reťazec, ktorý požaduješ hľadať v zadanom texte. Počíta sa výskyt reťazca v celom texte). Počet slov je v CH, pridaj si tam svoj algoritmus na vypísanie, lebo nechcel som ti meniť úplne všetko

Kód:

; -----------------------------
; Startovacia hlavicka pre TASM
; -----------------------------

.model small
.stack 100h

.data

zadaj_retazec DB 'Zadajte retazec : $'
retazec DB 200, 0, 201 dup(24h)

nas_retazec DB 'break$'
dlzka DB 0

pocet_slov DB 'Pocet slov : $'

.code

put_char proc
mov ah, 02h
int 21h
ret
put_char endp

put_string proc
mov ah, 09h
int 21h
ret
put_string endp

get_string proc
mov ah, 0Ah
int 21h
ret
get_string endp

new_line proc
mov dl, 10
call put_char
mov dl, 13
call put_char
ret
new_line endp
               
               
get_length proc
push si    
push bx
xor si, si
xor ax, ax
mov bx, offset nas_retazec

l1:
cmp BYTE PTR [bx+si], 24h
je l2
inc si
inc al
jmp l1

l2:
mov dlzka, al
       
pop bx
pop si
ret
get_length endp     


start:

mov ax, @data      ; inicializacia data segmetu
mov ds, ax    

mov ah, 0h
mov al, 7h
int 10h         ; vymazanie obrazovky, nastavenie 80x25

mov dx, offset retazec
call get_string

mov bx, offset retazec
xor cx, cx      ; v ch bude pocet slov, v cl pocet spravnych pismen

inc bx
inc bx
mov bp, offset nas_retazec

call get_length

xor si, si
xor di, di


main:


cmp BYTE PTR [bx+si], 24h
je end_scaning

mov al, BYTE PTR ds:[bp+di]
cmp BYTE PTR [bx+si], al
jne nenasiel
   
nasiel:
      
       
inc cl  
cmp cl, dlzka
jne next
        
inc ch

nenasiel:

xor cl, cl
inc bx
xor si, si
xor di, di 
jmp main

next:

inc si
inc di
jmp main


end_scaning:



; pocet slov je v CH



mov ax, 4c00h
int 21h
end start 

citro · Napísal **citro**: 18.05.2009 19:11

jak skusam tak skusam, vypisat mi to nechce...nemohol by si mi to upravit aj s vypisom? A keby som chcel porovnavat 10 retazcov kam drbnut cyklus?

Fico · Napísal **Fico**: 18.05.2009 19:29

Použi túto procedúru - prvý parameter bude CX (nezabudni vynulovať register CL, pretože výsledok je uložený iba v CH), druhý parameter bude offset reťazca, do ktorého vypíšeš číslo (zadeklaruj si nový reťazec).

citro píše:

A keby som chcel porovnavat 10 retazcov?

To myslíš, že budeš porovnávať najprv reťazec "break", potom reťazec "xxx", atď ? Ak áno, tak bude nutná rozšírnejšia úprava:

Kód:

; -----------------------------
; Startovacia hlavicka pre TASM
; -----------------------------

.model small
.stack 100h

.data

zadaj_retazec DB 'Zadajte retazec : $'
retazec DB 200, 0, 201 dup(24h)

nas_retazec DB 'break$'     ; tie reťazce si pomenuj ako chceš, to bolo písané narýchlo
druhy_ret DB 'pause$'

dlzka DB 0

adresa00 DW 0
adresa01 DW nas_retazec
adresa02 DW druhy_ret
adresaFF DW 0

adresa DW adresa00

.code

put_char proc
mov ah, 02h
int 21h
ret
put_char endp

put_string proc
mov ah, 09h
int 21h
ret
put_string endp

get_string proc
mov ah, 0Ah
int 21h
ret
get_string endp

new_line proc
mov dl, 10
call put_char
mov dl, 13
call put_char
ret
new_line endp
               
get_length proc
push si    
push bx
xor si, si
xor ax, ax

mov bx, adresa ;offset nas_retazec
mov bx, [bx]

l1:
cmp BYTE PTR [bx+si], 24h
je l2
inc si
inc al
jmp l1

l2:
mov dlzka, al
       
pop bx
pop si
ret
get_length endp     


start:

mov ax, @data      ; inicializacia data segmetu
mov ds, ax    

search:

add adresa, 2
mov bx, adresa
mov bx, [bx]
cmp bx, 0
je end_prog

mov ah, 0h
mov al, 7h
int 10h         ; vymazanie obrazovky, nastavenie 80x25

mov dx, offset retazec
call get_string


mov bx, offset retazec
xor cx, cx      ; v ch bude pocet slov, v cl pocet spravnych pismen

inc bx
inc bx

mov bp, adresa ;offset nas_retazec
mov bp, ds:[bp]

call get_length

xor si, si
xor di, di

main:

cmp BYTE PTR [bx+si], 24h
je end_scaning

mov al, BYTE PTR ds:[bp+di]
cmp BYTE PTR [bx+si], al
jne nenasiel
   
nasiel:
       
inc cl  
cmp cl, dlzka
jne next
        
inc ch

nenasiel:

xor cl, cl
inc bx
xor si, si
xor di, di 
jmp main

next:

inc si
inc di
jmp main


end_scaning:

; tu si to vypíš

jmp search

end_prog:

mov ax, 4c00h
int 21h
end start

Vysvetlenie:

Pridaj si tam reťazcov, koľko potrebuješ (nie je to nejako obmedzené), no s každým pridaným reťazcom pridaj premennú typu DW (WORD), ktorá bude niesť adresu tohto reťazca. Adresy ale pridávaj medzi premenné adresa00 a adresaFF, pretože adresa reťazca, ktorý sa práve bude porovnávať je premennej adresa a tá sa každým cyklom zvýši o 2 (teda prejde na ďalšiu adresu). Ďalej sa o všetko postará program

Ak je nejaká nejasnosť tak sa kľudne pýtaj, lebo z toho popisu sa asi ťažko dá niečo pochopiť :lol:

dEVIANT · Napísal **dEVIANT**: 20.04.2010 16:07

sevas ,
kamarat by potreboval nieco podobne ako bol program hore s malymi zmenami, len tomu nerozumie a tak keby dakto mohol :
Nacitajte z klavesnice retazec znakov ukoncenych znakom konca riadku. Vstup spracujte ako retazec cislic. Nech tento retazec predstavuje cele cislo v sestnastkovej sustave. Zobrazte toto cislo v binarnom inverznom kode na 16 bitoch. v nasm
dikes

baky · Napísal **baky**: 27.04.2010 21:40

nazdar potreboval by som pomoct z programom ktory z klavesnice nacita retazec znakov ukoncenych znakom konca riadku a urci kolko slov obsahuje rovnake samohlasky ako prve slovo vratane prveho slova a vytlacit to treba dvojkovo
n

samqo · Napísal **samqo**: 07.05.2010 14:11

Ja by som len potreboval pomoc z delenimv 8086 ... ze konkretne ked chcem delit obsah registra 10 tak ako budu vyzerat kokretne prikazy ... lebo skusal som to ale nechce mi to stale zobrat kompilator ... je to pre NASM ... dik za dpoved komukolvek ...

good871 · Napísal **good871**: 08.05.2010 10:10

cawte potreboval by som surne pomoct s asm 8086 pre prekladac nasm. som sa 8080 naucil, ale toto mi ako si nejde. portrebujem spravit program ,kt nacita hexa cislo a ypise decimalne. mohol by mi niekto prosim napisat aspon jednoduchu kostru? vsetko ostatne si uz nejak dopisem, len neviem ako mam zacat, pre mna to je spanielska dedina. prosim

JR55 · Napísal **JR55**: 19.05.2010 22:38

mohol by mi niekto pomoct. Stale mi to hlasi chybu.
Zadanie:
Načítajte z klávesnice reťazec znakov ukončených znakom konca riadku. Slová vo vstupe sú oddelené najmenej jedným znakom medzera. Uvažujte aj prvé, resp. posledné slovo vstupu. Určte počet čísel menších ako 1. uvedené číslo reprezentovaných slovami. Počet vytlačte dvojkovo.

zdrojak:
%include "asm_io.inc"

segment .data

no1 times 2048 db 0

segment .bss
no2 resb 80

segment .text
global _asm_main

_asm_main:
enter 0,0
pusha
mov ebx,no1
mov edx,no2

mov ebx,0
mov ecx,0
mov edx,0

prve_pismeno:
call read_char
cmp al,20h
jz prve_pismeno
cmp al,0ah
jz koniec1
cmp al,30h
jc znak1
cmp al,40h
jnc znak1

prva_cislica1:
mov byte[edx],al
inc edx
call read_char
cmp al,0ah
jz koniec1
cmp al,20h
jnz dalsia_cislica1
jmp cele_cislo

cele_cislo:
inc cl
call read_char
cmp al,20h
jz cele_cislo
cmp al,0ah
jz koniec2
cmp al,30h
jc znak2
cmp al,40h
jnc znak2
jmp prva_cislica2

prva_cislica2:
mov byte[ebx],al
inc ebx
call read_char
cmp al,0ah
jz koniec2
cmp al,20h
jnz dalsia_cislica2
cmp ebx,edx
jnc nulovanie
inc cl
jmp nulovanie

koniec1:
add cl,'0'
mov eax,ecx
call print_string
popa
mov eax,0
leave
ret

koniec2:
cmp ebx,edx
jnc koniec1
inc cl
jmp koniec1

znak1:
call read_char
cmp al,0ah
jz koniec1
cmp al,20h
jz prve_pismeno
jmp znak1

dalsia_cislica1:
cmp al,30h
jz znak1
cmp al,40h
jnc znak1
jmp prva_cislica1

znak2:
call read_char
cmp al,0ah
jz koniec2
cmp al,20h
jz cele_cislo
jmp znak2

dalsia_cislica2:
cmp al,30h
jz znak2
cmp al,40h
jnc znak2
jmp prva_cislica2

nulovanie:
mov ebx,0
jmp cele_cislo

pls potreboval by som najst chybu a popripade pomoct s tym vytlacenim dvojkovo

Assembler 8086

Podobné témy