Вывод содержимого регистров

Discussion in 'WASM.BEGINNERS' started by Exorcist, Apr 20, 2008.

  1. Exorcist

    Exorcist New Member

    Blog Posts:
    0
    Joined:
    Apr 20, 2008
    Messages:
    12
    Учусь програмировать на ассамблере.
    Делаю задачу про Систменый таймер.
    После использовании функции прерывания.ЗНачения времени помещаются в регистры.
    И я например хочу вывести время на экран HH:MM:SS
    Как вывести содержимое регистров на экран ,например в com программе.
    Пробывал вторую функцию и шестую.Но на экране пусто.Помогите пожалкйста.

    Приведите мне пример :
    Например у нас что то в регистре cx.Например счётчик. mov cx,16
    Как мне вывести на экран что там 16 ?
    Заранне спасибо
     
  2. Asterix

    Asterix New Member

    Blog Posts:
    0
    Joined:
    Feb 25, 2003
    Messages:
    3,576
    http://wasm.ru/forum/viewtopic.php?id=12759
    не ленитесь искать
     
  3. wsd

    wsd New Member

    Blog Posts:
    0
    Joined:
    Aug 8, 2007
    Messages:
    2,824
    Exorcist
    Code (Text):
    1. conv_w_to_ascii proc
    2. ;di result
    3. ;bx input
    4.     push dx
    5.         push cx
    6.         push ax
    7.     mov ax, bx
    8.     xor bx, bx
    9.     xor dx, dx
    10.     mov cx, 10000
    11.     div cx
    12.     test ax, ax
    13.     jz _next_1
    14.     add al, '0'
    15.     mov [di], al
    16.     inc di
    17.     mov bx, 1
    18.  
    19.  _next_1:
    20.     mov ax, dx
    21.     xor dx, dx
    22.     mov cx, 1000
    23.     div cx
    24.     test ax, ax
    25.     jz next_2
    26.     add al, '0'
    27.     mov [di], al
    28.     inc di
    29.     mov bx, 1
    30.     jmp _next_2
    31.    
    32.  next_2:
    33.     test bx, bx
    34.     jz _next_2
    35.     mov byte ptr [di], '0'
    36.     inc di
    37.    
    38.  _next_2:
    39.     mov ax, dx
    40.     xor dx, dx
    41.     mov cx, 100
    42.     div cx
    43.     test ax, ax
    44.     jz next_3
    45.     add al, '0'
    46.     mov [di], al
    47.     inc di
    48.     mov bx, 1
    49.     jmp _next_3
    50.    
    51.  next_3:
    52.     test bx, bx
    53.     jz _next_3
    54.     mov byte ptr [di], '0'
    55.     inc di
    56.    
    57.  _next_3:
    58.     mov ax, dx
    59.     xor dx, dx
    60.     mov cx, 10
    61.     div cx
    62.     test ax, ax
    63.     jz next_4
    64.     add al, '0'
    65.     mov [di], al
    66.     inc di
    67.     mov bx, 1
    68.     jmp _next_4
    69.    
    70.  next_4:
    71.     test bx, bx
    72.     jz _next_4
    73.     mov byte ptr [di], '0'
    74.     inc di
    75.    
    76.  _next_4:
    77.     add dl, '0'
    78.     mov [di], dl
    79.     inc di
    80.     mov byte ptr[di], 0
    81.         pop     ax
    82.         pop     cx
    83.     pop dx
    84.     ret
    85.    
    86. endp conv_w_to_ascii
    функция преобразования слова в строку(не оптимальная, но наглядная)
    и вообще срочно почитай зубкова
     
  4. rudik

    rudik Руденко Артём

    Blog Posts:
    0
    Joined:
    Dec 6, 2006
    Messages:
    302
    Location:
    г. Харьков
    Code (Text):
    1. Procedure_BIN2STRHEX:
    2.         push ebp
    3.         mov ebp,esp
    4.         push ebx
    5.         push edi
    6.         mov ebx,[ebp+8]
    7.         mov edi,[ebp+12]
    8.         push eax
    9.         push ecx
    10.         mov ecx,8      
    11.         mov ax,"0x"
    12.         stosw
    13.         Procedure_BIN2STRHEX_NEXT:
    14.         rol ebx,4
    15.         mov al,bl
    16.         and al,0x0f
    17.         add al,0x30
    18.         cmp al,0x3A
    19.         jc @f
    20.         add al,7
    21.         @@:
    22.         stosb
    23.         loop Procedure_BIN2STRHEX_NEXT
    24.         mov al,0
    25.         stosb
    26.         pop ecx
    27.         pop eax
    28.         pop edi
    29.         pop ebx
    30.         pop ebp
    31.         ret
    32.  
    33.  
    34.     Procedure_UBIN2STRDEC:
    35.         push ebp
    36.         mov ebp,esp
    37.         push eax
    38.         push edi
    39.         mov eax,[ebp+8]
    40.         mov edi,[ebp+12]
    41.         push edx
    42.         push ebx
    43.         test eax,eax
    44.         jnz @f
    45.         mov ax,"0"
    46.         stosw
    47.         jmp Procedure_BIN2STRDEC_ZERO
    48.  
    49.         @@:
    50.         cmp eax,1000000000
    51.         jnc Procedure_UBIN2STRDEC1000000000
    52.         cmp eax,100000000
    53.         jnc Procedure_UBIN2STRDEC100000000
    54.         cmp eax,10000000
    55.         jnc Procedure_UBIN2STRDEC10000000
    56.         cmp eax,1000000
    57.         jnc Procedure_UBIN2STRDEC1000000
    58.         cmp eax,100000
    59.         jnc Procedure_UBIN2STRDEC100000
    60.         cmp eax,10000
    61.         jnc Procedure_UBIN2STRDEC10000
    62.         cmp eax,1000
    63.         jnc Procedure_UBIN2STRDEC1000
    64.         cmp eax,100
    65.         jnc Procedure_UBIN2STRDEC100
    66.         cmp eax,10
    67.         jnc Procedure_UBIN2STRDEC10
    68.         jmp Procedure_UBIN2STRDEC1
    69.  
    70.         Procedure_UBIN2STRDEC1000000000:
    71.  
    72.         xor edx,edx
    73.         mov ebx,1000000000
    74.         div ebx    
    75.         add al,0x30
    76.         stosb
    77.         mov eax,edx
    78.         Procedure_UBIN2STRDEC100000000:
    79.         xor edx,edx
    80.         mov ebx,100000000
    81.         div ebx    
    82.         add al,0x30
    83.         stosb
    84.         mov eax,edx
    85.         Procedure_UBIN2STRDEC10000000:
    86.         xor edx,edx
    87.         mov ebx,10000000
    88.         div ebx    
    89.         add al,0x30
    90.         stosb
    91.         mov eax,edx
    92.         Procedure_UBIN2STRDEC1000000:
    93.         xor edx,edx
    94.         mov ebx,1000000
    95.         div ebx    
    96.         add al,0x30
    97.         stosb      
    98.         mov eax,edx
    99.         Procedure_UBIN2STRDEC100000:
    100.         xor edx,edx
    101.         mov ebx,100000
    102.         div ebx    
    103.         add al,0x30
    104.         stosb
    105.         mov eax,edx
    106.         Procedure_UBIN2STRDEC10000:
    107.         xor edx,edx
    108.         mov ebx,10000
    109.         div ebx    
    110.         add al,0x30
    111.         stosb      
    112.         mov eax,edx
    113.         Procedure_UBIN2STRDEC1000:
    114.         xor edx,edx
    115.         mov ebx,1000
    116.         div ebx    
    117.         add al,0x30
    118.         stosb
    119.         mov eax,edx
    120.         Procedure_UBIN2STRDEC100:
    121.         xor edx,edx
    122.         mov ebx,100
    123.         div ebx    
    124.         add al,0x30
    125.         stosb
    126.         mov eax,edx
    127.         Procedure_UBIN2STRDEC10:
    128.         xor edx,edx
    129.         mov ebx,10
    130.         div ebx    
    131.         add al,0x30
    132.         stosb
    133.         mov al,dl
    134.             Procedure_UBIN2STRDEC1:
    135.         add al,0x30
    136.         stosb
    137.         mov al,0
    138.         stosb
    139.  
    140.         Procedure_BIN2STRDEC_ZERO:
    141.         pop ebx
    142.         pop edx
    143.         pop edi
    144.         pop eax
    145.         pop ebp
    146.         ret
    147.  
    148.  
    149.     Procedure_SBIN2STRDEC:
    150.         push ebp
    151.         mov ebp,esp
    152.         push eax
    153.         push edi
    154.         mov eax,[ebp+8]
    155.         mov edi,[ebp+12]
    156.         test eax,0x80000000
    157.         jz @f
    158.         push eax
    159.         mov al,'-'
    160.         stosb
    161.         pop eax
    162.         xor eax,0xFFFFFFFF
    163.         inc eax
    164.         @@:
    165.         push edi
    166.         push eax
    167.         call Procedure_UBIN2STRDEC
    168.         add esp,8
    169.         pop edi
    170.         pop eax
    171.         pop ebp
    172.         ret