Nos defines no começo do programa é possível alterar o modo dos toques: 1 toque para ligar e 2 para desligar ou o contrário ou seja 2 toque para ligar e 1 para desligar. Também pode ser escolhido toque rápido ou normal. Veja a porção de código abaixo>

//ESCOLHA A SINALIZAÇÃO DE ON/OFF NA SIRENE (TOQUES)

#DEFINE NORMAL // 1 TOQUE PARA LIGAR E 2 PARA DESLIGAR

//DESCOMENTE PARA 1 TOQUES PARA LIGAR E 2 PARA DESLIGAR
//COMENTE PARA 2 TOQUES PARA LIGAR E 1 PARA DESLIGAR

//==============================================================================
//ESCOLHA A SINALIZAÇÃO DE ON/OFF NA SIRENE (TOQUES)

#DEFINE TOQUE_RAPIDO // TOQUES RAPIDOS

//DESCOMENTE PARA TOQUES RÁPIDOS DE SINALIZAÇÃO ON/OFF
//COMENTE TOQUE NORMAIS DE SINALIZAÇÃO ON/OFF

Caso deseje outros valores de duração dos toques tenha em mente o seguinte: A alteração destes tempos não está de forma fácil, como em um define ou coisa similar. Mas o valor do tempo dos toques é gerado nesta porção de rotina abaixo. Ela utiliza os contadores ts1,ts2 e ts2 que são incrementado a cada interrupção do timer 0:

//=============================================================================
// GERA TOQUE NA SIRENE
//==============================================================================
if (flag_1toq){ // gera apenas um toque
sirene=1;//liga a sirene
#IFDEF TOQUE_RAPIDO

if(bit_test(ts2,3))  //   aqui testamos um bit para dar um toque  rápido ( se optar por outros bits de ts2 terá tempos diferentes)
#ELSE
if(bit_test(ts2,4))// aqui testamos um bit para dar um toque com o dobro do tempo do anterior (toque normal)
#ENDIF

{
sirene=0;//desliga a sirene
flag_1toq=0;//reseta flag de 1 toque
++tok;//incrementa contador de número de toques
}
}

-------------------------------------abaixo rotina para gerar 2 toques-----------------

if (flag_2toq){//gera 2 toques
if ((tok==0) || (tok==2)) { flag_1toq=1;}
if(tok==1){
#IFDEF TOQUE_RAPIDO
if (!bit_test(ts2,3))  // aqui testa um bit de ts2 para um toque rápido
#ELSE
if (!bit_test(ts2,4))// aqui testa um bit de ts2 para um toque normal
#ENDIF

{ ++tok;}
}
if(tok==4) {flag_2toq=0;}
}

Para gerar outras quantidades de toques  que não sejam 1 ou 2, terá que alterar a rotina acima para produzir isto. Tenha em mente que a rotina é feita de uma forma parecida com máquina de estado, em que cada interrupção  irá realizar alguma coisa, não sendo aceitável a colocação de delays  que travariam todo o programa.

Talvez possa criar uma nova rotina, parecida com o abaixo para 3 toques :

if (flag_3toq){//gera 3 toques
if ((tok==0) || (tok==2) || (tok==4)) { flag_1toq=1;}
if(tok==1){
#IFDEF TOQUE_RAPIDO
if (!bit_test(ts2,3))  // aqui testa um bit de ts2 para um toque rápido
#ELSE
if (!bit_test(ts2,4))// aqui testa um bit de ts2 para um toque normal
#ENDIF

{ ++tok;}
}
if(tok==6) {flag_3toq=0;}
}

(Nota: declare o flag_3toq na seção '//flags'  para poder ser aceito pelo compilador.)

Ou ainda para 4 toques:

Talvez possa ser parecida com o abaixo para 4 toques :

