Código assembly PIC16: Relógio e contagem até 9999d

Publicado em Eletrônica
O código abaixo, para microcontroladores PIC, foi escrito com a inteção inicial de apenas exibir dígitos em 4 displays de sete segmentos multiplexados através de 4 transistores, entretanto, o ele foi expandido para ter as seguintes funcionalidades:
Conversão hexadecimal para BCD
Relógio (clock de 20Mhz) com ticks de
- 1ms,
- 2ms,
- 10ms,
- 100ms,
- 1 segundo,
- 1 minuto,
- 30minutos,
- 1 hora;
Há duas funções de conversão de hexadecimal para BCD: a primeira realiza a conversão de um número hexadecimal de 8 bits exibindo até dois dígitos nos displays e a outra converte um número de 16 bits aproveitando todos os quatro dígitos do hardware alvo.
O software utiliza a interrupção do TMR1 do PIC para fazer a temporização do "relógio". Para uma melhor organização de sua estrutura, o código a ser executado a cada intervalo de tempo foi lmovido para a seção "Relógio" após o loop principal main.
E para tornar o sistema semelhante às interrupções originais, foi criado um conjunto de flags para os intervalos de tempo. As funções de conversão hexadecimal para BCD já foram discutidas em outros tópicos.
Caso tenha alguma sugestão ou dúvida, deixe um comentário ou crie um tópico no fórum.
;*********************************************************
;    LICENÇA  GPLv3
;*********************************************************

;{ 
; Funções essenciais para a família de microcontroladores PIC16
; Copyleft (C) 2008  Pedro Henrique

;This program is free software: you can redistribute it and/or modify
;it under the terms of the GNU General Public License as published by
;the Free Software Foundation, either version 3 of the License, or
;any later version.

;This program is distributed in the hope that it will be useful,
;but WITHOUT ANY WARRANTY; without even the implied warranty of
;MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;GNU General Public License for more details.

;You should have received a copy of the GNU General Public License
;along with this program.  If not, see <http://www.gnu.org/licenses/>.
;}

;*********************************************************
;    16F877A
;*********************************************************
    list     p=16f877a
    #include p16f877a.inc

    __config _HS_OSC & _WDT_OFF & _LVP_OFF & _CP_OFF 

    errorlevel -302

;*********************************************************
;     DIRETIVAS
;*********************************************************

; hardware para o display de 7 segmentos
#define DISPLAY_7SEGMENTOS 
#define DELAY
#define toBCD
#define RELOGIO

;*********************************************************
;    CONSTANTES
;*********************************************************

; PORTB conectada aos transistores e bits de dados (BCD)
#define PORT_DISPLAY_7SEGMENTOS  PORTB

; relógio
#define RF_1hora    relogio_flags,7
#define RF_30min    relogio_flags,6
#define RF_1min    relogio_flags,5
#define RF_1seg    relogio_flags,4
#define RF_100ms    relogio_flags,3
#define RF_10ms    relogio_flags,2
#define RF_2ms        relogio_flags,1
#define RF_1ms        relogio_flags,0

;*********************************************************
;     VARIÁVEIS
;*********************************************************
    cblock 0x20
;{
    ; VARIÁVEIS EXTERNAS
        k_low
        k_high

        ; interrupções - contexto
        w_temp
        status_temp

        ; tempo a ser atrasado, para funções delay_ms e delay_10us
        delay
    endc

#ifdef RELOGIO
    cblock        
        ; flags para o relógio
        relogio_flags
        relogio_1ms
        relogio_2ms
        relogio_10ms
        relogio_100ms
        relogio_1seg
        relogio_1min
        relogio_30min
        relogio_1hora
    endc        
#endif

#ifdef toBCD ; 43:21
    cblock 
        ; utilizado nas rotinas de conversão BCD
        BCD_low        ; número a ser convertido, 8 ou 16 bits
        BCD_high        ; parte mais significativa, para 16 bits
        BCD_unidades    ; 8 bits
        BCD_dezenas    ; 8 bits
        BCD_centenas    ; números de 16 bits
        BCD_milhares    ; números de 16 bits

        ;variáveis externas
        display_high;  mostra4digitos
        display_low;  mostra4digitos
        posicao

        ; variáveis internas
        digitos_low ; menos significativo
        digitos_high ; mais significativo
        mostra1_digito_7seg
        mostra1_posicao_7seg
    endc
#endif
;}
;*********************************************************


