Tente algo assim:

/****************************************************************************

Sensor de Presença por Reflexão Infravermelho

c/ PIC 12F675

Autor: Cláudio Lários

Data: 24/10/2016

Aplicação: Detectar objetos que passam na frente do sensor usando luz
infravermelho.
Utiliza o método da reflexão.
O modo de operação pode ser escolhido entre 10 modos diferentes além
da saída em modo normal ou invertida.
Os tempos de operação podem também ser alterados pelo usuário neste
arquivo e depois recompilando para obter o novo arquivo .hex.
Usado compilador CCS C versão 3.200

Pinagem:
1= vcc
2= LED VERDE <-------------------acrescentado
3= LED VERMELHO <-------------------acrescentado
4= saída do receptor tsop1838
5- saída para acionamento do rele e eletroválvula de água
6- nc
7- saída para o led infravermelho
8- gnd

Uso didático

Este arquivo é parte integrante do blog Lários.Tecnologia.WS

************************************************************************/
#include <12F675.h>
#device adc=8
#use delay(clock=4000000)
#fuses NOWDT,INTRC_IO, NOCPD, NOPROTECT, NOMCLR, NOPUT, NOBROWNOUT//configuração

//bytes
#byte TMR0 = 0x01
#byte TRISIO = 0x85
#byte GPIO = 0x05
#byte OPTION_REG = 0x81
#byte ANSEL = 0x9f
#byte CMCON = 0x19
#byte ADCON = 0X1F
#byte ADRESH = 0X1E
#byte ADRESL = 0X9E

//bits
#bit IN = 0x5.3 //entrada do fotoreceptor - pino 4
#bit OUT = 0x5.2 //saída para controlar eletroválvula - pino 5
#bit LED = 0x5.1 //led indicador de programação
#bit LEDIR = 0x5.0 //led emissor de infrared
#bit LEDVM = 0X5.4 //led indicador de detenção vermelho ON pino 3 <--------------acrescentado
#bit LEDVD = 0X5.5 //led indicador de detenção verde OFF pino 2 <--------------acrescentado

#bit t0if = 0xb.2 //flag de over flow do timer0
#bit godone = 0x1f.1
#bit adfm = 0x1f.7
#bit adon = 0x1f.0
#bit vcfg = 0x1f.6
#bit f_int0 = 0xb.5

/*************************************************************************
OPÇÃO DO USUÁRIO
*************************************************************************/
//Escolha se a saída será invertida ou normal:

// #define SAIDA_INVERTIDA // pino 5 terá lógica invertida

//Obs. Para saída normal comente o acima (use na frente '//').

/*************************************************************************
ESCOLHA ABAIXO UMA DAS OPÇÕES POR DESCOMENTA-LA.
MANTENHA AS OUTRAS OPÇÕES COMENTADAS (COM "//" NA FRENTE)
*************************************************************************/

// #define MODO_1 //
// #define MODO_2
// #define MODO_3
// #define MODO_4
#define MODO_5
// #define MODO_6
// #define MODO_7
// #define MODO_8
// #define MODO_9
// #define MODO_10