if (flag_4toq){//gera 4 toques
if ((tok==0) || (tok==2) || (tok==4) || (tok==6)) { flag_1toq=1;}
if(tok==1){
#IFDEF TOQUE_RAPIDO
if (!bit_test(ts2,3))  // aqui testa um bit de ts2 para um toque rápido
#ELSE
if (!bit_test(ts2,4))// aqui testa um bit de ts2 para um toque normal
#ENDIF

{ ++tok;}
}
if(tok==8) {flag_3toq=0;}
}

(Nota: declare o flag_4toq na seção '//flags'  para poder ser aceito pelo compilador.)

--------------------------------------------------------

//==============================================================================
// TEMPO PARA DESLIGAMENTO DA SIRENE
//==============================================================================

Os contadores ts1,ts2,ts3 estão em cascata e são incrementados a cada interrupção do timer 0. Estes geram o tempo total que a sirene fica ligada em um disparo e também o tempo dos 'tocs' momentâneos para indicar  que o alarme foi ligado ou desligados.

if(++ts1==0){ if(++ts2==0){
if(++ts3==TMAX_SIRENE){
#IFDEF DESLIGA_SIRENE_APOS_TEMPO
flag_disp=0; // desliga sirene
#ENDIF
ts3=0; ts2=0; ts1=0;
#ifdef UNICO_DISPARO
flag_unica=1;
#else
flag_unica=0;
#endif

}
}

Você pode alterar o tempo destes toques de duas formas ( que me veio a mente no momento):

1) Escolher um outro bit do contador ts2 para ser testado. Ex:

if(bit_test(ts2,3))  ou if(bit_test(ts2,3))   ou  if(bit_test(ts2,2))  ou if(bit_test(ts2,1)) 

2) Manter os valores originais e alterar apenas o tempo que a interrupção do timer 0 acontece. O valor atual é de 100 us. Poderá alterar  para mais ou menos, fazendo que altere o tempo que são incrementados os contadores ts1,ts2 e ts3 e portanto, o tempo de duração do toque. Note que o tempo máximo que a sirene ficará ligada será também proporcionalmente alterado. Neste caso, terá que alterar também o valor desta constante,  conforme a porção do código abaixo, situada no início do programa c:

byte const TMAX_SIRENE = 8*(5);//sirene ligada (tempo em min. entre parênteses).

Faça testes experimentalmente. Comece alterando o tempo dos toques que deseja,  por modificar a recarga do timer0. Esta parte do código fica na porção inicial da rotina de interrupção do timer 0 conforme mostra a porção abaixo:

//==============================================================================
////////////////////////////////////////////////////////////////////////////////
// ROTINA DE INTERRUPÇÃO DO TIMER 0
////////////////////////////////////////////////////////////////////////////////
//==============================================================================
#int_rtcc