;*********************************************************
;    MACROS
;*********************************************************

BEGIN_CRITICO macro
;{
    bcf INTCON,GIE
    endm

END_CRITICO macro
    bsf INTCON,GIE
    endm

;}
;*********************************************************


;*********************************************************
;    0x00
;*********************************************************
    org 0x00
     goto start


;*********************************************************
;    INTERRUPÇÕES
;*********************************************************
    org 0x04
;{
    ; salva contexto
    movwf w_temp
    swapf STATUS,w
    movwf status_temp


    btfsc PIR1,TMR1IF
        goto INT_TIMER1    
    btfsc INTCON, TMR0IF
        goto INT_TIMER0
    btfsc INTCON,INTF
        goto INT_INT
    btfsc INTCON,RBIF
        goto INT_RB
    btfsc PIR1,TMR2IF
        goto INT_TIMER2

    goto INT_FIM





INT_TIMER1:
;{
; TMR1 é utilizado no sistema de ticks. A cada 1 ms

    ; AJUSTE - 0,6us
    nop
    nop
    nop

    ; .2us * 8 * (65536(0xFFFF)-64911(0xFD8F) = 625 = 0x271)
    banksel TMR1H
    movlw 0xFD    ; valor inicial para se obter um tick a cada 1ms
    movwf TMR1H
    movlw 0x91 ; testes demonstraram que 0x91 é o valor ótimo
    movwf TMR1L
    bsf T1CON,TMR1ON

    incf relogio_1ms,f
    bsf RF_1ms

    movlw 0x02
    subwf relogio_1ms,w
    btfss STATUS,Z
        goto relogio_verifica_flags; diferente de 2
    clrf relogio_1ms

    incf relogio_2ms,f
    bsf RF_2ms
    movlw 0x05
    subwf relogio_2ms,w
    btfss STATUS,Z
        goto relogio_verifica_flags; diferente de 5
    clrf relogio_2ms

    incf relogio_10ms,f
    bsf RF_10ms
    movlw .10
    subwf relogio_10ms,w
    btfss STATUS,Z
        goto relogio_verifica_flags; diferente de 10
    clrf relogio_10ms

    incf relogio_100ms,f
    bsf RF_100ms
    movlw .10
    subwf relogio_100ms,w
    btfss STATUS,Z
        goto relogio_verifica_flags; diferente de 10
    clrf relogio_100ms

    incf relogio_1seg,f
    bsf RF_1seg
    movlw .60
    subwf relogio_1seg,w
    btfss STATUS,Z
        goto relogio_verifica_flags; diferente de 60
    clrf relogio_1seg

    incf relogio_1min,f
    bsf RF_1min
    movlw .30
    subwf relogio_1min,w
    btfss STATUS,Z
        goto relogio_verifica_flags; diferente de 30
    clrf relogio_1min

    incf relogio_30min,f
    bsf RF_30min
    movlw .2
    subwf relogio_30min,w
    btfss STATUS,Z
        goto relogio_verifica_flags; diferente de 2
    clrf relogio_30min

    incf relogio_1hora,f
    bsf RF_1hora

relogio_verifica_flags:    
; TMR1 configurado para estourar de 1ms em 1ms    
    btfsc RF_1ms
        call _1ms
    btfsc RF_1hora
        call _1hora
    btfsc RF_30min
        call _30min
    btfsc RF_1min
        call _1min
    btfsc RF_1seg
        call _1seg
    btfsc RF_100ms
        call _100ms
    btfsc RF_10ms
        call _10ms
    btfsc RF_2ms
        call _2ms

relogio_fim:

timer1_fim:
    bcf PIR1,TMR1IF
    goto INT_FIM
; ---------------------------------------------------------------------
;}    





INT_TIMER0: 
;{
; TMR0 é utilizado na função delay

#ifdef DELAY
delay_int_ms:
    ; TMR0 = a cada 1 ms    
    banksel delay
    movf delay,f
    btfss STATUS,Z
        decf delay,f

    banksel TMR0
    movlw .217; (.256-.39) = 39 ciclos necessários
    movwf TMR0

    goto delay_int_fim
    ; TMR0 = a cada 1 ms

delay_int_fim:
#endif

timer0_fim:
    bcf INTCON,TMR0IF
    goto INT_FIM
; ---------------------------------------------------------------------
;}    




INT_TIMER2:
;{


timer2_fim:    
    bcf PIR1,TMR2IF
    goto INT_FIM
; ---------------------------------------------------------------------

;}


INT_RB:
;{

rb_fim:
    bcf INTCON,RBIF
    goto INT_FIM
; ---------------------------------------------------------------------
;}    



INT_INT:
;{
int_int_fim:
    bcf INTCON,INTF
    goto INT_FIM
; ---------------------------------------------------------------------
;}





INT_FIM:
;{

    swapf status_temp,w
    movwf STATUS

    swapf w_temp, f
    swapf w_temp,w

    retfie
;}
;}
; ---------------------------------------------------------------------