//************************************************************************
// Explicação dos modos de operação:
/************************************************************************
Modo 1 - Ao detectar objeto aciona a saída por um tempo determinado e desliga
(pulso temporizado).Tem um tempo inicial mínimo de permanência do objeto
na frente do sensor para que aconteça a atuação (despreza movimentos
rápidos do objeto).
Após a temporização, enquanto objeto ficar na frente do sensor a saída
permanecerá desligada
Modo 2 - Ao detectar objeto aciona a saída por um tempo determinado e desliga
(pulso temporizado). Aciona com movimentos rápidos do objeto).
Após a temporização, enquanto objeto ficar na frente do sensor a saída
permanecerá desligada
Modo 3 - Inverte a saída a cada que um objeto passa pela frente dos sensores
(modo retenção). Aciona com a passagem rápida de obstáculos.
Enquanto objeto ficar acionando o sensor a saída permanecerá inalterada
Modo 4 - Inverte a saída cada vez que um objeto passa pela frente dos sensores
(modo retenção). Tem um tempo inicial mínimo de permanência do objeto
para que aconteça a mudança de estado da saída (despreza acionamentos
rápidos).
Enquanto objeto ficar na frente do sensor a saída permanecerá inalterada
Modo 5 - Ao detectar objeto aciona a saída enquanto objeto ficar na frente do
sensor a saída permanecerá ligada.
Aciona com a passagem rápida de obstáculos.
Modo 6 - Ao detectar objeto aciona a saída enquanto objeto ficar na frente do
sensor a saída permanecerá ligada. Tem um tempo inicial mínimo de
permanência do objeto na frente do sensor para que aconteça o
acionamento da saída (despreza acionamentos rápidos).
Modo 7 - Ao detectar objeto aciona a saída enquanto objeto ficar na frente do
sensor a saída permanecerá ligada. Após o objeto sair da frente do
sensor a saída continuará ligada por um tempo adicional programado
(pulso com pós temporização).
Aciona com a passagem rápida de obstáculos.
Modo 8 - Ao detectar objeto aciona a saída enquanto objeto ficar na frente do
sensor a saída permanecerá ligada. Tem um tempo inicial mínimo de
permanência do objeto na frente do sensor para que aconteça o
acionamento da saída (despreza acionamentos rápidos).
Após o objeto sair da frente do sensor a saída continuará ligada por
um tempo adicional programado (pulso com pós temporização).
Modo 9 - Inverte a saída a cada que um objeto passa pela frente dos sensores
(modo retenção). Aciona com a passagem rápida de obstáculos.
Enquanto objeto ficar acionando o sensor a saída permanecerá inalterada
Após objeto sair da frente do sensor ocorrerá um tempo morto onde o
sensor estará inoperante.
Modo 10 - Inverte a saída cada vez que um objeto passa pela frente dos sensores
(modo retenção). Tem um tempo inicial mínimo de permanência do objeto
para que aconteça a mudança de estado da saída (despreza acionamentos
rápidos).
Enquanto objeto ficar acionando o sensor a saída permanecerá inalterada
Após objeto sair da frente do sensor ocorrerá um tempo morto onde o
sensor estará inoperante.

/************************************************************************/

//Ajuste os valores para temporização desejadas para cada modo de operação:

#ifdef MODO_1
#define TEMPO_PRE_AC_M1 25 //# 0,25 segundos com objeto permanecendo na frente
//do sensor
#define TEMPO_SAIDA_LIG_M1 1500// 1,5 segundos
#endif

#ifdef MODO_2
#define TEMPO_LIGADO_M2 2000 //2 segundos ligado
#endif

#ifdef MODO_4
#define TEMPO_PRE_AC_M4 25 //# 0,25 segundos com objeto na frente do sensor
#endif

#ifdef MODO_6
#define TEMPO_PRE_AC_M6 25 //# 0,25 segundos com objeto na frente do sensor
#endif

#ifdef MODO_7
#define TEMPO_ADICIONAL_M7 2000 //2 segundos delay ligado após objeto sair da
#endif //frente do sensor

#ifdef MODO_8
#define TEMPO_ADICIONAL_M8 2000 //2 segundos delay ligado após objeto sair da
//frente do sensor
#define TEMPO_PRE_AC_M8 25 //# 0,25 segundos com objeto na frente do sensor
#endif

#ifdef MODO_9
#define TEMPO_MORTO_M9 2000 //2 segundos - sensor inoperante neste tempo
#endif

#ifdef MODO_10
#define TEMPO_MORTO_M10 3000 //3 segundos - sensor inoperante neste tempo
#define TEMPO_PRE_AC_M10 50 //# 0,50 segundos com objeto na frente do sensor
#endif

//# Nota: Os tempos de pré-acionamento tem proporções diferentes dos outros
// tempos gerados pela rotina 'delay_ms()'. Como são gerados no loop de
// repetição principal e as rotinas serão diferentes conforme a escolha do
// modo desejado, os tempos poderão não ser muito precisos.

//------------------FIM DOS AJUSTES DO USUÁRIO----------------------------------

#ifdef SAIDA_INVERTIDA
#define LIGA 0
#define DESLIGA 1
#else
#define LIGA 1
#define DESLIGA 0
#endif

#define FILTRO1 49

//variáveis globais
unsigned int16 cont1;
/*************************************************************************
Rotina do Sensor de Aproximação
*************************************************************************/

unsigned int1 sensor_ir(){
//Para TSOP1838 ou similar (KSM603LM,VS1838) de frequência = 38khz

unsigned int8 pulso,b;
pulso=0;

for(b=0;b<80;b++){ //gera 80 pulsos na frequência próxima de 38 khz
LEDIR=0;
delay_us(12);
LEDIR=1;
if(!IN)pulso++; else delay_cycles( 2 );//testa se pulso chegou no receptor
}
LEDIR=0;
delay_ms(15);
if(pulso > FILTRO1) return (1); else return (0);

}

