ALUNOS DEVEM CHEGAR A ISTO....LOUCURA LOUCURA....

[tcpipchip]

Código: Selecionar todos

include 'emu8086.inc'
; multi-segment executable file template.

data segment
    ; add your data here!
    pkey db "press any key...$"
   
    linha  db 0
    coluna db 0
   
zero db "*****",0
     db "*   *",0
     db "*   *",0
     db "*   *",0
     db "*****","$"

um   db "    *",0
     db "    *",0
     db "    *",0
     db "    *",0
     db "    *","$"

dois db "*****",0
     db "    *",0
     db "*****",0
     db "*    ",0
     db "*****","$"

tres db "*****",0
     db "    *",0
     db "*****",0
     db "    *",0
     db "*****","$"

quat db "*   *",0
     db "*   *",0
     db "*****",0
     db "    *",0
     db "    *","$"

cinc db "*****",0
     db "*    ",0
     db "*****",0
     db "    *",0
     db "*****","$"

seis db "*****",0
     db "*    ",0
     db "*****",0
     db "*   *",0
     db "*****","$"

sete db "*****",0
     db "    *",0
     db "    *",0
     db "    *",0
     db "    *","$"

oito db "*****",0
     db "*   *",0
     db "*****",0
     db "*   *",0
     db "*****","$"
     
nove db "*****",0
     db "*   *",0
     db "*****",0
     db "    *",0
     db "*****","$"     
                   
ends

stack segment
    dw   128  dup(0)
ends

code segment
start:
; set segment registers:
    mov ax, data
    mov ds, ax
    mov es, ax

    ; add your code here
   
    ; POE VIDEO 25X80
    MOV AH,0
    MOV AL,3
    INT 10H   
       
PEGA_HORA:   
    call obtem_hora
    PUSH CX ; CONTEM HORA/MINUTO
    PUSH DX ; CONTEM SEGUNDOS DH
    CALL IMPRIME_TELA
    JMP PEGA_HORA
                   
    lea dx, pkey
    mov ah, 9
    int 21h        ; output string at ds:dx
   
    ; wait for any key....   
    mov ah, 1
    int 21h
   
    mov ax, 4c00h ; exit to operating system.
    int 21h   

obtem_hora:
    ; CH = HORA
    ; CL = MINUTO
    ; DH = SEGUNDOS
    MOV AH,2CH
    INT 21H
    RET
   
IMPRIME_TELA:
    PUSH BP
    MOV BP,SP
             
    ; POSICIONA CURSOR
    mov al,10
    mov byte ptr linha,al
    mov al,70
    mov byte ptr coluna,al
       
    MOV AX,[BP+4] ; SEGUNDOS
    ;AH SEGUNDOS
    ;SEPARE SEGUNDOS
    XCHG AH,AL
    MOV AH,0
    ; begin
    mov bx, 10 ; divide segundos por 10...
    xor dx, dx ; dx = 0
    div bx     ; ax = cociente dx = resto  al=cociente dl=resto
    mov ah,dl
    CALL PEGA_OFFSET_TEXTO       
    CALL IMPRIME_DIGITO

    ; POSICIONA CURSOR
    mov al,10
    mov byte ptr linha,al
    mov al,60
    mov byte ptr coluna,al
       
    MOV AX,[BP+4] ; SEGUNDOS
    ;AH SEGUNDOS
    ;SEPARE SEGUNDOS
    XCHG AH,AL
    MOV AH,0
    ; begin
    mov bx, 10 ; divide segundos por 10...
    xor dx, dx ; dx = 0
    div bx     ; ax = cociente dx = resto  al=cociente dl=resto
    mov ah,al
    CALL PEGA_OFFSET_TEXTO       
    CALL IMPRIME_DIGITO


    ; POSICIONA CURSOR
    mov al,10
    mov byte ptr linha,al
    mov al,50
    mov byte ptr coluna,al
       
    MOV AX,[BP+6] ; MINUTOS
    ;AL MINUTOS
    ;SEPARE MINUTOS
    MOV AH,0
    ; begin
    mov bx, 10 ; divide segundos por 10...
    xor dx, dx ; dx = 0
    div bx     ; ax = cociente dx = resto  al=cociente dl=resto
    mov ah,dl
    CALL PEGA_OFFSET_TEXTO       
    CALL IMPRIME_DIGITO

    ; POSICIONA CURSOR
    mov al,10
    mov byte ptr linha,al
    mov al,40
    mov byte ptr coluna,al
       
    MOV AX,[BP+6] ; MINUTOS
    ;AL MINUTOS
    ;SEPARE MINUTOS
    MOV AH,0
    ; begin
    mov bx, 10 ; divide segundos por 10...
    xor dx, dx ; dx = 0
    div bx     ; ax = cociente dx = resto  al=cociente dl=resto
    mov ah,al
    CALL PEGA_OFFSET_TEXTO       
    CALL IMPRIME_DIGITO


    ; POSICIONA CURSOR
    mov al,10
    mov byte ptr linha,al
    mov al,30
    mov byte ptr coluna,al
       
    MOV AX,[BP+6] ; HORAS
    ;AH HORA
    ;SEPARE HORAS
    XCHG AH,AL
    MOV AH,0
    ; begin
    mov bx, 10 ; divide segundos por 10...
    xor dx, dx ; dx = 0
    div bx     ; ax = cociente dx = resto  al=cociente dl=resto
    mov ah,dl
    CALL PEGA_OFFSET_TEXTO       
    CALL IMPRIME_DIGITO

    ; POSICIONA CURSOR
    mov al,10
    mov byte ptr linha,al
    mov al,20
    mov byte ptr coluna,al
       
    MOV AX,[BP+6] ; HORAS
    ;AL SEGUNDOS
    ;SEPARE SEGUNDOS
    XCHG AH,AL
    MOV AH,0
        ; begin
    mov bx, 10 ; divide segundos por 10...
    xor dx, dx ; dx = 0
    div bx     ; ax = cociente dx = resto  al=cociente dl=resto
    mov ah,al
    CALL PEGA_OFFSET_TEXTO       
    CALL IMPRIME_DIGITO

    POP BP
    RET 4
   
PEGA_OFFSET_TEXTO:

DIG_0:   
    CMP AH,0
    JNE DIG_1
    MOV SI, OFFSET ZERO
DIG_1:
    CMP AH,1
    JNE DIG_2
    MOV SI, OFFSET UM
DIG_2:
    CMP AH,2
    JNE DIG_3
    MOV SI, OFFSET DOIS
DIG_3:
    CMP AH,3
    JNE DIG_4
    MOV SI, OFFSET TRES
DIG_4:
    CMP AH,4
    JNE DIG_5
    MOV SI, OFFSET QUAT
DIG_5:   
    CMP AH,5
    JNE DIG_6
    MOV SI, OFFSET CINC
DIG_6:
    CMP AH,6
    JNE DIG_7
    MOV SI, OFFSET SEIS
DIG_7:
    CMP AH,7
    JNE DIG_8
    MOV SI, OFFSET SETE
DIG_8:
    CMP AH,8
    JNE DIG_9
    MOV SI, OFFSET OITO
DIG_9:
    CMP AH,9
    JNE ERRO_DIGITO
    MOV SI, OFFSET NOVE
ERRO_DIGITO:
    RET   

IMPRIME_DIGITO:
    ; SI APONTA PARA INICIO TEXTO
    mov dl, byte ptr coluna ; coluna
IMPRIME_LINHA:
    mov dh, byte ptr linha  ; linha
    mov bh, 0
    mov ah, 2
    int 10h   
   
    MOV CL,[SI]
    CMP CL,"$"
    JE SAI_IMPRIME
    CMP CL,0
    JE  PULA_LINHA
    MOV AH,2
    PUSH DX  ; SALVE DL QUE CONTEM COLUNA
    MOV DL,CL
    INT 21H 
    POP DX   ; RESTAURE DX QUE CONTEM DL
    INC SI
    INC DL ; AVANCA COLUNA
    JMP IMPRIME_LINHA

PULA_LINHA:         
    INC SI
    INC BYTE PTR LINHA
    JMP IMPRIME_DIGITO ; RESTAURANDO COLUNA
SAI_IMPRIME:
    RET   

ends

end start ; set entry point and stop the assembler.


[andre_luis]

Exibicionista...




+++

[tcpipchip]

Ensinei hoje passagem de parametros por pilha

A PILHA TEM TRES FUNCOES
-SALVAR ENDEREÇO DE RETORNO DE CHAMADA DE SUBROTINA
EXEMPLO:
CALL TESTE
*

TESTE:
RET