;*********************************************************
;    INÍCIO
;*********************************************************
start:
;{
    ; apaga RAM
    ;{
    clrf TMR0

    banksel delay
    clrf delay

    #ifdef RELOGIO
    clrf relogio_flags
    clrf relogio_1ms
    clrf relogio_2ms
    clrf relogio_10ms
    clrf relogio_100ms
    clrf relogio_1seg
    clrf relogio_1min
    clrf relogio_30min
    clrf relogio_1hora
    #endif RELOGIO


#ifdef DISPLAY_7SEGMENTOS 
    banksel BCD_low
    clrf    BCD_low        
    clrf    BCD_high        
    clrf    BCD_unidades
    clrf    BCD_dezenas
    clrf    BCD_centenas
    clrf    BCD_milhares

    clrf    digitos_low
    clrf    digitos_high 
    clrf    mostra1_digito_7seg
    clrf    mostra1_posicao_7seg
    clrf posicao

#endif

    ;}


    ; Ativa interrupções
    bsf INTCON,GIE    ; ativa chave geral de interrupções    
    bsf INTCON,PEIE    ; ativa chave geral de periféricos
    banksel PIE1
    bsf PIE1,TMR1IE    ; TMR 1

#ifdef RELOGIO
    ; sistema de ticks
    banksel T1CON
    bcf T1CON,TMR1CS        ; TMR1 é incrementado com o clock
    bsf T1CON,T1CKPS1    ; pre-scale configurado para TMR1
    bsf T1CON,T1CKPS0    ; 1:8
    bcf T1CON,T1OSCEN    ; desativa oscilador externo

    ; .2us (20 Mhz) * 8 (scale) * (65536-64911 = 625 = 0x271)
    movlw 0xFD    ; valor inicial para se obter um tick a cada 1ms
    movwf TMR1H
    movlw 0x8F
    movwf TMR1L
    bsf T1CON,TMR1ON
    ;----
#endif

    ; configura PORTB para uso com os displays de 7 segmentos
    banksel TRISB
    movlw 0x00
    movwf TRISB    ; PORTB
    banksel PORTB
    clrf PORTB
    ;----




    banksel BCD_high
    movlw 0x00
    movwf k_high
    movlw 0x00
    movwf k_low


;} 
;*********************************************************


;*********************************************************
;    LOOP PRINCIPAL - MAIN
;*********************************************************

main:
;{

    banksel k_high
    movf k_high,w
    movwf BCD_high
    movf k_low,w
    movwf BCD_low
    call toBCD16

    movf BCD_high,w
    movwf display_high
    movf BCD_low,w
    movwf display_low

    goto main
;} 
;*********************************************************


;*********************************************************
;    Relógio
;*********************************************************

_1ms:

    bcf RF_1ms
    return ; _1ms
;---------------------------------------------------------------------
_2ms:


    bcf RF_2ms
    return ; _2ms
;---------------------------------------------------------------------
_10ms:

    banksel k_low
    incf k_low,f
    btfsc STATUS,Z
        incf k_high,f

    movlw 0x27
    subwf k_high,w
    btfsc STATUS,C
        clrf k_high

    bcf RF_10ms
    return ; _10ms
;---------------------------------------------------------------------
_100ms:


    bcf RF_100ms
    return ; _100ms
;---------------------------------------------------------------------
_1seg:


    bcf RF_1seg
    return ; _1seg