/*************************************************************************
ROTINA MAIN
*************************************************************************/

void main() {

setup_adc_ports(NO_ANALOGS|VSS_VDD);//ports digitais
setup_adc(ADC_OFF);//desliga AD
setup_counters(RTCC_INTERNAL,RTCC_DIV_1);//n usado
setup_timer_1(T1_DISABLED);//n usado
setup_comparator(NC_NC_NC_NC);//desliga comparadores internos
setup_vref(FALSE);//desliga voltagem de referência
// TRISIO=0B111000;//ajusta saídas e entradas
TRISIO=0B001000;//ajusta saídas e entradas <--------------agora leds vm e vd
cont1=0;//zera contador
#ifdef SAIDA_INVERTIDA
GPIO= 0B0000100;
#else
GPIO=0;//desliga todas as saídas
#endif
/*************************************************************************
LAÇO PRINCIPAL DE REPETIÇÃO
*************************************************************************/

for(;;){
/************************************************************************
Modo 1 - Ao detectar objeto aciona a saída por um tempo determinado e desliga
(pulso temporizado).Tem um tempo inicial mínimo de permanência do objeto
na frente do sensor para que aconteça a atuação (despreza movimentos
rápidos do objeto).
Enquanto objeto ficar na frente do sensor a saída permanecerá desligada
************************************************************************/

#ifdef MODO_1

if(sensor_ir()){//se obstáculo está na frente do sensor então incrementa
cont1++;
}
else{
if(cont1<TEMPO_PRE_AC_M1)cont1=0;//zera se tirar obstáculo da frente do
//sensor enquanto o tempo for menor
}
if(cont1>=TEMPO_PRE_AC_M1){//se obstáculo ficar mais que tempo programado
//na frente do sensor
OUT=LIGA;
LEDVM=LIGA;//<----------------------------------
LEDVD=DESLIGA;//<--------------------------------
delay_ms(TEMPO_SAIDA_LIG_M1);//tempo mínimo que fica acionado a saída
OUT=DESLIGA;
while(sensor_ir())delay_ms(10);//enquanto objeto continuar na frente do
// sensor
cont1=0;//zera contador de tempo
}
OUT=DESLIGA;
LEDVD=LIGA;//<----------------------------------
LEDVM=DESLIGA;//<--------------------------------

#endif
/************************************************************************
Modo 2 - Ao detectar objeto aciona a saída por um tempo determinado e desliga
(pulso temporizado). Aciona com movimentos rápidos do objeto).
Enquanto objeto ficar na frente do sensor a saída permanecerá desligada
************************************************************************/

#ifdef MODO_2
if(sensor_ir()){
OUT=LIGA;
LEDVM=LIGA;//<----------------------------------
LEDVD=DESLIGA;//<--------------------------------
delay_ms(TEMPO_LIGADO_M2);//tempo mínimo que fica acionado a saída
OUT=DESLIGA;
while(sensor_ir())delay_ms(10);//enquanto objeto continuar na frente do
//sensor
}
OUT=DESLIGA;
LEDVD=LIGA;//<----------------------------------
LEDVM=DESLIGA;//<--------------------------------
#endif
/************************************************************************
Modo 3 - Inverte a saída a cada que um objeto passa pela frente dos sensores
(modo retenção). Aciona com a passagem rápida de obstáculos.
Enquanto objeto ficar acionando o sensor a saída permanecerá inalterada
************************************************************************/
#ifdef MODO_3
if(sensor_ir()){
OUT=!OUT;
LEDVM=OUT;//<----------------------------------
LEDVD=!OUT;//<--------------------------------
while(sensor_ir())delay_ms(10);//enquanto objeto continuar na frente do
//sensor
}
#endif
/************************************************************************
Modo 4 - Inverte a saída cada vez que um objeto passa pela frente dos sensores
(modo retenção). Tem um tempo inicial mínimo de permanência do objeto
para que aconteça a mudança de estado da saída (despreza acionamentos
rápidos).
Enquanto objeto ficar na frente do sensor a saída permanecerá inalterada
************************************************************************/
#ifdef MODO_4

if(sensor_ir()){//se obstáculo está na frente do sensor então incrementa
cont1++;
}
else{
if(cont1<TEMPO_PRE_AC_M4)cont1=0;//zera se tirar obstáculo da frente do
//sensor enquanto o tempo for menor que
// o programado
}
if(cont1>=TEMPO_PRE_AC_M4){//se obstáculo ficar mais que tempo programado
//na frente do sensor
OUT=!OUT;//inverte a saída (retenção)
LEDVM=OUT;//<----------------------------------
LEDVD=!OUT;//<--------------------------------
while(sensor_ir())delay_ms(10);//aguarda obstaculo sair da frente dos
//sensores
cont1=0;//zera contador de tempo
}//if(cont1>=TEMPO_NF)
#endif
/************************************************************************
Modo 5 - Ao detectar objeto aciona a saída enquanto objeto ficar na frente do
sensor a saída permanecerá ligada.
Aciona com a passagem rápida de obstáculos.
************************************************************************/
#ifdef MODO_5
if(sensor_ir()){
while(sensor_ir()){
OUT=LIGA;
LEDVM=LIGA;//<----------------------------------
LEDVD=DESLIGA;//<--------------------------------
delay_ms(10);}//enquanto objeto continuar na
//frente do sensor
}
OUT=DESLIGA;
LEDVD=LIGA;//<----------------------------------
LEDVM=DESLIGA;//<--------------------------------
#endif
/************************************************************************
Modo 6 - Ao detectar objeto aciona a saída enquanto objeto ficar na frente do
sensor a saída permanecerá ligada. Tem um tempo inicial mínimo de
permanência do objeto na frente do sensor para que aconteça o
acionamento da saída (despreza acionamentos rápidos).
************************************************************************/
#ifdef MODO_6

if(sensor_ir()){//se obstáculo está na frente do sensor então incrementa
cont1++;
}
else{
if(cont1<TEMPO_PRE_AC_M6)cont1=0;//zera se tirar obstáculo da frente do
//sensor enquanto o tempo for menor que
// o programado
}
if(cont1>=TEMPO_PRE_AC_M6){//se obstáculo ficar mais que o periodo
//programado na frente do sensor
while(sensor_ir()){OUT=LIGA;
LEDVM=LIGA;//<----------------------------------
LEDVD=DESLIGA;//<--------------------------------
delay_ms(10);}//aciona enquanto objeto estiver
// na frente dos sensores
cont1=0;//zera contador de tempo
}//if(cont1>=TEMPO_NF)
OUT=DESLIGA;//desliga saída
LEDVD=LIGA;//<----------------------------------
LEDVM=DESLIGA;//<--------------------------------
#endif

/************************************************************************
Modo 7 - Ao detectar objeto aciona a saída enquanto objeto ficar na frente do
sensor a saída permanecerá ligada. Após o objeto sair da frente do
sensor a saída continuará ligada por um tempo adicional programado
(pulso com pós temporização).
Aciona com a passagem rápida de obstáculos.
************************************************************************/
#ifdef MODO_7
if(sensor_ir()){
while(sensor_ir()){
OUT=LIGA;
LEDVM=LIGA;//<----------------------------------
LEDVD=DESLIGA;//<--------------------------------
delay_ms(10);}//enquanto objeto continuar na
//frente do sensor
delay_ms(TEMPO_ADICIONAL_M7);//mantém ligado a saída por tempo adicional
// após objeto sair da frente do sensor
}
OUT=DESLIGA;
LEDVD=LIGA;//<----------------------------------
LEDVM=DESLIGA;//<--------------------------------
#endif
/************************************************************************
Modo 8 - Ao detectar objeto aciona a saída enquanto objeto ficar na frente do
sensor a saída permanecerá ligada. Tem um tempo inicial mínimo de
permanência do objeto na frente do sensor para que aconteça o
acionamento da saída (despreza acionamentos rápidos).
Após o objeto sair da frente do sensor a saída continuará ligada por
um tempo adicional programado (pulso com pós temporização).
************************************************************************/
#ifdef MODO_8

if(sensor_ir()){//se obstáculo está na frente do sensor então incrementa
cont1++;
}
else{
if(cont1<TEMPO_PRE_AC_M8)cont1=0;//zera se tirar obstáculo da frente do
//sensor enquanto o tempo for menor que
// o programado
}
if(cont1>=TEMPO_PRE_AC_M8){//se obstáculo ficar mais que o periodo
//programado na frente do sensor
while(sensor_ir()){
OUT=LIGA;
LEDVM=LIGA;//<----------------------------------
LEDVD=DESLIGA;//<--------------------------------
delay_ms(10);
}//aciona enquanto objeto estiver
// na frente dos sensores
delay_ms(TEMPO_ADICIONAL_M8);//mantém ligado a saída por tempo adicional
// após objeto sair da frente do sensor
cont1=0;//zera contador de tempo
}//if(cont1>=TEMPO_NF)
OUT=DESLIGA;//desliga saída
LEDVD=LIGA;//<----------------------------------
LEDVM=DESLIGA;//<--------------------------------
#endif

/************************************************************************
Modo 9 - Inverte a saída a cada que um objeto passa pela frente dos sensores
(modo retenção). Aciona com a passagem rápida de obstáculos.
Enquanto objeto ficar acionando o sensor a saída permanecerá inalterada
Após objeto sair da frente do sensor ocorrerá um tempo morto onde o
sensor estará inoperante.
************************************************************************/
#ifdef MODO_9
if(sensor_ir()){
OUT=!OUT;
LEDVM=OUT;//<----------------------------------
LEDVD=!OUT;//<--------------------------------
while(sensor_ir())delay_ms(10);//enquanto objeto continuar na frente do
//sensor
delay_ms(TEMPO_MORTO_M9); //sensor inoperante neste tempo
}
#endif
/************************************************************************
Modo 10 - Inverte a saída cada vez que um objeto passa pela frente dos sensores
(modo retenção). Tem um tempo inicial mínimo de permanência do objeto
para que aconteça a mudança de estado da saída (despreza acionamentos
rápidos).
Enquanto objeto ficar acionando o sensor a saída permanecerá inalterada
Após objeto sair da frente do sensor ocorrerá um tempo morto onde o
sensor estará inoperante.
***************************************************************************/
#ifdef MODO_10

if(sensor_ir()){//se obstáculo está na frente do sensor então incrementa
cont1++;
}
else{
if(cont1<TEMPO_PRE_AC_M10)cont1=0;//zera se tirar obstáculo da frente do
//sensor enquanto o tempo for menor que
// o programado
}
if(cont1>=TEMPO_PRE_AC_M10){//se obstáculo ficar mais que tempo programado
//na frente do sensor
OUT=!OUT;//inverte a saída (retenção)
LEDVM=OUT;//<----------------------------------
LEDVD=!OUT;//<--------------------------------
while(sensor_ir())delay_ms(10);//aguarda obstaculo sair da frente dos
//sensores
cont1=0;//zera contador de tempo
delay_ms(TEMPO_MORTO_M10); //sensor inoperante neste tempo
}//if(cont1>=TEMPO_NF)
#endif

}//for()
}//main