NESTE CASO, *, QUE É O ENDEREÇO DA PROXIMA INSTRUCAO, É SALVO NA PILHA.
AO ENCONTRAR RET, RETIRA O * DA PILHA E JOGO EM IP (CONTADOR DE PROGRAMA), INDO PARA O ENDEREÇO *

-PRESERVAR CONTEXTOS DE REGISTRADORES
EXEMPLO:

; DIGAMOS QUE AX SEJA 765 E VOCE NÃO QUER PERDE-LO....ENTAO SALVE ELE

PUSH AX
MOV AX,33
POP AX

NESTE CASO, SALVEI O AX NA PILHA, PQ NA LINHA SEGUINTE VOU ALTERA-LO....
PARA RESTAURAR O DADO DA PILHA, VOCE DÁ UM POP AX
ASSIM, O SEU 765 RESTAURA

-PASSAGEM DE PARÂMETROS
EXEMPLO:
PUSH 33
PUSH 44
CALL SOMA
*

SOMA:
.
.
.

NESTE EXEMPLO, OS VALORES 33 E 44 SÃO COLOCADOS NA PILHA E ENTAO VOCE PODE CHAMAR A SUBROTINA QUE FAÇA A SOMA DESTES 2 DADOS EMPILHADOS.
O PROBLEMA, É QUE QUANDO VOCE DÁ UM CALL, O ENDEREÇO DE RETORNO TAMBEM É SALVO NA PILHA.

ENTAO, DENTRO DA SOMA, O QUE TEREMOS EMPILHADO ?


* SP FFFA/FFF9
0044 FFFC/FFFB
0033 FFFE/FFFD
BP FFFF

BP SEMPRE APONTA PARA A BASE DA PILHA E SP SEMPRE APONTA PARA O ULTIMO DADO EMPILHA.

PARA PEGAR OS PARAMETROS, VOCE DEVE USAR [BP+....] COMO ENDEREÇO.
COMO BP ESTÁ NA BASE DA PILHA, NÃO PODEREI USAR [BP+....], VOU VAI ENDEREÇAR ABAIXO DA PILHA.
O SEGREDO É FAZER BP RECEBER SP
POREM VOU PERDER BP.
ENTAO DEVEMOS SALVAR BP NA PILHA,
FAÇA PUSH BP

BP SP FFF8/FFF7
* FFFA/FFF9
0044 FFFC/FFFB
0033 FFFE/FFFD
BP FFFF

AGORA MOVA PARA BP, O VALOR DE SP

BP SP FFF8/FFF7  BP
* FFFA/FFF9
0044 FFFC/FFFB
0033 FFFE/FFFD
FFFF

PARA PEGAR O VALOR 44, BASTA USAR O ENDEREÇO BASE [BP+4....]
EXEMPLO, BP VALE FFF7, SE VOCE SOMAR 4, VIRA FFFB, QUE É ENDEREÇO DE 0044 NA PILHA
PARA PEGAR O VALOR 33, BASTA USAR O ENDEREÇO BASE [BP+6....]
EXEMPLO, BP VALE FFF7, SE VOCE SOMAR 4, VIRA FFFD, QUE É ENDEREÇO DE 0033 NA PILHA

PRONTO! DADOS PEGOS

ANTES DE RETORNAR, RESTAURE BP DA PILHA E RETORNE TIRANDO DA PILHA OS 0044 E 0033 QUE SÃO 4 BYTES.

PUSH BP
MOV BP,SP
MOV AX, [BP+4] ; PEGUEI 0044
MOV AX, [BP+6] ; PEGUEI 0033
POP BP
RET 4

[tcpipchip]

Código: Selecionar todos

; multi-segment executable file template.