;---------------------------------------------------------------------
_1min:

    bcf RF_1min
    return ; _1min
;---------------------------------------------------------------------
_30min:

    bcf RF_30min
    return ; _30min
;---------------------------------------------------------------------
_1hora:

    bcf RF_1hora
    return ; _1hora
;---------------------------------------------------------------------



;*********************************************************


;*********************************************************
;<FUNÇÃO> 
; delay_us
;{
;<HARDWARE> 

; <ARGUMENTOS>
; delay = quantidade de microsegundos a serem atrasados
;*********************************************************
delay_us:
    ;clock = 20Mhz
    banksel delay
    decfsz delay,f
        goto delay_us

    return ; delay_us
;} 
;*********************************************************


;*********************************************************
;<FUNÇÃO> 
; delay_ms
;{
;<HARDWARE> 

; <ARGUMENTOS>
; delay = quantidade de milisegundos a serem atrasados
;*********************************************************
delay_ms:

    ; função delay
    banksel OPTION_REG
    bcf OPTION_REG,T0CS    ; TMR0 é incrementado com o clock
    bcf OPTION_REG,PSA    ; pre-scale configurado para o TMR0
    bcf OPTION_REG,PS0    ; 1:128 => PS2:PS0 = 110
    bsf OPTION_REG,PS1    
    bsf OPTION_REG,PS2


    banksel TMR0
    movlw .217; (.256-.39) = 39 ciclos necessários
    movwf TMR0
    bsf INTCON,TMR0IE
    ;----

delay_ms_loop:
    banksel delay
    movf delay,f
    btfsc STATUS,Z
        goto delay_ms_fim

    goto delay_ms_loop

delay_ms_fim:
    bcf INTCON,TMR0IE

    return ; delay_ms
;} 
;*********************************************************

;*********************************************************
;<FUNÇÃO> 
; toBCD8
;{
; Converte um número de 8 bits em decimal para BCD

; <ARGUMENTOS>
; BCD_low = número de 8 bits a ser convertido em BCD

; <RETORNO>
; BCD_unidades = dígito menos significativo
; BCD_dezenas = dígito mais significativo
; BCD_low = ambos os dígitos
;*********************************************************
 #ifdef toBCD 

toBCD8 
    banksel BCD_low
    ; .100 invés de 99 para evitar o teste de igualdade
    movlw .100 ; verifica se o número é maior que .99
    subwf BCD_low,w
    btfsc STATUS, C
        clrf BCD_low; apaga o número caso for maior que .99

    clrf BCD_unidades ; apaga cálculos anteriores
    clrf BCD_dezenas

dezenas_toBCD8: ; dígito mais significativo
    movlw .10
    subwf BCD_low, f
    btfss STATUS, C
        goto unidades_toBCD8
    incf BCD_dezenas,f
    goto dezenas_toBCD8

unidades_toBCD8: ; dígito menos significativo
    movlw .10
    addwf BCD_low, f
    movf BCD_low, w
    movwf BCD_unidades    

    swapf BCD_dezenas,w
    iorwf BCD_unidades,w
    movwf BCD_low ; retorna o resultado também em BCD_low

    return ; toBCD8
#endif
;} 

;*********************************************************

