ASM51

Pessoal,,
Estou enfrentando um problema aqui em um circuito e não sei ao certo qual é o problema.
Analisando por baixo, eu cheguei a conclusão que eu tenho que tratar os possíveis handlers disponíveis.
Observando o código do .S, eu observei que ele faz o seguinte.

Aqui ele aloca os protótipos dos handler,

Código: Selecionar todos

__Vectors       DCD     __initial_sp              ; Top of Stack
                DCD     Reset_Handler             ; Reset Handler
                DCD     NMI_Handler               ; NMI Handler
                DCD     HardFault_Handler         ; Hard Fault Handler
                DCD     MemManage_Handler         ; MPU Fault Handler
                DCD     BusFault_Handler          ; Bus Fault Handler
                DCD     UsageFault_Handler        ; Usage Fault Handler
                DCD     0                         ; Reserved
                DCD     0                         ; Reserved
                DCD     0                         ; Reserved
                DCD     0                         ; Reserved
                DCD     SVC_Handler               ; SVCall Handler
                DCD     DebugMon_Handler          ; Debug Monitor Handler
                DCD     0                         ; Reserved
                DCD     PendSV_Handler            ; PendSV Handler
                DCD     SysTick_Handler           ; SysTick Handler

Aqui ele aloca uma chamada para o endereço de entrada do handler.

Código: Selecionar todos

  ; Reset Handler

Reset_Handler   PROC
                EXPORT  Reset_Handler             [WEAK]
                IMPORT  __main
                LDR     R0, =__main
                BX      R0
                ENDP


; Dummy Exception Handlers (infinite loops which can be modified)               

NMI_Handler     PROC
                EXPORT  NMI_Handler               [WEAK]
                B       .
                ENDP
HardFault_Handler\
                PROC
                EXPORT  HardFault_Handler         [WEAK]
                B       .
                ENDP
MemManage_Handler\
                PROC
                EXPORT  MemManage_Handler         [WEAK]
                B       .
                ENDP
BusFault_Handler\
                PROC
                EXPORT  BusFault_Handler          [WEAK]
                B       .
                ENDP
UsageFault_Handler\
                PROC
                EXPORT  UsageFault_Handler        [WEAK]
                B       .
                ENDP
SVC_Handler     PROC
                EXPORT  SVC_Handler               [WEAK]
                B       .
                ENDP
DebugMon_Handler\
                PROC
                EXPORT  DebugMon_Handler          [WEAK]
                B       .
                ENDP
PendSV_Handler  PROC
                EXPORT  PendSV_Handler            [WEAK]
                B       .
                ENDP
SysTick_Handler PROC
                EXPORT  SysTick_Handler           [WEAK]
                B       .
                ENDP

Observando então este pequeno script
; Reset Handler

Código: Selecionar todos

Reset_Handler   PROC
                EXPORT  Reset_Handler             [WEAK]
                IMPORT  __main
                LDR     R0, =__main
                BX      R0
                ENDP

Me leva a crer, que eu posso muito bem fazer o mesmo para que cada exceção chame uma rotina com nome pré definido, desta forma aqui ????

Código: Selecionar todos

 
HardFault_Handler  PROC
                EXPORT  HardFault_Handler         [WEAK]
                IMPORT  __qualquer_nome
                LDR     R0,=__qualquer_nome       
                BX       R0       
                ENDP

A duvida agora é, o registrador R0, pode ser usado para qualquer chamada ?
Se não, para que serve o R0, e qual endereço vou utilizar ?

Eu já procurei em vários lugares e não encontrei em lugar algum !!

Sim pode.
Recomendo que VC leia este livro:
http://www.asm51.eng.br/phpbb/blog.php?action=view&article_id=3



E leia estes artigos:


http://www.ethernut.de/en/documents/arm-exceptions.html

E tem mais informações no site da arm.

Se VC estiver usando o Keil, crie um breakpoint logo na chamada da exception e vá em callstack e veja qual endereço gerou ele. Analise o código e tente encontrar ponteiros maltratados, loopings com matrizes que estão contando além do tamanho da matriz, declaração de variável local maior que o tamanho da pilha etc...

Rodrigo, muito obrigado.
Vou ler os indicados e retorno depois com resultados !!

Fabim

nos 6 modos de interrupção podes usar sem medo R0 a R7.

Cara, nunca precisei me preocupar com baixo nível, e agora infelizmente precisei, pois é algo que preciso de margem de erro ZERO !

Estes registradores R0 a R15 sei que são para uso geral, e alguns são fixos para determinadas funções !
Agora Miguel como disse, R0 a R7...

O script:
Reset_Handler PROC
EXPORT Reset_Handler [WEAK]
IMPORT __main
LDR R0, =__main
BX R0
ENDP
Move endereço do Main para R0, pula para R0.

Eu estou bem confuso agora, acho que não peguei o isprito do negócio !!
Alguém pode dar uma canjinha ?

Reset_Handler PROC
EXPORT Reset_Handler [WEAK]
IMPORT __main
LDR R0, =__main
BX R0
ENDP

Fabim, caso na queiras perder R0, faz assim....tenta fazer...

Reset_Handler PROC
EXPORT Reset_Handler [WEAK]
IMPORT __main
LDR PC,[PC,#__main]
ENDP

Miguelito, muito obrigado, mais não me expressei bem !!!

Os R0 a R7, são utilizados para alocar endereços de execução ? é isto ?

Esta é minha duvida. !!!

Fabim

Baixei uma apostila assembly !!!
Já sei o que é rsrsrs

Brigado !!

Otimo!!!!!!!!!!!

http://www.inf.furb.br/~maw/arm/lpc-ARM-book_srn_p.pdf



Lembra muito a Arquitetura CRIS