data segment 
   
    numero_0 db " ***  ",0
             db "*  ** ",0
             db "* * * ",0
             db "* * * ",0
             db "**  * ",0
             db " ***  ","$"
    numero_1 db "  *   ",0
             db " **   ",0
             db "  *   ",0
             db "  *   ",0
             db "  *   ",0
             db " ***  ","$"
    numero_2 db " ***  ",0
             db "*   * ",0
             db "   *  ",0
             db "  *   ",0
             db " *    ",0
             db "***** ","$"
    numero_3 db " ***  ",0
             db "*   * ",0
             db "   *  ",0
             db "    * ",0
             db "*   * ",0
             db " ***  ","$"
    numero_4 db "*   * ",0
             db "*   * ",0
             db "***** ",0
             db "    * ",0
             db "    * ",0
             db "    * ","$"
    numero_5 db "***** ",0
             db "*     ",0
             db "****  ",0
             db "    * ",0
             db "    * ",0
             db "****  ","$"
    numero_6 db "   *  ",0
             db "  *   ",0
             db " ***  ",0
             db "*   * ",0
             db "*   * ",0
             db " ***  ","$"
    numero_7 db "***** ",0
             db "   *  ",0
             db "  *   ",0
             db "  *   ",0
             db " *    ",0
             db " *    ","$"
    numero_8 db " ***  ",0
             db "*   * ",0
             db " ***  ",0
             db "*   * ",0
             db "*   * ",0
             db " ***  ","$"
    numero_9 db " ***  ",0
             db "*   * ",0
             db " ***  ",0
             db "  *   ",0
             db " *    ",0
             db "*     ","$"   
    dois_pontos db "      ",0
                db "  *   ",0
                db "      ",0
                db "  *   ",0
                db "      ",0
                db "      ","$"
    barra   db "    * ",0
            db "   ** ",0
            db "  **  ",0
            db " **   ",0
            db "**    ",0
            db "*     ","$"   
   alfabeto db "***** ",0
            db "*   * ",0
            db "***** ",0
            db "*   * ",0
            db "*   * ",0
            db "*   * ","$"
            db "****  ",0
            db "*  *  ",0
            db "***** ",0
            db "*   * ",0
            db "*   * ",0
            db "***** ","$"
            db "***** ",0
            db "*     ",0
            db "*     ",0
            db "*     ",0
            db "*     ",0
            db "***** ","$"
            db "****  ",0
            db "*   * ",0
            db "*   * ",0
            db "*   * ",0
            db "*   * ",0
            db "****  ","$"
            db "***** ",0
            db "*     ",0
            db "****  ",0
            db "*     ",0
            db "*     ",0
            db "***** ","$"
            db "***** ",0
            db "*     ",0
            db "****  ",0
            db "*     ",0
            db "*     ",0
            db "*     ","$"
            db "***** ",0
            db "*     ",0
            db "*     ",0
            db "*  ** ",0
            db "*   * ",0
            db "***** ","$"
            db "*   * ",0
            db "*   * ",0
            db "*   * ",0
            db "***** ",0
            db "*   * ",0
            db "*   * ","$"
            db "***** ",0
            db "  *   ",0
            db "  *   ",0
            db "  *   ",0
            db "  *   ",0
            db "***** ","$"
            db "***** ",0
            db "  *   ",0
            db "  *   ",0
            db "  *   ",0
            db "  *   ",0
            db "**    ","$"
            db "*  *  ",0
            db "* *   ",0
            db "**    ",0
            db "* *   ",0
            db "*  *  ",0
            db "*   * ","$" 
            db "*     ",0
            db "*     ",0
            db "*     ",0
            db "*     ",0
            db "*     ",0
            db "***** ","$"
            db "*   * ",0
            db "** ** ",0
            db "* * * ",0
            db "*   * ",0
            db "*   * ",0
            db "*   * ","$"
            db "*   * ",0
            db "**  * ",0
            db "* * * ",0
            db "*  ** ",0
            db "*   * ",0
            db "*   * ","$"
            db "***** ",0
            db "*   * ",0
            db "*   * ",0
            db "*   * ",0
            db "*   * ",0
            db "***** ","$"
            db "****  ",0
            db "*   * ",0
            db "*   * ",0
            db "****  ",0
            db "*     ",0
            db "*     ","$"
            db "***** ",0
            db "*   * ",0
            db "*   * ",0
            db "* * * ",0
            db "*  ** ",0
            db "***** ","$"
            db "****  ",0
            db "*   * ",0
            db "*   * ",0
            db "****  ",0
            db "* *   ",0
            db "*  *  ","$"
            db "***** ",0
            db "*     ",0
            db "***** ",0
            db "    * ",0
            db "    * ",0
            db "***** ","$"
            db "***** ",0
            db "  *   ",0
            db "  *   ",0
            db "  *   ",0
            db "  *   ",0
            db "  *   ","$"
            db "*   * ",0
            db "*   * ",0
            db "*   * ",0
            db "*   * ",0
            db "*   * ",0
            db "***** ","$"
            db "*   * ",0
            db "*   * ",0
            db "*   * ",0
            db " * *  ",0
            db " * *  ",0
            db "  *   ","$"
            db "*   * ",0
            db "*   * ",0
            db "*   * ",0
            db "* * * ",0
            db "** ** ",0
            db "*   * ","$"
            db "*   * ",0
            db " * *  ",0
            db "  *   ",0
            db "  *   ",0
            db " * *  ",0
            db "*   * ","$"
            db "      ",0
            db "      ",0
            db "***** ",0
            db "      ",0
            db "      ",0
            db "      ","$"
            db "      ",0
            db "      ",0
            db "      ",0
            db "      ",0
            db "      ",0
            db "      ","$"
   numb_0    db "****** ",0
             db "*    * ",0
             db "*    * ",0
             db "*    * ",0
             db "*    * ",0
             db "*    * ",0
             db "*    * ",0
             db "*    * ",0
             db "****** ","$"
    numb_1   db "     * ",0
             db "     * ",0
             db "     * ",0
             db "     * ",0
             db "     * ",0
             db "     * ",0
             db "     * ",0
             db "     * ",0
             db "     * ","$"
    numb_2   db "****** ",0
             db "     * ",0
             db "     * ",0
             db "     * ",0
             db "****** ",0
             db "*      ",0
             db "*      ",0
             db "*      ",0
             db "****** ","$"
    numb_3   db "****** ",0
             db "     * ",0
             db "     * ",0
             db "     * ",0
             db "****** ",0
             db "     * ",0
             db "     * ",0
             db "     * ",0
             db "****** ","$"
    numb_4   db "*    * ",0
             db "*    * ",0
             db "*    * ",0
             db "****** ",0
             db "     * ",0
             db "     * ",0
             db "     * ",0           
             db "     * ",0                           
             db "     * ","$"
    numb_5   db "****** ",0
             db "*      ",0
             db "*      ",0             
             db "*      ",0                         
             db "****** ",0
             db "     * ",0
             db "     * ",0
             db "     * ",0             
             db "****** ","$"
    numb_6   db "*      ",0
             db "*      ",0
             db "*      ",0
             db "*      ",0
             db "****** ",0
             db "*    * ",0
             db "*    * ",0
             db "*    * ",0
             db "****** ","$"
    numb_7   db "****** ",0
             db "     * ",0
             db "     * ",0
             db "     * ",0
             db "     * ",0
             db "     * ",0             
             db "     * ",0
             db "     * ",0
             db "     * ","$"
    numb_8   db "****** ",0
             db "*    * ",0
             db "*    * ",0
             db "*    * ",0
             db "****** ",0
             db "*    * ",0
             db "*    * ",0
             db "*    * ",0
             db "****** ","$"
    numb_9   db "****** ",0
             db "*    * ",0
             db "*    * ",0
             db "****** ",0
             db "     * ",0
             db "     * ",0             
             db "     * ",0 
             db "     * ",0
             db "     * ","$" 
    numb_pontos db "       ",0
                db "       ",0
                db "   *   ",0
                db "       ",0
                db "       ",0
                db "   *   ",0
                db "       ",0
                db "       ",0               
                db "       ","$"
    numb_vazio db "       ",0
               db "       ",0
               db "       ",0
               db "       ",0
               db "       ",0
               db "       ",0
               db "       ",0
               db "       ",0               
               db "       ","$"   
                         
               
    vLinha dw 00
    vColuna dw 00
    contrCaracter1 db 0
    contrCaracter2 db 0
    contrCaracterTot db 0
    contrDigito dw 00
    hHora db 0
    lHora db 0
    hMin db 0
    lMin db 0
    hSeg db 0
    lSeg db 0 
 
    corCaracter db 8
    msg_escolheCor db "Escolha uma cor 1-9 :","$" 
    caracterAscii db 9;197
    ano dw 00 
    divAno dw 00   
    opcaoImprimir db 1
    opcaoPosQuantImprimir db 1
    diasemana db 0
    dom db "   domingo   ","$"
    seg db "segunda","$"
    ter db " terca","$"
    qua db "quarta","$"
    qui db "quinta","$"
    sex db " sexta","$"
    sab db "    sabado   ","$"   

    feira db "-feira ","$"
    imprimirFeira db 1
    contrPontos db 61
    pontos_ligados db 1
    msg_rotativa db "                           ","$"
    rotacionouJa db 0       
    tpEfeitoRotacao db 1
    totMudarTipo db 0   
    atualizaData db 0   
    guardaMinutos db 0
    coresParaMsgRotativa db 1  ;vou usar duas posicoes
    coresParaMsgRotativa1 db 0  ;a segunda..
    caracterPontoHora db 1     ;para imprimir apenas : entre as horas..
    ;cores 0-15 0=preto(nao vou usar) 
    hora_romana db "             ","$" ;monto a hora em numeros romanos e armazeno aqui 
    mostrandoHoraTipo db 0     ;0 numeros 1 numeros romados
    contrTrocaHora db 0   
    pegaData db "                           ","$"  ;monto a mensagem com HORA/DIASEM/DATA
    pegaData2 db "--\-/-\-/-\-/-\-/-\-/-!BRUF","$"
    pegaData3 db "----!OACATUPMOC-AD-SAICNEIC","$"       
    pegaData4 db "---------------------.N.H.L","$" 
    pegaData5 db "---------------------------","$"
    cntrMsgBarra db 1                  ;armazena a mensagem q sera exibida               
    aguardaMsgSumirTroca db 0          ;uso para controle.. nao pode trocar
    aguardaMsgSumirTroca2 db 0         ;a mensagem enquanto estiver sendo vista
    CntrAM_PM db 0 
    qualCaracter dw 0   ;0 = 6x6 2 = 9x7
       
    tamBytesCaracter db 42
    tamBytesCaracter1 db 72 
    totLinhasCaracter dw 6
    totLinhasCaracter1 dw 9
    totColunasCaracter dw 6
    totColunasCaracter1 dw 7
    totOcupaCaracter dw 12
    totOcupaCaracter1 dw 14 
    totLinhasCaracterMult dw 7
    totLinhasCaracterMult1 dw 8 
    numeroEstaSendoMostrado db 0
    podeMudarNumero db 0 
   
ends

stack segment
    dw   128  dup(0)
ends

code segment
start:
; set segment registers:
    mov ax, data
    mov ds, ax
    mov ax, 0b800h ;configuracao da posicao 0 do video
    mov es, ax

    CALL DEFINE_TELA
   
    lea bx,pegaData3
   
    mov [bx+6],199 ;A ~
    mov [bx+7],128 ;C ,
    mov [bx+24],210 ;E ^
             
    mov [contrPontos],32
   
    mov [qualCaracter],0 ;seta caracter 6x6

    CALL PEGA_DATA   
   
    CALL ESCOLHENDO_COR
   
    ;CALL BARR_GRAFF 
;apagar cursor

;vou apagar a mensagem da escolha de cor..
    mov bx,0
apagando_escolhe_cor:   
    mov es:[bx],0
    mov es:[bx+1],0
    add bx,2
    cmp bx,42
    jbe apagando_escolhe_cor
;fim apagar a mensagem
    mov ch,32
    mov ah,1
    int 10h
; fim apaga cursor
  ;mov [tpEfeitoRotacao],al  ;usei para testar os tipos .. pega mesmo valor da cor
infinito:
    mov si, 0
    CALL AMOSTRA_HORARIO ; carrega time_buf
    jmp infinito

 
DEFINE_TELA proc
  mov ah, 0  ;servico
  mov al, 3  ;80x25
  int 10h    ;chama
  ret     
DEFINE_TELA endp

; SUBPROGRAMA QUE AMOSTRA HORARIO
; CONVERTE PARA O FORMATO:  HORA: MINUTO: SEGUNDO
AMOSTRA_HORARIO PROC   
  MOV AH,2CH ;
  INT 21H ;
  ;converte horas para ASCII
  mov [opcaoPosQuantImprimir],0
 
  mov bx,0
  add bx,cx
  mov dl,0
  add bx,dx

  ;cmp si,0 ;se for igual deve atualizar a data
  ;je atualiza_data
  ;[mostrandoHoraTipo]
  ;contrTrocaHora
  cmp [contrPontos],DH
  je status_pontos
 
  MOV AL,CH ;
  mov [atualizaData],ch
 
  cmp cx,3073    ;12:01
  jae deve_trocar_pm

  cmp cx,1       ;00:01
  jae deve_trocar_am    ;se for 00:00 deve pegar PM ainda.. 
                        ;ainda e PM