;*********************************************************
;<FUNÇÃO> 
; toBCD16
;{
; Converte um número de 16 bits em decimal para BCD

; <ARGUMENTOS>
; BCD_low = 8 bits menos significativos a serem convertido em BCD
; BCD_high = 8 bits mais significativos a serem convertido em BCD

; <RETORNO>
; BCD_unidades = dígito menos significativo
; BCD_dezenas = dígito das dezenas
; BCD_centenas = dígito das centenas
; BCD_milhares = dígito mais significativo

; BCD_low = dígitos menos significativos
; BCD_high = dígitos mais significativos
;*********************************************************
 #ifdef DISPLAY_7SEGMENTOS 

; 20 Mhz:
; melhor tempo: 11,65 us
; pior tempo: 73,6 us

toBCD16: 
    banksel BCD_high
    movlw 0x27 ; verifica se o número é maior que .9999 = 0x270F
    subwf BCD_high,w

    btfsc STATUS, Z
        goto verifica_nibble_inferior_toBCD16    ; igual a 0x27?
    btfsc STATUS, C
        goto apagar_BCD_toBCD16 ; maior que 0x27?
    goto prosseguir_conversao_toBCD16 ; menor que 0x27?

verifica_nibble_inferior_toBCD16:
    movlw 0x0F ; verifica se o número é maior que .9999 = 0x270F
    subwf BCD_low,w
    btfsc STATUS, Z ; igual a 0x000F?
        goto prosseguir_conversao_toBCD16
    btfsc STATUS, C ; maior que 0x000F?
        goto apagar_BCD_toBCD16 
    goto prosseguir_conversao_toBCD16 

apagar_BCD_toBCD16: ; caso o número seja maior que 9999
    clrf BCD_low
    clrf BCD_high

prosseguir_conversao_toBCD16:
    clrf BCD_unidades ; apaga cálculos anteriores
    clrf BCD_dezenas
    clrf BCD_centenas
    clrf BCD_milhares


; INÍCIO DO PROCESSO DE CONVERSÃO
milhares_toBCD16: ; dígito mais significativo
    movlw 0x03
    subwf BCD_high,f
    btfsc STATUS,C
        goto milhares_low_toBCD16 ; >= 0x03
    movlw 0x03
    addwf BCD_high,f
    goto centenas_toBCD16

milhares_low_toBCD16:
    movlw 0xE8
    subwf BCD_low,f
    btfsc STATUS,C
        goto incrementa_milhares_toBCD16; >= 0xE8

    movf BCD_high,w
    btfsc STATUS,Z
        goto milhares_retorna_toBCD16 ; não é possível

    decf BCD_high,f    ; empréstimo efetuado    

    goto incrementa_milhares_toBCD16

milhares_retorna_toBCD16:
    movlw 0x03 ; restaura valor original
    addwf BCD_high,f
    movlw 0xE8; restaura valor original
    addwf BCD_low,f
    goto centenas_toBCD16 ; O número já não é maior que 1000

incrementa_milhares_toBCD16:
    incf BCD_milhares,f ; milhar contabilizado
    goto milhares_toBCD16


centenas_toBCD16:
    movlw 0x64
    subwf BCD_low,f 
    btfss STATUS,C ; BCD_low é menor que 0x64?
        goto empresta_um_toBCD16 ; Sim, tenta empréstimo
    incf BCD_centenas,f
    goto centenas_toBCD16

empresta_um_toBCD16:
    movlw 0x01
    subwf BCD_high,f ; subwf seta o Carry
    btfss STATUS,C
        goto centenas_retorna_toBCD16 ; empréstimo impossível
    incf BCD_centenas,f
    goto centenas_toBCD16

centenas_retorna_toBCD16:
    incf BCD_high,f
    movlw 0x64
    addwf BCD_low,f
    goto dezenas_toBCD16



;copiado de toBCD8 ------------

dezenas_toBCD16: ; dígito mais significativo
    movlw .10
    subwf BCD_low, f
    btfss STATUS, C
        goto unidades_toBCD16
    incf BCD_dezenas,f
    goto dezenas_toBCD16

unidades_toBCD16: ; dígito menos significativo
    movlw .10
    addwf BCD_low, f
    movf BCD_low, w
    movwf BCD_unidades    

;copiado de toBCD8 ------------



; O resutado pode ser obtido tanto no BCD_low e BCD_high ou 
; nos quatro files referentes às unidades, dezenas, centenas e milhares
    swapf BCD_milhares,w
    iorwf BCD_centenas,w
    movwf BCD_high ; retorna o resultado também em BCD_high

    swapf BCD_dezenas,w
    iorwf BCD_unidades,w
    movwf BCD_low ; retorna o resultado também em BCD_low

    return ; toBCD16
#endif
;} 

;*********************************************************


