ASM51

Bom pessoal, este problema eu consigo resolver no C18 mas preciso resolvê-lo no CCS:

Estou tratando interrupções que são críticas quanto ao tempo de tratamento (são 5 no total, sendo que duas são prioritárias)
Eu estou fazendo o tratamento manual, no C18 eu uso o #pragma code int_global = 0x0008 e dentro desta rotina coloco em assembly um goto me mandando para a posição de memória 0x7000 (por exemplo), daí no código coloco uma outra função #pragma code int_rot2=0x7000 e coloco minhas interrupções de alta para serem tratadas (identificar qual foi e direcionar para o correto tratamento), finalizando com o RETFIE 1 em assembly para restaurar o contexto com os registradores shadow...
Para completar as interrupções de baixa prioridade eu faria assim: #pragma code int_rot1=0x0018 e o código para salvar contexto na mão, identificar qual interrupão ocorreu e tratá-la, restituir o contexto e sair com um RETFIE 0...
Agora no CCS a história muda... Uso a diretiva #int_global (equivale a começar na posição 0x0008h na memória vetor de interrupção de alta) e abaixo dela coloco o código que me manda para outra posição de memória onde "estaria" a função que vai tratar a interrupção (como citado no exemplo acima em C18), mas como faço isso no CCS?
Da mesma forma, quando ocorrer uma interrupção de baixa prioridade, como vou escrever minha função de tratamento na posição 0x0018 para trata-la?
Eu não consegui achar exemplos assim, para quem lida com o CCS deve ser tranquilo, alguem pode me ajudar???

Oi fábio,

Pode ser assim:

//### Interrupções
#byte RCON = 0xFD0
#byte INTCON = 0xFF2
#byte INTCON2 = 0xFF1
#byte INTCON3 = 0xFF0
#byte PIE1 = 0xF9D
#byte PIE2 = 0xFA0
#byte PIR1 = 0xF9E
#byte PIR2 = 0xFA1
#byte IPR1 = 0xF9F
#byte IPR2 = 0xFA2

//##############################################
//### Interrupção Timer2
#INT_TIMER2
void trata_timer2()
{....
}

//##############################################
//### Interrupção CCP1 - a cada evento do CCP Capture 1
#INT_CCP2
void trata_CCP2()
{...
}

//#######################################
//### Interrupção EXT0 - a cada evento do EXT0
#INT_EXT
void trata_EXT()
{...
}

Daí para colocar a interrupção do CCP2 como prioritaria, no CCS ao invés utilizar as funções pré-definidas do compilador, tipo
/*
enable_interrupts (global); //Habilita interrupções
enable_interrupts (int_timer2); // Habilita interrupção Timer2
enable_interrupts (int_ccp2); // Habilita interrupção CCP2
enable_interrupts (INT_EXT); // Habilita interrupção ext
*/

tente setar os bits dos registradores de interrupção na mão mesmo, tipo:

IPR1 = 0b00000000;
IPR2 = 0b00000001;

PIR1 = 0b00000000;
PIR2 = 0b00000000;

PIE1 = 0b00000010;
PIE2 = 0b00000001;

INTCON3 = 0b00000000;
INTCON2 = 0b10000000;
INTCON = 0b11010000;

RCON = 0b10001100;

daí, garanto que vai funcionar muito bem!!!

Boa sorte!

Agradeço a resposta amigo!!!
Mas acabei resolvendo da seguinte forma:

#org 0x7000,0x712B
//ALTA PRIORIDADE
void trata_int_high()
{
//testa em C qual interrupção de alta aconteceu e trata

#asm
retfie 1
#endasm
}

#org 0x0018,0x0FFF
//BAIXA PRIORIDADE
void trata_int_low()
{
#asm
movwf w_temp
movff status,status_temp
movff bsr,bsr_temp
#endasm

//testa em C qual interrupção de baixa ocorreu e trata

#asm
movff bsr_temp,bsr
movf w_temp,w
movff status_temp,status
retfie 0
#endasm
}