deve_trocar_pm:
  mov [CntrAM_PM],1      ;1 = PM 0 = AM   
  jmp pula_troca_pm_am
 
deve_trocar_am:
  mov [CntrAM_PM],0      ;1 = PM 0 = AM
   
pula_troca_pm_am: 
  CALL CONVERTE
  CALL ARMAZENA_HORA
  mov [hHora], al
  mov [hHora+1], ah
  ;converte minutos
  MOV AL,CL ;   

  add [atualizaData],cl   
 
  cmp cl,[guardaMinutos]
  jne proc_trocar_hora
  jmp espera_pra_trocar
 
proc_trocar_hora:
  mov [contrTrocaHora],1
   
espera_pra_trocar:
  mov [guardaMinutos],cl
  CALL CONVERTE
  CALL ARMAZENA_HORA
  mov [hMin], al
  mov [hMin+1], ah
 
 
  ;converte segundos
  MOV AL,DH ;
  add [atualizaData],dh
  mov [contrPontos],DH ;atualzia o segundo
  CALL CONVERTE
  CALL ARMAZENA_HORA 
  mov [hSeg], al
  mov [hSeg+1], ah
 
  cmp [contrTrocaHora],1
  je conta_tempo_trocar
  jmp pula_controle_troca_numeros
 
conta_tempo_trocar: 
  mov [mostrandoHoraTipo],1 ; mostrar romanos...
  cmp [contrPontos],10
  jae volta_numeros
  jmp pula_controle_troca_numeros
 
volta_numeros:
  mov [contrTrocaHora], 0
  mov [mostrandoHoraTipo],0
  mov [opcaoPosQuantImprimir],0 
 
pula_controle_troca_numeros: 
  CALL IMPRIME_RELOGIO
 
  CALL BARR_GRAFF  ;BX , DX, SI
   
;ini controle pra mudar o caracter <<<<<<<<<<<<<<<<<<<<   
  inc [caracterAscii]
  cmp [caracterAscii]," " ;caracter spa (20D)
  je troca_caracter_ascii   
  cmp [caracterAscii],0 ;caracter nulo (0D)
  je troca_caracter_ascii
  jmp caracter_aceito
troca_caracter_ascii:
  inc [caracterAscii]   
caracter_aceito: 
;fim controle pra mudar o caracter <<<<<<<<<<<<<<<<<<<<
 
  mov [rotacionouJa],1
 
  cmp [hMin+1],0   ;pra nao atualizar mais de uma vez.
  je comp_total_horas 
  RET        ; se nao for cai fora...
comp_total_horas:
  cmp [atualizaData],2
  jbe atualiza_data
  RET
 ; inc [corCaracter]
status_pontos:
  cmp [rotacionouJa],1
  je passar_msg
  jmp passou
passar_msg:
  mov [rotacionouJa],0
  mov ah,[corCaracter]            ;pegando a cor escolhida pelo usuario
  mov [coresParaMsgRotativa+1],ah ;vou armazenar a cor escolhida pelo usuario
  mov ah, [coresParaMsgRotativa]  ;vou pegar a cor da msg rotativa
  mov [corCaracter] ,ah           ;jogar pra cor do caracter
  CALL PASSA_MSG
;inicio controle do efeito
  cmp [aguardaMsgSumirTroca],0
  je liberout_msg_barra
  jmp nao_liberou_ainda
 
liberout_msg_barra:
  cmp [aguardaMsgSumirTroca2],1
  je zera_contador_mudar
 
nao_liberou_ainda:
  cmp [totMudarTipo],50
  inc [totMudarTipo] ;inc tot de tempo que ficara neste tipo
  jae mudar_tipo
  jmp passou         ;pulaaa
   
mudar_tipo:
  cmp [totMudarTipo],120
  jae zera_contador_mudar
  jmp nao_zera_contador_mudar
 
zera_contador_mudar:     
  cmp [aguardaMsgSumirTroca],1   ;esta bloqueado
  mov [aguardaMsgSumirTroca2],1  ;informa q ja poderia trocar....
  je passa_controle_msg_barra   
  mov [podeMudarNumero],1
  mov [aguardaMsgSumirTroca2],0
  cmp [cntrMsgBarra],4
  jae zera_contr_msg_barra
  inc [cntrMsgBarra]
  jmp passa_controle_msg_barra
 
zera_contr_msg_barra:
  mov [cntrMsgBarra],0
 
passa_controle_msg_barra:
  mov [totMudarTipo],0
  ;para identificar q passou um ciclo vou mudar a cor da mensagem
  cmp [coresParaMsgRotativa],15 ;a ultima cor... sera 14 ..
  je zera_cor_msg_rotativa
  inc [coresParaMsgRotativa]      ;modificar a cor quando entrar aqui..
  jmp nao_zera_contador_mudar
 
zera_cor_msg_rotativa:
  mov [coresParaMsgRotativa],1   

 
nao_zera_contador_mudar:   
  cmp [tpEfeitoRotacao],3 ;ultimo tipo
  jne pode_incrementar_tipo
  mov [tpEfeitoRotacao],1 ;recomeca
  jmp passou          ; pulaaa
 
pode_incrementar_tipo:
  inc [tpEfeitoRotacao]   ;proximo tipo
;fim controle do efeito

passou:
  cmp [mostrandoHoraTipo],1
  je vis_numeros_romanos
 
  mov ah, [coresParaMsgRotativa]  ;vou pegar a cor da msg rotativa
  inc ah                          ;a cor dos : sera a proxima da msg rotativa
  cmp ah, 16
  jae pega_primeira_cor_pontos
  mov [corCaracter] ,ah           ;jogar pra cor do caracter
  jmp pegou_cor_pontos                                 
 
pega_primeira_cor_pontos:
  mov [corCaracter] ,1            ;jogar pra cor do caracter
 
pegou_cor_pontos: 
  mov [opcaoPosQuantImprimir],0
  mov [contrCaracterTot],1
  cmp [numeroEstaSendoMostrado],2
  je reposiciona_pontos
  mov [contrDigito],50  ;26+12+12 = 48
  mov [qualCaracter],0
  jmp pula_reposiciona
   
reposiciona_pontos:
  mov [contrDigito],50  ;22+14+14 = 44
  mov [qualCaracter],2
 
pula_reposiciona:   
  cmp [pontos_ligados],1
  je desliga_ponto
  mov al,":"
  mov [pontos_ligados],1
  jmp pula_desliga
desliga_ponto:
  mov al," "
  mov [pontos_ligados],0 
pula_desliga:
  push ax   
  mov ah,[caracterAscii]         ;guardar o caracter
  mov [caracterPontoHora],ah   ;armazena
  mov [caracterAscii],248;9 ;caracter legal para os :
  call IMPRIME_BIG_CARACTER
 
  cmp [numeroEstaSendoMostrado],2
  je reposiciona_pontos2
  mov [contrDigito],86  ;26+12+12+12+12+12 = 48
  ;mov [qualCaracter],0
  jmp pula_reposiciona2
   
reposiciona_pontos2:
  mov [contrDigito],92  ;22+14+14+14+14+14 = 46
  ;mov [qualCaracter],2
 
pula_reposiciona2:   
  pop ax   
  mov [contrCaracterTot],1
  call IMPRIME_BIG_CARACTER
  mov ah,[caracterPontoHora]      ;retoma o caracter
  mov [caracterAscii],ah            ;armazena
  mov [contrDigito], 0
  ;retomar a cor...
  mov ah,[coresParaMsgRotativa+1]
  mov [corCaracter],ah 
  mov [qualCaracter],0 ;volta pro 6x6     
  RET
vis_numeros_romanos:
    RET
atualiza_data:
    CALL PEGA_DATA
    RET 
AMOSTRA_HORARIO ENDP
                         
CONVERTE PROC
  MOV AH, 0H ; mostra horario
  MOV DL,10
  DIV DL     
  ;ah tera o resto da divisao
  ;ex.: 47 / 10 ah = 7 al = 4 
  RET

CONVERTE ENDP

ARMAZENA_HORA PROC       
    add si,3          ; para armazenar na posicao da variavel correta 00:00:00
    cmp si, 9         ; zerar o contador de si quando pegou os 3 valores HH:MM:SS
    jae zera_si       ;acima ou igual
    RET     
zera_si:
    mov si,0
    ret             
    RET
ARMAZENA_HORA ENDP