Olá Claudio! Deu certo os leds! mas consegui usar somente no modo 7 o que queria! percebi usando a câmera do celular que quando ele conta o tempo o led ir para de emitir e só volta a emitir quando o temporizador termina! usando o modo 8 o a saída  pisca por causa do tempo mínimo de permanência do objeto,  mas no modo 7 acho que é muito rápido e não da tempo de desligar a saída. Seria isso? Muito obrigado!

Já ia me esquecendo, como a detecção é de pequena distância no lugar do tsop usei um foto-transistor til78  e coloquei um  transistor bc 337 para excitar o led infra e funcionou bem!

Boa tarde Claudio, alegria de pobre dura pouco rsrs, quando deixo o objeto na frete da primeira vez funciona da maneira que preciso ele não pisca quando chega no tempo que eu programei que é 1 minuto, mas se por exemplo tiro o objeto por alguns segundos e volto a colocar na frente ele continua contando o tempo e quando chega no tempo programado desliga e liga novamente, o que precisaria era que quando o objeto ficasse na frente do sensor ele reiniciasse o temporizar e só começasse a contar se o objeto não estivesse na frente dele e se fosse colocado novamente reiniciaria o temporizador! Não sei se me fiz entender, mas pelo que percebi o programa fica preso na rotina de delay. Obrigado!

