Assembler - Cyfra/Liczba Hex - zamiana na kod ASCII

0

Witam,
Walczę z takim problemem jak w temacie, jednak coś opornie mi to idzie. Jeśli można prosiłbym o pomoc.

segment .text
        global _start
_start: mov al, 0x20
        call hex_to_ascii
        call print_char
        mov al, 0ah
        call print_char
        mov eax, 1
        mov ebx, 0
        int 0x80

segment .bss
char    resb    1
segment .text
print_char:
        mov [char], al
        mov eax, 4
        mov ebx, 1
        mov ecx, char
        mov edx, 1
        int 0x80
        ret

hex_to_ascii:
        and al, 0Fh
        cmp al, 09h
        jbe label1
        add al, 07h
        label1:
        add al, 30h
        int 0x80
        ret
0

A co dokładnie chcesz zrobić i co nie działa?

0

Dokładniej:

  • podaje do rejestru AL liczbę w postaci szesnastkowej 0x0 - 0xF.
  • w wyniki (również w rejestrze AL) zwracany ma być odpowiedni kod ascii (chyba powinienem dodać 0x30??)
  • gdy podam liczbę większą niż 0xF powinien wypisać się ??
0

Ale zwracany jest kod ascii czego? Bo ja nadal nie rozumiem co ty chcesz dostać. Chcesz wypisać na ekran reprezentacje hex tej liczby? Tzn jak ktoś poda w al liczbę np. Ah albo po prostu 10 to na ekran chcesz wypisać A?
Jeśli tak to popatrz tutaj:
http://www.asciitable.com/index/asciifull.gif bo teraz robisz to zupełnie źle.

0

Właśnie tej części z treści tego zadania też nie zrozumiałem. Wygląda to mniej więcej tak, proszę o wskazówki nie całe rozwiązanie:

Napisać podprogram, który zamienia cyfrę szestnastkową na kod ASCII. Cyfra przekazywana
jest poprzez rejestr AL, a odpowiedni kod ASCII jest zwracany również poprzez
rejestr AL.Wprzypadku gdy wartość rejestru AL jest większa od 15 (maksymalna wartosc
dla cyfry szestnastkowej) w AL zwracany jest ’?’. Przetestować działanie podprogramu
dla wartości od 0 do 20 (używając pętle w programu głównego) wypisując zwracany znak.

0

Chyba chodzi o to, żeby wypisać 0x0 ---> 0 0x1 ---> 1 itd ??

0

Na oko chodzi o konwersje z tablicy ascii, czyli dla liczby 0 masz zwrócić znak 0 czyli liczbę 48. Patrz tablica znaków ascii którą pokazałem wyżej. To musisz zrobić w oparciu o 2 przypadki -> dla liczb 0-9 musisz po prostu dodać 48 a dla liczb 10-15 musisz dodać 55 tak żeby liczba 10 (czyli 0Ah) zamieniło sie na liczbę 55 czyli znak A w ascii.

0

Ok, to ma sens. Jeszcze jedno pytanie:

segment .text
        global _start
_start: mov al, 'A'
        call print_char
        mov al, 0ah
        call print_char
        mov eax, 1
        mov ebx, 0
        int 0x80

segment .bss
char    resb    2
segment .text
print_char:
        mov [char], al
        mov eax, 4
        mov ebx, 1
        mov ecx, char
        mov edx, 1
        int 0x80
        ret

W tym programie drukuje mi się A na wyjściu. W jaki sposób przekonwertować liczbę 0x0A, aby również mi zadziałało - w tym momencie wyświetla się pusta linia.

0

Dokładnie tak jak napisałem wyżej. Nie, nikt nie napisze tego za ciebie.

0

A co mi tam, nudziło mi się, ale napisane celowo brzydko, więc będziesz zmuszony przeanalizować żeby się nauczyć : >

segment .text
global _start
_start:

    ; liczba
    mov bx, 0xc3

    xor edx, edx
    xor ecx, ecx
    inc ecx
    inc ecx

    .___:
    mov ax, bx
    shr al, 4
    cmp al, 10
    sbb al, 0x69
    das
    mov byte [abc+edx], al
    inc dx
    ror bl, 4 
    loop .___

    mov eax, 4
    mov ebx, 1
    mov ecx, abc
    mov edx, 3
    int 0x80
    
    mov eax, 1
    int 0x80


segment .data
abc: db 0, 0, 0
0

Coś mi tu jeszcze nie śmiga.
Na wyjściu mam 1, 2, 3 ... 9, później seria białych znaków :(

segment .data
ile equ 20
new_line db 0ah

segment .bss
licznik resb 1
char resb 1
var resb 1

segment .text
global _start

_start:
	mov cl, ile
	mov al, 0x00
looper:	
	mov [licznik], cl
	mov [var], al
	call convert
	call print_char
	call print_new_line
	mov cl, [licznik]
	mov al, [var]
	inc al
	dec cl
	jnz looper
	call safe_exit

print_char:
	mov [char], al
	mov eax, 4
	mov ebx, 1
	mov ecx, char
	mov edx, 1
	int 0x80
	ret

convert:
	cmp al, 0x0f
	jg err
	cmp al, 0x00
	jl err

	cmp al, 0x09
	jg character
	add al, 0x30
	ret
character:
	add al, 0x0B
err:
	mov al, 0x3f

print_new_line:
	mov eax, 4
	mov ebx, 1
	mov ecx, new_line
	mov edx, 1
	int 0x80
	ret

safe_exit:
	mov eax, 1
	mov ebx, 0
	int 0x80
	ret
0
    cmp al, 0x09
    jg character
    add al, 0x30
    ret
character:
    add al, 0x0B
err:
    mov al, 0x3f

To nie ma sensu. Przecież jak zrobisz jg character to do swojego al dodasz tylko 0B a potem WCALE NIE WRÓCISZ tam skad skoczyłeś tylko kod sie będzie dalej wykonywał idąc przez to twoje err a potem wykonujac kod z print_new_line aż nie trafi na ret...
Jakbyś użył debugera to byś widział co sie dzieje. Ale nie, po co...

1 użytkowników online, w tym zalogowanych: 0, gości: 1