IMPRIME_RELOGIO PROC  ;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< 
   
    mov ah,[hSeg]
    add ah,48
    mov al,[lSeg]
    add al,48
    mov [pegaData+19],al
    mov [pegaData+20],ah
    mov ah,[hMin]
    add ah,48
    mov al,[lMin]
    add al,48
    mov [pegaData+22],al
    mov [pegaData+23],ah
    mov ah,[hHora]
    add ah,48
    mov al,[lHora]
    add al,48
    mov [pegaData+25],al
    mov [pegaData+26],ah
    mov [pegaData+21],":"
    mov [pegaData+24],":"
   
    call LIMPA_AREA_RELOGIO
   
    cmp [mostrandoHoraTipo],0
    je relogio_numerico
    mov al,[hHora]
    mov ah,[lHora] 
    xor di,di  ;comecar a empilhar os numeros romanos no offset 0
    CALL NUMEROS_ROMANOS       
    mov al,[hMin]
    mov ah,[lMin]
    cmp ax,0
    je imprime_so_hora   
    mov [bx+si],"-" 
    inc si
    mov di,si
    CALL NUMEROS_ROMANOS
   ; mov di,si
imprime_so_hora:
    mov di,si
    CALL CENTRALIZAR_NUMEROS_ROMANOS
    CALL IMPRIMIR_NUMEROS_ROMANOS
    RET   
   
relogio_numerico:
   
    cmp [podeMudarNumero],1
    je troca_num_hora
    jmp pula_troca_numeros     
   
troca_num_hora:
    cmp [numeroEstaSendoMostrado],2
    je muda_pro_primeiro
    mov [numeroEstaSendoMostrado],2  ;9x7
    mov [podeMudarNumero],0
    jmp pula_troca_numeros
   
muda_pro_primeiro:
    mov [numeroEstaSendoMostrado],0  ;6x6
    mov [podeMudarNumero],0

pula_troca_numeros:   
    cmp [numeroEstaSendoMostrado],2
    je pos_inicio_numero
    mov [contrDigito],26 ;24 6x6 --  16 9x7
    mov [qualCaracter],0
    jmp joga_numeros_tela
   
pos_inicio_numero:
    mov [contrDigito],22 ;24 6x6 --  16 9x7
    mov [qualCaracter],2
   
joga_numeros_tela:       
    mov al,[hHora]
    mov ah,[lHora]     
    mov [contrCaracterTot],0
    mov [opcaoImprimir],1
   
    call IMPRIME_BIG_CARACTER
   
    mov al,":"       
    mov [contrCaracterTot],0
    mov [opcaoImprimir],0
   ;mov [contrDigito],48 
    call IMPRIME_BIG_CARACTER
   
    mov al,[hMin]
    mov ah,[lMin]
    mov [contrCaracterTot],0
    mov [opcaoImprimir],1
    ;mov [contrDigito],60
    call IMPRIME_BIG_CARACTER
   
    mov al,":"
    mov [contrCaracterTot],0
    mov [opcaoImprimir],0 
    ;mov [contrDigito],84
    call IMPRIME_BIG_CARACTER
   
    mov ah,[corCaracter]
    mov [coresParaMsgRotativa+1],ah
    mov ah, [coresParaMsgRotativa]  ;vou pegar a cor da msg rotativa
    dec ah                          ;a cor dos segundos sera uma anterior da msg rotativa
    cmp ah, 0
    je pega_a_ultima_cor_para_segundos
    mov [corCaracter], ah
    jmp ja_pegou_cor_para_segundos
pega_a_ultima_cor_para_segundos:
    mov [corCaracter], 15   

ja_pegou_cor_para_segundos:
   
    mov al,[hSeg]
    mov ah,[lSeg]
    mov [contrCaracterTot],0
    mov [opcaoImprimir],1     
    ;mov [contrDigito],96 
   
    mov [qualCaracter],2 
     
    call IMPRIME_BIG_CARACTER
   
    mov [qualCaracter],0   
     
    mov [contrDigito],0
    mov ah, [coresParaMsgRotativa+1]  ;retoma a cor original...
    mov [corCaracter], ah
   
    RET
IMPRIME_RELOGIO ENDP


IMPRIME_BIG_CARACTER PROC
    ;mov si, 0
    ;mov dx, 0
    ;AL = primeiro digito
    ;AH = segundo digito 
    mov [contrCaracter1],al   ;primeiro
    mov [contrCaracter2],ah ;segundo     
   
    mov si,[qualCaracter]
    cmp si,0 ;esta usando caracter 6x6
    je caracter6x6
    lea bx,numb_0
    dec si
    jmp ja_pegou_offset
   
caracter6x6:
    lea bx,numero_0
   
ja_pegou_offset:
    ;mov ah,0
    ;mov al, [contrCaracter]  ja esta com o valor
    cmp al,":"
    je pontos
    cmp al,"/"
    je imp_barra
    cmp al,"-"
    je imp_menos
    cmp al," "
    je espaco_branco
    cmp al, 95
    jae e_letra
   
    mov cl,[tamBytesCaracter+si];42
    mul cl
    add bx, ax
    jmp continua
   
espaco_branco:
    mov ah,0 
    cmp si,0
    je vazio_6x6 
    mov al,11
    mov cl,[tamBytesCaracter+si]
    jmp pegou_vazio
   
vazio_6x6:   
    mov al,37   
    mov cl,42  ; tamanho do digito na memoria   
   
pegou_vazio:
    mul cl 
    add bx, ax
    jmp continua
   
e_letra:
    mov ah,0
    sub al,"a"
    add al,12   
    mov cl,42  ; tamanho do digito na memoria
    mul cl 
    add bx, ax
    jmp continua     
imp_menos:
    mov ah,0
    mov al,36   
    mov cl,42  ; tamanho do digito na memoria
    mul cl 
    add bx, ax
    jmp continua
imp_barra:     
    mov ah,0
    mov al,11  ;tot digitos anterior a ele
    mov cl,42  ; tamanho do digito na memoria
    mul cl 
    add bx, ax
    jmp continua 
pontos: 
    mov ah,0
    mov al,10         
    mov cl,[tamBytesCaracter+si];42
    mul cl
    add bx, ax
continua: 
    mov si,[qualCaracter]       
    mov cx,[totLinhasCaracter+si]   
   ; xchg cl,ch                                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    cmp [vLinha],cx ;6 ;verifica se terminou
    jae terminou_imprimir_digito
   
    push bx   
    mov ax,[vLinha]
    mov cx,[totLinhasCaracterMult+si];7  ja pegou o valor ai em cima...
    ;inc cx ;tot mais um
   ; xchg cl,ch
    mul cx                             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   
    mov si,[vColuna]
    add si,ax     
    MOV AL,[BX+SI]    ;pega o valor       
    mov bx,0 
    push ax   ;vou utilizar o [al] entao empilho o [ax] 
    mov ax,[vColuna]
    mov cx,2 ;para utilizar a funcao (mul) o [al] deve estar com o valor a ser
              ; multiplicado e o [cl] com o valor de quantas vezes.
    mul cx    ;ira multiplicar o valor de [al] pelo de [cl] (valor de entrada * 10)
    mov si,ax
    mov ax,[vLinha]
    mov cx,160
    mul cx
    add ax,[contrDigito]
    add bx,ax
    pop ax    ;retomo o [ax]                     
    cmp al,"*"
    je troca_car
    jmp caracterTela
   
troca_car:
    mov al,[caracterAscii] 
   
caracterTela:
    cmp [opcaoPosQuantImprimir],1
    je imprime_data
    cmp [opcaoPosQuantImprimir],2
    je posiciona_num_romanos   
    cmp [opcaoPosQuantImprimir],3
    je imprime_semana   
   
    ;mov es:[BX+SI+1472],AL ;imprime o valor ;1440 - 32 centraliza na tela
    ;mov al,[corCaracter]
    ;mov es:[BX+SI+1473],al ;imprime o da cor
    ;jmp pula_imprime_data
    cmp [qualCaracter],2
    je posiciona_num_9x7

posiciona_num_romanos:
    mov es:[BX+SI+1442],AL ;imprime o valor ;1440 - 32 centraliza na tela
    mov al,[corCaracter]
    mov es:[BX+SI+1443],al ;imprime o da cor
    jmp pula_imprime_data

posiciona_num_9x7:
    mov es:[BX+SI+1122],AL ;imprime o valor ;1440 - 32 centraliza na tela
    mov al,[corCaracter]
    mov es:[BX+SI+1123],al ;imprime o da cor
    jmp pula_imprime_data
   
imprime_data:
    mov es:[BX+SI+3060],AL ;imprime o valor ;1440 - 32 centraliza na tela
    mov al,[corCaracter]
    mov es:[BX+SI+3061],al ;imprime o da cor
    jmp pula_imprime_data   
   