O programa foi feito de uma forma 'genérica'. Não dá para prever todas as possibilidades de uso. Você terá que adaptar o código as suas necessidades. Em qual dos modos está usando? Se  um dos modos se aproxima do que necessita então tente altera-lo para fazer o que deseja.

Olá Claudio, vou seguir sua orientação! obrigado!! se precisar de ajuda já sabe né? rsrs vou incomodar vc um pouquinho!! Abraço!

Olá Claudio! tudo bem?: espero que sim! fiz uma alteração que acho que da certo para o que quero testei e até agora tudo certo! Veja a alteração que fiz no código! não sei se é correto mas deu certo pra mim! 

#ifdef MODO_7
inicio:
if(sensor_ir()){
while(sensor_ir()){
OUT=LIGA;
LEDVM=LIGA;//<----------------------------------
LEDVD=DESLIGA;//<--------------------------------
delay_ms(10);}//enquanto objeto continuar na
//frente do sensor
delay_ms(TEMPO_ADICIONAL_M7);//mantém ligado a saída por tempo adicional
// após objeto sair da frente do sensor
}
while(sensor_ir()){
goto inicio;
}

criei um rótulo com nome início e assim que o temporizador termina ele testa de novo se o objeto está na frente e vai para o início.

Abraço!

Se o código está funcionando, então está correto. O uso da instrução 'goto' em 'C', na maioria dos casos é desnecessária. Mas não existe proibição do seu uso.