VOID isr(){

timer0= 155; // recarga para nova interrupção com 100 useg (sendo 255 -155= 100)

Poderá alterar aos poucos e testar se está da forma desejada (ex. timer0=165 para 90 us = mais rápido o toque em 10% e  usando timer0=145 ->mais lento 10%

Não exagere para não dar problema na rotina de recepção.  Depois altere o valor da constante :

byte const TMAX_SIRENE = 8*(5);//sirene ligada (tempo em min. entre parênteses).

Altere o valor para produzir o tempo ligado que desejar. Note que ao alterar a rotina do timer 0 irá fazer o minuto durar menos ou mais do que a contagem '8' no  contador ts3.

Espero que possa ter entendido todo este processo.

ok   muito obrigado pela orientação.     

Claudio estou precisando mudar os pinos de entrada e saida para aproveitar uma placa aqui poderia me orientar como mudo os pinos.

ex uma tabela de bit   e outra de tris   correspondestes aos pinos .grato

Veja o datasheet para encontrar qual bit corresponde ao pino do pic.
O mesmo bit é o usado no tris.
Ex.
O pino 2 é o gp5 (0x5.5) tendo o bit de direção 'tris' de número 5 (0x85.5)
O pino 3 é o gp4 (0x5.4) tendo o bit de direção 'tris' de número 4 (0x85.4)
O pino 4 é o gp3 (0x5.3) tendo o bit de direção 'tris' de número 3 (0x85.3) sendo somente entrada.
O pino 5 é o gp2 (0x5.2) tendo o bit de direção 'tris' de número 2 (0x85.2)
O pino 6 é o gp1 (0x5.1) tendo o bit de direção 'tris' de número 1 (0x85.1)
O pino 7 é o gp0 (0x5.0) tendo o bit de direção 'tris' de número 0 (0x85.0)

Para alterar os pinos deverá alterar tanto no pino como na sua direção (gpio e tris).
Abaixo temos a porção de código do artigo ref154 (alarme):

#bit led_onoff = 0X05.1 // PINO 6
#bit sirene = 0X05.4 // PINO 3
//------------------------------------------------------------------------------
// TRIS-STATE GPIO          543210 (bits)
byte const TRIS_LED = 0b101100; //SENTIDO DAS PORTAS P/ ACENDER LED 'LEARN'
byte const TRIS_BOT = 0b101101; //SENTIDO DAS PORTAS P/ LER BOTÃO 'LEARN'
//==============================================================================
#define sensor PIN_A2 //pino 5
#define RFIN PIN_A5 // pino 2
#define BOT PIN_A0 // botão 'learn'
#define BOTS PIN_A3 // botão 'learn SENSOR WIRELESS' PINO 4
#define LED PIN_A0 // led 'learn'

Para trocar os pinos e facilitar a montagem em uma placa de circuito impressa
de outro artigo que seja parecido, altere o pino e tambem o valor da constante que
será carregada no registrador 'trisio'.
Veja abaixo um exemplo usando esta mesma porção de código (se encontra no começo
do programa C):

//usando acesso direto
#bit led_onoff = 0X05.1 // PINO 6 (mantido o mesmo pino)
#bit sirene = 0X05.2 // PINO 5 (antes era 0X05.4 // PINO 3)
//------------------------------------------------------------------------------
// TRIS-STATE GPIO 543210 //sendo '1' para entrada e '0' para saída
byte const TRIS_LED = 0b011001; //SENTIDO DAS PORTAS P/ ACENDER LED 'LEARN'
byte const TRIS_BOT = 0b111001; //SENTIDO DAS PORTAS P/ LER BOTÃO 'LEARN'

//Note que gp5 (pino 2) ora é saída para led ora é entrada para o botão de programação
// As constantes TRIS_LED e TRIS_BOT diferem apenas neste bit que corresponde ao pino 2 (gp5).
// Os outros pinos foram alterados conforme sua função quer seja de entrada (1) quer seja
// de saída (0), iguais em ambas constantes.
//==============================================================================
//usando acesso por função 'output_low/high(pin) ou input(pin)
#define sensor PIN_A4 // pino 3 (estava PIN_A2 //pino 5)
#define RFIN PIN_A0 //pino 7 (antes era PIN_A5 // pino 2)
#define BOT PIN_A5 //pino 2 (antes era PIN_A0 // botão 'learn')
#define BOTS PIN_A3 // botão 'learn SENSOR WIRELESS' PINO 4 (manteve mesmo pino)
#define LED PIN_A5 //pino 2 (antes era PIN_A0 // led 'learn')

Tente alterar conforme for melhor para seu projeto.

nossa mãe manja muito .obrigado Claudio

Olá Claudio. Tudo bem?

Gostaria na verdade de me referir ao projeto:

Alarme Residencial Temporizado com fio.

C/ PIC 12F675  - Ref.: 271. Gostei muito, pretendo aplicar na minha residência.

Seria possível incrementar: Se o alarme não for desligado,  a sirene dispara por exemplo, 15 min, fica desligada por 30 min e volta a disparar 15 min, por determinado número de vezes?