imprime_semana:
    mov es:[BX+SI+162],AL ;imprime o valor ;1440 - 32 centraliza na tela
    mov al,[corCaracter]
    mov es:[BX+SI+163],al ;imprime o da cor
   
pula_imprime_data:
    mov si,[qualCaracter]
    mov bx,[totColunasCaracter+si]
    inc [vColuna]
 ;   xchg bl,bh       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    cmp [vColuna],bx;6   
    ;pop bx
    jae zera_cx 
    pop bx
    jmp continua
   
terminou_imprimir_digito: ;cai fora quando terminar...
    mov si,[qualCaracter]
    mov ax,[totOcupaCaracter+si]
  ;  xchg al,ah                     ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    add [contrDigito],ax;12
    mov ah, [opcaoImprimir]
    cmp [contrCaracterTot],ah
    jae pula
    inc [contrCaracterTot]
    cmp si,0
    je pega_denovo_6x6   
    lea bx,numb_0 
    jmp pegou_9x7
pega_denovo_6x6:
    lea bx,numero_0
pegou_9x7:
    mov ah,0
    mov al,[contrCaracter2] 
    cmp si,1
    ja dec_si_pegar_var_db
    jmp pula_dec
     
dec_si_pegar_var_db:
    dec si 
   
pula_dec:
    mov cl,[tamBytesCaracter+si]
    ;mov cl,42
    mul cl
    add bx, ax 
    mov [vColuna],0
    mov [vLinha],0
    jmp continua
   
pula:   
    mov [vColuna],0
    mov [vLinha],0
    mov [contrCaracterTot],0
    cmp [opcaoPosQuantImprimir],1 
    je contr_data
    ;cmp [opcaoPosQuantImprimir],2 ;3
    jmp contr_maximo              ;je
    ;cmp [contrDigito],96
    ;jae zeraContrDigito
    RET
   
contr_data:
    cmp [contrDigito],120
    jae zeraContrDigito
    RET             
   
contr_maximo:
    cmp [contrDigito],156
    jae zeraContrDigito
    RET

zeraContrDigito:
    mov [contrDigito],0
    ret     
     
zera_cx: ;devera incrementar a linha e verificar se esta na linha final..
    mov [vColuna], 0
    inc [vLinha]
    pop bx
    jmp continua
    ret     
IMPRIME_BIG_CARACTER ENDP 

ESCOLHENDO_COR PROC 
  lea dx,msg_escolheCor
  mov ah,9
  int 21h
 
  ; read character in al:
  mov ah, 1
  int 21h
  sub al,"0"
  mov [corCaracter],al
  RET
ESCOLHENDO_COR ENDP 

PEGA_DATA PROC
    mov ah,2Ah
    int 21h     
   
    push cx
    push dx
    ;CALL CONVERTE  ; al dia da semana
    ;call IMPRIME_BIG_CARACTER
    CALL IMPRIME_DIA_SEMANA ;esta em al ja o numero de 0 - 6
    pop dx
   
    mov al,dl      ; dia
    ;xor dl,30H
     
    push dx
    CALL CONVERTE
    mov dh,al
    add dh,48
    mov [pegaData+9],dh
    mov dh,ah
    add dh,48
    mov [pegaData+8],dh
    mov [pegaData+7],"/"
    call IMPRIME_BIG_CARACTER
    mov al,"/"               
    mov [opcaoImprimir],0 
    mov [corCaracter],1
    call IMPRIME_BIG_CARACTER
    mov [corCaracter],8
    mov [opcaoImprimir],1
    pop dx
    mov al,dh      ;mes 
    CALL CONVERTE
    mov dh,al
    add dh,48
    mov [pegaData+6],dh
    mov dh,ah
    add dh,48
    mov [pegaData+5],dh
    mov [pegaData+4],"/"
   
    call IMPRIME_BIG_CARACTER
    mov [opcaoImprimir],0 
    mov [corCaracter],1
    mov al,"/"
    call IMPRIME_BIG_CARACTER 
    mov [corCaracter],8
    mov [opcaoImprimir],1
    pop cx
    mov [ano], cx 
    call IMPRIME_ANO
   
    mov [opcaoImprimir],1
   
    mov [opcaoPosQuantImprimir],0

   
    ;Return: CX = year (1980-2099)
    ;DH = month
    ;DL = day
    ;AL = day of week (00h=Sunday)
    RET
PEGA_DATA ENDP


IMPRIME_ANO PROC
    mov [divAno], 1000
    mov cx,0
    mov [opcaoImprimir],0
    lea bx,pegaData
    add bx,3
divide_ano:
    mov dx, 0
    mov ax, [ano]
    idiv [divAno]  ; ax = (dx ax) / num2.
    ;imprimir AL 2012 - [2]
    push ax             
    push dx
    push cx   
    mov dh,al
    add dh,48 
    mov [bx],dh
    push bx
    call IMPRIME_BIG_CARACTER
    pop bx
    pop cx
    pop dx
    pop ax
    dec bx
    mul [divAno]     
    sub [Ano],ax
   
    cmp dx, 0 ;dx esta com o 012
    inc cx
    je fim_divide
    cmp cx,1
    je dec_900
    cmp cx,2
    je dec_90
    cmp cx,3
    je dec_9
    ;cmp cx,4
    jae fim_divide
    ;jmp divide_ano

dec_900:
    mov [divAno], 100
    jmp divide_ano
dec_90:
    mov [divAno], 10
    jmp divide_ano
dec_9:
    mov [divAno], 1
    jmp divide_ano
   
fim_divide:         
    RET   
IMPRIME_ANO ENDP


IMPRIME_DIA_SEMANA PROC
    mov [opcaoImprimir],0 ;um caracter por vez
    mov [opcaoPosQuantImprimir],3
;limpar a msg_rotativa...
    lea bx,msg_rotativa
prox_caracter_limpar:   
    mov [bx]," "
    inc bx
    cmp [bx],"$"
    jne prox_caracter_limpar
;fim limpar a msg_rotativa...     
    mov bx, 0
    mov di,0 
    lea bx,pegaData
    mov [bx+10],"-"
    add bx,11       
    mov [bx],"-"
    inc bx
    mov [bx],"-"
    inc bx
    mov [bx],"-"
    inc bx
    mov [bx],"-"
    inc bx
    mov [bx],"-"
    inc bx
    mov [bx],"-"
    inc bx
    mov [bx],"-"
    inc bx
    mov [bx],"-"
    sub bx,7
    cmp al, 0 ;domingo
    je domingo
    cmp al, 1 ; segunda 
    je segunda
    cmp al, 2 ; terca
    je terca
    cmp al, 3 ; quarta
    je quarta
    cmp al, 4 ; quinta
    je quinta
    cmp al, 5 ; sexta 
    je sexta
    ;sabado 6
    mov [bx],"o"
    inc bx
    mov [bx],"d"
    inc bx
    mov [bx],"a"
    inc bx
    mov [bx],"b"
    inc bx
    mov [bx],"a"
    inc bx
    mov [bx],"s"
    lea bx,sab
    mov [imprimirFeira],0 
    jmp imp_prox
   
domingo:   
    mov [bx],"o"
    inc bx
    mov [bx],"g"
    inc bx
    mov [bx],"n"
    inc bx
    mov [bx],"i"
    inc bx
    mov [bx],"m"
    inc bx
    mov [bx],"o"
    inc bx
    mov [bx],"d"
    lea bx,dom
    mov [imprimirFeira],0
    jmp imp_prox
   
segunda:
    mov [bx],"a"
    inc bx
    mov [bx],"d"
    inc bx
    mov [bx],"n"
    inc bx
    mov [bx],"u"
    inc bx
    mov [bx],"g"
    inc bx
    mov [bx],"e"
    inc bx
    mov [bx],"s"
    lea bx,seg
    mov [imprimirFeira],1 
    jmp imp_prox   
   
terca:   
    mov [bx],"a"
    inc bx
    mov [bx],"c"
    inc bx
    mov [bx],"r"
    inc bx
    mov [bx],"e"
    inc bx
    mov [bx],"t"
    lea bx,ter
    mov [imprimirFeira],1
    jmp imp_prox
   
quarta: 
    mov [bx],"a"
    inc bx
    mov [bx],"t"
    inc bx
    mov [bx],"r"
    inc bx
    mov [bx],"a"
    inc bx
    mov [bx],"u"
    inc bx
    mov [bx],"q"
    lea bx,qua 
    mov [imprimirFeira],1
    jmp imp_prox
   