;*********************************************************
;<FUNÇÃO> 
; mostra1digito
;{
; Exibe um dígito <digito> no display de 7 segmentos de nº <mostra1_posicao_7seg>

;<HARDWARE> 
; 4 displays de sete segmentos multiplexados 
; através de 4 transistores e o dado codificado em BCD.
; Os 8 bits estarão conectados na porta PORT_DISPLAY_7SEGMENTOS

; <ARGUMENTOS>
; mostra1_digito_7seg (f) = um dígito (0 a 9) a ser exibido
; mostra1_posicao_7seg (f) = número (0 a 4) estabelece qual display 
; deve ser utilizado para exibir o dígito.
;*********************************************************

#ifdef DISPLAY_7SEGMENTOS

mostra1digito:
    banksel mostra1_posicao_7seg    
    movf mostra1_posicao_7seg, w
    andlw b'00000111' ; Posicação máxima = 4° display
    movwf mostra1_posicao_7seg

    sublw 4 ; Posicação máxima = 4° display
    btfss STATUS,C
        clrf mostra1_posicao_7seg ; posicao > 4 = nenhum display ativo

    movf mostra1_digito_7seg,w ; apenas o primeiro nibble é válido
    andlw b'00001111'
    movwf mostra1_digito_7seg

    movlw HIGH decodifica_7seg
    movwf PCLATH
    movf mostra1_posicao_7seg,w
    call decodifica_7seg ; 4 bits mais significativos
    iorwf mostra1_digito_7seg, w; 4 bits menos significativos
    movwf PORT_DISPLAY_7SEGMENTOS
    return ; mostra1digito

#endif
;*********************************************************

;*********************************************************
;<TABELA> 
; decodifica_7seg

; <ARGUMENTOS>
; w = posicao do display em decimal a ser decodificado
;*********************************************************

#ifdef DISPLAY_7SEGMENTOS
; primeiros 4 bits = transistores de multiplexação
decodifica_7seg:
    addwf PCL,f
    retlw b'00000000' ; nenhum display
    retlw b'00010000' ; 1° display
    retlw b'00100000' ; 2° display
    retlw b'01000000' ; 3° display
    retlw b'10000000' ; 4° display
    retlw b'00000000' ; apenas em caso de erro
    retlw b'00000000' ; apenas em caso de erro
    retlw b'00000000' ; apenas em caso de erro
    return ; apenas em caso de erro, tabela

#endif
;}
;*********************************************************

;*********************************************************
;<FUNÇÃO> 
; mostra4digitos
;{
; Exibe quatro dígitos <digito> nos 4 displays de 7 segmentos utilizando a função
; mostra1digito

;<HARDWARE> 
; 4 displays de sete segmentos multiplexados 
; através de 4 transistores e o dado codificado em BCD.

; <ARGUMENTOS>
; digitos_low (f) = dois dígitos BCD (0 a 9) menos significativos
; digitos_high (f) = dois dígitos BCD (0 a 9) mais significativos
;*********************************************************

#ifdef DISPLAY_7SEGMENTOS

banksel display_low

;1º digito - menos significativo:
digito_1:
    movf posicao,f
    btfss STATUS,Z
        goto digito_2

    movf display_low,w
    movwf mostra1_digito_7seg
    movlw 0x01
    movwf mostra1_posicao_7seg
    call mostra1digito
    goto digito_fim

;2º digito 
digito_2:
    movlw 0x01
    subwf posicao,w
    btfss STATUS,Z
        goto digito_3

    swapf display_low,w
    movwf mostra1_digito_7seg
    movlw 0x02
    movwf mostra1_posicao_7seg
    call mostra1digito
    goto digito_fim

;3º digito 
digito_3:
    movlw 0x02
    subwf posicao,w
    btfss STATUS,Z
        goto digito_4

    movf display_high,w
    movwf mostra1_digito_7seg
    movlw 0x03
    movwf mostra1_posicao_7seg
    call mostra1digito
    goto digito_fim

;4º digito - mais significativo:
digito_4:
    swapf display_high,w
    movwf mostra1_digito_7seg
    movlw 0x04
    movwf mostra1_posicao_7seg
    call mostra1digito

digito_fim:    
    incf posicao,f
    movlw 0x04
    subwf posicao,w
    btfsc STATUS,Z
        clrf posicao ; posicao = 0 até 3

#endif

;}
;*********************************************************    
end
Tagged sob
Itens relacionados (por tag)

Mais nesta categoria: « Microcontroladores PIC16: Instruções assembly para movimentação de dados Código assembly PIC16 para exibição de quatro dígitos em displays multiplexados »
PHPH.com.br

Código assembly PIC16: Relógio e contagem até 9999d

Itens relacionados (por tag)

Deixe um comentário

Nós fazemos

Instrumentação

Nossa política