Creio que o resultado pode ser o mesmo da seguinte forma:

#ifdef MODO_7

while(sensor_ir()){
OUT=LIGA;
LEDVM=LIGA;
LEDVD=DESLIGA;
delay_ms(10);//enquanto objeto continuar na
                         //frente do sensor
delay_ms(TEMPO_ADICIONAL_M7);//mantém ligado a saída por tempo adicional
// após objeto sair da frente do sensor
}
Mas não testei, e se da sua forma está funcionando porque não usar?

Bom dia Claudio, vou testar a sua solução tbm!! obrigado por responder!! forte abraço!

Bom dia Claudio, vou testar a sua solução tbm!! obrigado por responder!! forte abraço!

Bom dia Claudio, eu enchendo de novo nesse mesmo projeto! então minha alteração que tinha falado não deu certo e a sua que postou por último testei e deu no mesmo.. eu preciso que quando o objeto fique na frente do sensor, a contagem pare e fique com as saída e os led correspondentes ligados. O problema que acontece é que o contador continua mesmo com o objeto na frente do sensor e da uma piscada e reinicia tudo. veja a porção do código que estou usando 

#ifdef MODO_7

if(sensor_ir()){
while(sensor_ir()){
OUT=LIGA;
LEDVM=LIGA;//<----------------------------------
LEDVD=DESLIGA;//<--------------------------------
LED=DESLIGA;
delay_ms(10);}//enquanto objeto continuar na
//frente do sensor
delay_ms(TEMPO_ADICIONAL_M7);//mantém ligado a saída por tempo adicional
// após objeto sair da frente do sensor
}

OUT=DESLIGA;
LEDVM=DESLIGA;//<--------------------------------
LEDVD=LIGA;//<----------------------------------
LED=LIGA;
#endif

teria como colocar alguma instrução para parar a contagem e manter as saidas ligadas?

Não sei se me fiz entender.

Att; Sérgio

Nesta última porção de código qual é o contador que não para de incrementar? Está em outra parte do seu programa?

Olá Cláudio, seguinte, o que preciso é quando o objeto estivesse na frente do sensor ele não contasse o tempo, pelo que percebi com o objeto na frente o tempo é contado mesmo que o objeto esteja na frente, pois quando passa o tempo programado ele da uma piscada e volta ligar!

Eu preciso que enquanto o objeto estiver na frente e quando fosse tirado e colocado na frente ele reiniciasse o tempo e só contasse quando o objeto não estivesse na frente! do que jeito que está ele com o objeto na frente ele pisca e volta ligar sucessivamente, e se aumentar o tempo por exemplo 15 segundos, se vc tirar e e voltar o objeto e voltar a colocar ele não reinicia a o temporizador.

O programa completo está logo acima quando pedi para colocar mais leds para monitorar!

Att; Sérgio

Att; Sérgio

É como se o sensor entendesse que não tem nada na frente por um instante bem rápido. Tente reduzir o valor da constante FILTRO1 de 49 para digamos, 30 ou menos.  Atente que um sinal de interferência na entrada do fio ligado ao tsop poderia gerar esta situação. Talvez testar com cabo blindado. Verifique também fontes de luz infrared na proximidade como emitidas por lâmpadas fluorescentes e outras. Talvez colocar um osciloscópio neste ponto e ver a forma de onda com objeto na frente e sem objeto poderia esclarecer algo sobre o funcionamento do sensor.