quinta:   
    mov [bx],"a"
    inc bx
    mov [bx],"t"
    inc bx
    mov [bx],"n"
    inc bx
    mov [bx],"i"
    inc bx
    mov [bx],"u"
    inc bx
    mov [bx],"q"
    lea bx,qui
    mov [imprimirFeira],1 
    jmp imp_prox
   
sexta:   
    mov [bx],"a"
    inc bx
    mov [bx],"t"
    inc bx
    mov [bx],"x"
    inc bx
    mov [bx],"e"
    inc bx
    mov [bx],"s"         
    lea bx,sex 
    mov [imprimirFeira],1

imp_prox: 
    mov al,[bx]
    inc bx
    push bx
        lea bx, msg_rotativa
        mov [msg_rotativa+DI],al
        inc di
    Call IMPRIME_BIG_CARACTER
    pop bx
    cmp [bx],"$"
    jne imp_prox
    cmp [imprimirFeira],1
    je imprime_feira
    ;cmp [contrDigito],156
    ;jae finaliza_dia_semana
    jmp finaliza_dia_semana

imprime_feira:
    mov [imprimirFeira],0 ;informa q ja imprimiu
    lea bx,feira
    jmp imp_prox               
   
finaliza_dia_semana:       
    mov [opcaoImprimir],1 ;seta pra 2
    mov [opcaoPosQuantImprimir],1 ; seta pra hora 
    mov [vColuna],0
    mov [contrDigito],0
    mov [vLinha],0
    mov [contrCaracterTot],0
   
    RET   
IMPRIME_DIA_SEMANA ENDP

PASSA_MSG PROC
    mov [opcaoImprimir],0 ;um caracter por vez
    mov [opcaoPosQuantImprimir],3
    lea bx, msg_rotativa
    ;tenho q rotacionar ela primeiro...
    cmp [tpEfeitoRotacao],1
    je ini_efeito1

ini_efeito2:
    mov di,0           ;<<<<
    mov al,[bx]        ;<<<< guarda a primeira     
    jmp efeito2 
   
ini_efeito1:     
    mov di,22         ; >>>>> 
    mov al,[bx+23]    ; >>>> guardo a ultima posicao
 
efeito1:
    mov ah,[bx+DI]     ;>>>>pego a ultima
    mov [bx+DI+1],ah   ;>>>>jogo na primeira
    sub DI,1           ;>>>>>>   
    jnc efeito1        ;>>>>>>>>
    mov [bx],al  ;>>>>>jogo o q tava na ultima pra primeira... e acabou
    jmp comeca_imprimir_msg
   
efeito2:     
    mov ah,[bx+DI+1]     ;<<<<pego a ultima
    mov [bx+DI],ah   ;<<<<jogo na primeira
    inc di              ;<<<<
    cmp di,23           ;<<<<
    jne efeito2    ;<<<< 
    mov [bx+23],al ;<<<<     
   
comeca_imprimir_msg:
    mov di,0
imp_prox_rot:
    cmp [tpEfeitoRotacao],3
    je imp_efeito3
    mov al,[bx+di]
    push bx
    push di
    Call IMPRIME_BIG_CARACTER
    pop di
    pop bx
    inc di     
    cmp di,13
    jne imp_prox_rot
    jmp pula_efeito3
imp_efeito3:
    mov al,[bx]
    push di
    push bx
    Call IMPRIME_BIG_CARACTER
    pop bx
    pop di
    inc di
    cmp di,13
    jne imp_efeito3

pula_efeito3:   
    mov [opcaoImprimir],1 ;seta pra 2
    mov [opcaoPosQuantImprimir],1 ; seta pra hora 
    mov [vColuna],0
    mov [contrDigito],0
    mov [vLinha],0
    mov [contrCaracterTot],0
         
    RET   
PASSA_MSG ENDP   

BARR_GRAFF PROC  ;BX , DX, SI, AL
    mov si,0
    mov bx,2580
    mov dh,0
    mov dl,[contrPontos]
    mov cl,1
    ;mov al,[caracterAscii]
   
    ;add al,16 ; pegar as cores com bacground 
    mov al,[corCaracter]
    shl al,4 
    mov ah, al
   
inc_barra:
    push cx
    push dx
    push ax     
    MOV AH, 0H ; mostra horario
    mov al,cl
    MOV DL,5
    DIV DL     
    ;ah tera o resto da divisao
    ;ex.: 47 / 10 ah = 7 al = 4 
    cmp ah,0 
    je muda_cor_barra
    pop ax
    pop dx
    pop cx
    mov al,ah ; pega a cor denovo, caso tenha mudado precisa retomar
    mov dh,0
   
ja_mudou: 
    cmp cl,[guardaMinutos]
    jbe coloca_caracter_minutos 
    jmp nao_coloca_caracter_minutos   
   
coloca_caracter_minutos: 
    cmp cl,[guardaMinutos]
    jae liberar_nova_msg_barra
    mov [aguardaMsgSumirTroca],1 ;bloqueia troca
    jmp nao_libera_nova_msg_barra
   
liberar_nova_msg_barra:
    mov [aguardaMsgSumirTroca],0 ;libera troca

nao_libera_nova_msg_barra:
    cmp cl,[guardaMinutos]
    je caracter_da_ponta

    push ax
    mov ah,[guardaMinutos]
    sub ah,3             
    cmp cl,ah            ;se for igual ou maior posso colocar o pm, am...
    jae ja_tem_3_caracteres                             
    cmp dh,"|" ;verifica se tem caracter de 5 em 5 seg..
    jne ainda_nao_e_pm_am  ;se nao tiver
    pop ax
    mov dh,197
    jmp nao_coloca_caracter_minutos
   
;pode_colocar_carac_min:
    ;push ax
    ;mov ah,[guardaMinutos]
    ;sub ah,3             
    ;cmp cl,ah            ;se for igual ou maior posso colocar o pm, am...
    ;jae ja_tem_3_caracteres
    ;jmp ainda_nao_e_pm_am
;ini controle do PM e AM ----------   
ja_tem_3_caracteres:
    mov ah,[guardaMinutos]
    sub ah,3
    cmp cl,ah
    je coloca_pm_am_1
    inc ah
    cmp cl,ah
    je coloca_pm_am_2 
    cmp dh,"|" ;verifica se tem caracter de 5 em 5 seg.. 
    je identificacao_de_5_seg
    jmp ainda_nao_e_pm_am
identificacao_de_5_seg:
    pop ax
    mov dh,197
    jmp nao_coloca_caracter_minutos
   
coloca_pm_am_1:
    cmp [CntrAM_PM],0             
    je mostra_am
    mov dh,"p"
    jmp pegou_am_pm
mostra_am:
    mov dh,"a"
pegou_am_pm:
    pop ax
    jmp nao_coloca_caracter_minutos
   
coloca_pm_am_2:
    mov dh,"m"
    pop ax
    jmp nao_coloca_caracter_minutos
;fim controle do PM e AM ----------
   
ainda_nao_e_pm_am:   
    mov dh,"-"
    pop ax
    jmp nao_coloca_caracter_minutos
     
caracter_da_ponta:
    mov dh,26
   
nao_coloca_caracter_minutos:   
    mov es:[BX],dh ;caracter   
   
    mov es:[BX+1],al ;imprime o da cor
    add bx,2 
    inc cl
    cmp cl,dl
    jbe inc_barra
    cmp cl,61 ;tamanho total da barra + 1 pq si vai poder chegar a 60
    mov si,26 ;controle da data na barra ;tamanho da msg da barra
    jbe limpar_resto_barra
    jmp terminou_barra  ;terminou a barra

muda_cor_barra:
     
    mov dh,0
    cmp al,3 ;15
    je mudar_cor_unidade_barra
     

   
    cmp al,6 ;30       
    je mudar_cor_unidade_barra_2

   
    cmp al,9 ;45
    je mudar_cor_unidade_barra 

   
    jmp pula_unidade_cor_barra         ;se nao for nao incrementa...

mudar_cor_unidade_barra_2:
    add dh,1   
     
mudar_cor_unidade_barra:
    add dh,1 
   
    pop ax   
    mov al, [corCaracter]
    inc al
    add al,dh ;se for 10 em 10...
    shl al,4
    pop dx
    mov dh,0
    jmp unidade_com_cor

pula_unidade_cor_barra:
    pop ax   
    mov al, [corCaracter]
    shl al,4
    mov cl, [corCaracter]
    add cl,2
    add al,cl
    pop dx
    mov dh,"|"
unidade_com_cor:   
    ;add al,2
       
    pop cx
    jmp ja_mudou   
   
limpar_resto_barra:

    cmp cl,[guardaMinutos]
    mov dl,7
    jbe pode_colocar_carac_min_s_fundo
    mov dl,0
    mov dh,0 
    jmp nao_coloca_caracter_minutos_s_fundo   
 
pode_colocar_carac_min_s_fundo: 
    cmp cl,[guardaMinutos]
    je caracter_da_ponta_s_fundo
;ini controle da data na barra
    cmp cl,[guardaMinutos]
    jae liberar_troca_msg_barra
    mov [aguardaMsgSumirTroca],1 ;bloqueia troca
    jmp pula_liberar_msg   
   
liberar_troca_msg_barra:
    mov [aguardaMsgSumirTroca],0 ;libera troca   
   
pula_liberar_msg:   
    cmp si,26   ;tamanho da msg da barra
    jbe pega_prox_numero_data
    ;jmp nao_pode_trocar
nao_pode_trocar: 
    mov dh,"-"
    jmp nao_coloca_caracter_minutos_s_fundo 
   
pega_prox_numero_data:
    cmp [cntrMsgBarra],4
    je pega_msg_entra_barra4
    cmp [cntrMsgBarra],3
    je pega_msg_entra_barra3
    cmp [cntrMsgBarra],2
    je pega_msg_entra_barra2   
    cmp [cntrMsgBarra],1
    je pega_msg_entra_barra1
    mov dh,[pegaData+si];"-"         mensagem a ser exibida na barra
    jmp pegou_msg   

pega_msg_entra_barra4:
    mov dh,[pegaData5+si];
    jmp pegou_msg
       
pega_msg_entra_barra3:
    mov dh,[pegaData4+si];
    jmp pegou_msg
   
pega_msg_entra_barra2:
    mov dh,[pegaData3+si];
    jmp pegou_msg
         
pega_msg_entra_barra1:
    mov dh,[pegaData2+si]; 
   
pegou_msg:
    dec si
;fim controle da data na barra
    jmp nao_coloca_caracter_minutos_s_fundo
   
caracter_da_ponta_s_fundo:
    mov dh,26
   
nao_coloca_caracter_minutos_s_fundo:
    mov es:[BX],dh ;caracter
    ;inc bx
    mov es:[BX+1],dl ;imprime o da cor
    add bx,2 
    inc cl
    cmp cl,60
    jbe limpar_resto_barra
   
terminou_barra:   
    RET
BARR_GRAFF ENDP

NUMEROS_ROMANOS PROC
;VOU PRECISAR DOS NUMEROS DIVIDIDOS...
    ;AL = primeiro digito
    ;AH = segundo digito
    ; zerar o SI quando chamar pela primeira vez
    ;mov al,[contrCaracter1] ;primeiro
    ;mov ah,[contrCaracter2] ;segundo
    lea bx,hora_romana 
    mov si,di     
   
    cmp al,1
    je n_10
    cmp al,2
    je n_20
    cmp al,3
    je n_30
    cmp al,4
    je n_40
    cmp al,5
    je n_50 
   
   
romanos_pega_segundo:       
    cmp ah,1
    je n_1
    cmp ah,2
    je n_2
    cmp ah,3
    je n_3
    cmp ah,4
    je n_4
    cmp ah,5
    je n_5
    cmp ah,6
    je n_6
    cmp ah,7
    je n_7
    cmp ah,8
    je n_8
    cmp ah,9
    je n_9
    cmp ah,0
    je n_0
    jmp romanos_pronto
n_0: ;
    cmp al,0
    je romanos_pronto
    dec si   
jmp romanos_pronto
n_3: ; III
    mov [bx+si],"i"
    inc si
n_2: ; II
    mov [bx+si],"i"
    inc si       
n_1: ; I 
    mov [bx+si],"i"

jmp romanos_pronto

n_4: ; IV
    mov [bx+si],"i"
    inc si
n_5: ; V
    mov [bx+si],"v"
   
jmp romanos_pronto
n_6: ; VI
    mov [bx+si],"v"
    inc si
    mov [bx+si],"i"
   
jmp romanos_pronto
n_7: ; VII
    mov [bx+si],"v"
    inc si 
    mov [bx+si],"i"
    inc si
    mov [bx+si],"i"
   
jmp romanos_pronto
n_8: ; IIX
    mov [bx+si],"i"
    inc si
    mov [bx+si],"i"
    inc si
    mov [bx+si],"x"
   
jmp romanos_pronto
n_9: ; IX
    mov [bx+si],"i"
    inc si
    mov [bx+si],"x"
   
jmp romanos_pronto

n_30:
    mov [bx+si],"x"
    inc si
n_20:
    mov [bx+si],"x"
    inc si
n_10:; X
    mov [bx+si],"x"
    inc si
jmp romanos_pega_segundo

n_40:; XL   
    mov [bx+si],"x"
    inc si   
n_50:; L   
    mov [bx+si],"l"
    inc si
jmp romanos_pega_segundo

romanos_pronto:
    inc si
    mov [bx+si],"$" 
   
    RET   
NUMEROS_ROMANOS ENDP   

CENTRALIZAR_NUMEROS_ROMANOS PROC
    ;centralizar a escrita num romanos...
    ;13 posicoes na tela.. (si) tem o tamanho total q gerou
    ;subtrair 13 de si e dividir o valor.. esse sera o tanto para centralizar
    ;mov ax,si
    ;add ax,13 ;pra gerar sub sempre positiva
    mov si,di
    mov ax,13
    sub ax,si
    cmp al,1
    jbe romanos_pula_div_zero
    mov cl,2
    div cl
 
    ;ah al...
    mov ah, al ;saber depois o total de vezes q fiz isto...
    ;push si
    mov di,si
romanos_continua_centralizar:   
    mov cl,[bx+si]   ;pego a ultima posicao
    mov [bx+si+1],cl ;e avanco ela
    dec si           ;dec si
    cmp si,65535
    jne romanos_continua_centralizar
    mov [bx]," "
    ;pop si
    ;inc si
    ;push si
    inc di   
    dec al           ;dec al que esta com o total de vezes que irei fazer isto..
    cmp al,0       ;comparo pra ver se ja posso parar...
    mov si,di
    jne romanos_continua_centralizar
romanos_pula_div_zero:   
    ;xchg al,ah   
    ;add si,ax  ;al ja esta com 0, ira incrementar em si o total de vezes q avacou a msg
    ;cmp si,13
    ;jb romanos_limpar_resto     
;fim centralizar a escrita num romanos...
    RET   
CENTRALIZAR_NUMEROS_ROMANOS ENDP

IMPRIMIR_NUMEROS_ROMANOS PROC
    lea bx,hora_romana
    xor si,si ;zera si
    mov [opcaoImprimir],0         ;informa q vou imprimir 1 caracter por vez...
    mov [opcaoPosQuantImprimir],2 ;seta para numeros romanos...
    mov [contrCaracterTot],0
    mov [vColuna],0   
    mov [contrDigito],0
    mov [vLinha],0
romanos_prox_caracter:   
    mov al,[bx+si]
    push si 
    push bx 
 
    CALL IMPRIME_BIG_CARACTER

    pop bx       
    pop si
    inc si
    cmp [bx+si],"$"
    jne romanos_prox_caracter 
    cmp si,13
    jbe romanos_limpar_resto ;se ainda nao preencheu a tela...
    jmp romanos_finaliza ;senao sai fora


romanos_limpar_resto:
    mov al," "
    push si
    CALL IMPRIME_BIG_CARACTER
    pop si
    inc si
    cmp si,13
    jbe romanos_limpar_resto   
romanos_finaliza:
    mov [vColuna],0   
    mov [contrDigito],0
    mov [vLinha],0                       
    RET
IMPRIMIR_NUMEROS_ROMANOS ENDP


LIMPA_AREA_RELOGIO PROC
    push bx
    xor bx,bx ;zera bx
limpa_area_caracter:
;posiciona_num_9x7:
    mov es:[BX+1122],0 ;imprime o valor ;1440 - 32 centraliza na tela
    mov es:[BX+1123],0 ;imprime o da cor

    add bx,2
    cmp bx,1440 ;9 linhas ate o final...
    jbe limpa_area_caracter ;se ainda nao preencheu a tela...
    pop bx
    RET   
LIMPA_AREA_RELOGIO ENDP

   
fim: ;Exit:
    mov ax, 4c00h ; exit to operating system.
    int 21h   
ends

end start ; set entry point and stop the assembler.

[tcpipchip]

http://www.inf.furb.br/~maw/asm51/relogioNUM.exe
Preferivel rodar com o DOSBOX...
Abraços
TCPIPCHIP