Usando o Hex fornecido funciona?

Se não, então tente ver se não perdeu o byte de calibração do oscilador interno. Este byte deve ser encontrado nas 2 últimas posições da memória flash, começando com 0x34 mais um byte.  Se você ler o pic com o programador  e encontrar tudo 0xff nas 2 últimas posições, então seu pic perdeu este byte de calibração. A falta dele faz com que o programa entre em um loop e não funciona de jeito nenhum (quando usando oscilador interno). Você poderá editar um valor com 0x34c0 na tela do programador  para estas  2 últimas posições e novamente regravar todo o programa no pic. Veja também o artigo "COMO CALIBRAR A FREQUÊNCIA DO OSCILADOR INTERNO DO PIC 12F675/629 (DIDÁTICO)"

ou digite :     http://blog.larios.tecnologia.ws/iBlog/archives/2881

Obrigado por ter respondido Cláudio,

O Hex original do arquivo zipado funciona perfeitamente, mas, se eu compilar no meu CCS deixa de funcionar.

Todos os testes estão sendo feitos apenas no Proteus que é um ambiente confiável para testes. Já testei por exemplo com dois PICs 16F628A comunicando um com o outro via serial. Claro que usei um componente RF TX e RX 433 para isso. 

Já uso esse método de teste há bastante tempo inclusive com outros modelos de PICs como por exemplo o PIC 12F1822 que tem USART.

E tanto é que com o arquivo HEX original roda normalmente na simulação com o Proteus.

Mas compila normalmente sem dar mensagem de erro? Se dá alguma mensagem, talvez se possa saber através dela o que está acontecendo. Se não tem mensagem de erro e compila normalmente, pode ter várias causas. Talvez a reinstalação do CCS possa resolver. Se não, tente buscar ajuda no forum do CCS C compiler sobre o que possa ter mudado nesta versão.

Não dá nenhum erro quando compila.

E o CCS está funcionando normalmente porque consigo compilar outros códigos

Como tem 2 softwares, o do TX e o outro, o RX precisamos saber em qual está o problema.

Tem varias maneiras de fazer isto:

Carregue o programa original no RX e o que compilou no TX.

No pino 7 do TX, quando você aperta um botão qualquer gera sinal? Use um disco piezo eletrico ligado nele e ao gnd. Ao apertar escutará um som característico se estiver funcionando. Deverá operar o  RX. Com isto feito e comprovado o funcionamento do TX  há que verificar o RX.

Agora carregue o programa original no TX e  o que você compilou no RX. Se o teste anterior funcionou, e este não, então tem algo acontecendo no programa RX.

Talvez uma alteração feita por " Control_V e Control_C" ( ou seja, algum caracter adicionado, perdido ou alterado). Confira o programa a procura de algum erro comparando com o do site. Certifique de não ter alterado nada no programa.

Resumo: Tente identificar qual dos programas não está funcionando.

Basta apenas compilar um dos arquivos tx ou rx, que deixa de funcionar. Muito estranho.

Complicou!!!

Tente ver o Forum da CCS para ver quais as modificações desta versão em relação as anteriores. Pode ser que tenha alguma exigência a mais no código para funcionar. Será que não precisa colocar quais ports serão a saída padrão da serial? Mesmo que não use serial, alguns compiladores exigem isto. Também, quando você compila um arquivo C no CCS C, em geral  vai ser criada uma pasta junto com o arquivo hex com terminação .list.  Ela tem o código gerado em assembly e você pode analisar este código para ver se está fazendo o que deseja.  Através desta análise minuciosa talvez se possa identificar algum erro de funcionalidade no código gerado  decorrente de alguma exigência. Identificado a porção de código basta trabalha nesta área especifica na busca da solução.

Obrigado Cláudio pela resposta,

Eu fiz o que vc sugeriu definindo os pinos TX/RX com o comando #use rs232(baud=???, parity=N,xmit=PIN_A0, rcv=PIN_A3, bits=8)

Eu preciso informar o baud também? Se sim qual é o baud desse projeto?

Tente algo como 9600 bauds. Depois que compilar e testar, se não funcionar, peço a gentileza de postar no comentário mesmo (control_c/control_v) o arquivo .list.

CCS PCM C Compiler, Version 5.015, 5967 10-nov-19 21:06

Filename: C:\Users\Pictures\TX RX 12F675\cr_5c_675_v2_\cr_5c_675_v2_\tx\tx_5c_on_off_675.lst

ROM used: 193 words (19%)
Largest free fragment is 831
RAM used: 9 (14%) at main() level
13 (20%) worst case
Stack used: 2 locations
Stack size: 8

*
0000: MOVLW 00
0001: MOVWF 0A
0002: GOTO 004
0003: NOP
0004: CALL 3FF
0005: BSF 03.5
0006: MOVWF 10
0007: MOVLW 00
0008: MOVWF 0A
0009: GOTO 073
.................... //***************************************************************************
.................... //
.................... // Transmissor de 5 canais on/off com pic 12f675
.................... //
.................... //
.................... // Autor: Cláudio Lários Data:10/07/2014
.................... //
.................... //
.................... //
.................... //
.................... // Uso didático apenas.
.................... // Use apenas em conjunto com o rx de 5 canais on/off (ref156)
.................... // Obs. Sujeito a bugs ainda não observados.
.................... //***************************************************************************
....................
....................
.................... #include <12F675.h>
.................... //////////// Standard Header file for the PIC12F675 device ////////////////
.................... ///////////////////////////////////////////////////////////////////////////
.................... //// (C) Copyright 1996, 2013 Custom Computer Services ////
.................... //// This source code may only be used by licensed users of the CCS C ////
.................... //// compiler. This source code may only be distributed to other ////
.................... //// licensed users of the CCS C compiler. No other use, reproduction ////
.................... //// or distribution is permitted without written permission. ////
.................... //// Derivative programs created using this software in object code ////
.................... //// form are not restricted in any way. ////
.................... ///////////////////////////////////////////////////////////////////////////
.................... #device PIC12F675
....................
.................... #list
....................
.................... #device adc=8
.................... #use delay(clock=4000000)
000A: MOVLW 2C
000B: MOVWF 04
000C: MOVF 00,W
000D: BTFSC 03.2
000E: GOTO 01D
000F: MOVLW 01
0010: MOVWF 21
0011: CLRF 20
0012: DECFSZ 20,F
0013: GOTO 012
0014: DECFSZ 21,F
0015: GOTO 011
0016: MOVLW 4A
0017: MOVWF 20
0018: DECFSZ 20,F
0019: GOTO 018
001A: GOTO 01B
001B: DECFSZ 00,F
001C: GOTO 00F
001D: RETURN
*
0026: MOVLW 12
0027: SUBWF 2A,F
0028: BTFSS 03.0
0029: GOTO 038
002A: MOVLW 2A
002B: MOVWF 04
002C: MOVLW FC
002D: ANDWF 00,F
002E: BCF 03.0
002F: RRF 00,F
0030: RRF 00,F
0031: MOVF 00,W
0032: BTFSC 03.2
0033: GOTO 038
0034: GOTO 036
0035: NOP
0036: DECFSZ 00,F
0037: GOTO 035
.................... #fuses NOWDT,INTRC_IO, NOCPD, NOPROTECT, NOMCLR, NOPUT, BROWNOUT
.................... #use rs232(baud=9600,parity=N,xmit=PIN_A0,rcv=PIN_A3, bits=8)
....................
.................... CONST INT16 serial_number = 0x89ab;
....................
....................
....................
.................... const int16 te = 500; //valor de TE
....................
.................... #byte gpio= 0x05
.................... #byte tris= 0x85
.................... #bit saida= 0x05.0 //pino 7
....................
.................... int8 data [4];
....................
....................
.................... //==============================================================================
.................... // rotina geradora de tempo piloto de 23 TE sem transmissão
.................... //==============================================================================
.................... void pilot_period(){
.................... saida=0;
*
001E: BCF 05.0
.................... delay_us(23*te);
001F: MOVLW 0B
0020: MOVWF 2C
0021: CALL 00A
0022: MOVLW 02
0023: MOVWF 29
0024: MOVLW F7
0025: MOVWF 2A
*
0038: DECFSZ 29,F
0039: GOTO 024
.................... }
.................... //==============================================================================
.................... // rotina geradora do start bit
.................... //==============================================================================
.................... void start_bit(){
.................... saida=1;
003A: BSF 05.0
.................... delay_us(te);
003B: MOVLW A6
003C: MOVWF 20
003D: DECFSZ 20,F
003E: GOTO 03D
003F: NOP
.................... saida=0;
0040: BCF 05.0
.................... //==============================================================================
.................... // rotina geradora de bit '1'
.................... //==============================================================================
.................... }
.................... void bit1(){
.................... saida=0; //'1'
*
0055: BCF 05.0
.................... delay_us(2*te);
0056: MOVLW 01
0057: MOVWF 2C
0058: CALL 00A
.................... saida=1;
0059: BSF 05.0
.................... delay_us(te);
005A: MOVLW A6
005B: MOVWF 20
005C: DECFSZ 20,F
005D: GOTO 05C
005E: NOP
.................... saida=0;
005F: BCF 05.0
.................... //==============================================================================
.................... // rotina geradora de bit '0'
.................... //==============================================================================
.................... }
.................... void bit0(){
.................... saida=0; //'0'
*
0061: BCF 05.0
.................... delay_us(te);
0062: MOVLW A6
0063: MOVWF 20
0064: DECFSZ 20,F
0065: GOTO 064
0066: NOP
.................... saida=1;
0067: BSF 05.0
.................... delay_us(2*te);
0068: MOVLW 01
0069: MOVWF 2C
006A: CALL 00A
.................... saida=0;
006B: BCF 05.0
.................... }
.................... //==============================================================================
.................... // rotina de envio para saída rf de um byte
.................... //==============================================================================
....................
.................... void envia(int valor){
.................... int b;
.................... for(b=0;b<8;b++){
*
004E: CLRF 2B
004F: MOVF 2B,W
0050: SUBLW 07
0051: BTFSS 03.0
0052: GOTO 070
....................
.................... if(valor&1){
0053: BTFSS 2A.0
0054: GOTO 061
.................... bit1();
.................... }
*
0060: GOTO 06C
.................... else{
.................... bit0();
.................... }
.................... valor>>=1;
*
006C: BCF 03.0
006D: RRF 2A,F
006E: INCF 2B,F
006F: GOTO 04F
.................... }
.................... }
.................... //==============================================================================
.................... // rotina de envio para saída rf de 4 bytes
.................... //==============================================================================
....................
....................
.................... void transmite(){
.................... int8 a;
.................... pilot_period();// 23 TE desligado
.................... start_bit();//bit de inicio
....................
.................... for(a=4;a>0;a--){ //envia os 4 bytes
*
0041: MOVLW 04
0042: MOVWF 28
0043: MOVF 28,F
0044: BTFSC 03.2
0045: GOTO 072
.................... envia(data[a-1]);
0046: MOVLW 01
0047: SUBWF 28,W
0048: ADDLW 24
0049: MOVWF 04
004A: MOVF 00,W
004B: MOVWF 29
004C: MOVF 29,W
004D: MOVWF 2A
*
0070: DECF 28,F
0071: GOTO 043
.................... }
0072: GOTO 0BF (RETURN)
.................... }
....................
....................
.................... //==============================================================================
.................... // rotina de principal
.................... //==============================================================================
....................
....................
....................
....................
.................... void main() {
0073: MOVF 03,W
0074: ANDLW 1F
0075: MOVWF 03
0076: BSF 03.5
0077: BCF 05.0
0078: BCF 03.5
0079: BSF 05.0
007A: BCF 1F.6
007B: BSF 03.5
007C: BCF 1F.0
007D: BCF 1F.1
007E: BCF 1F.2
007F: BCF 1F.3
0080: MOVLW 07
0081: BCF 03.5
0082: MOVWF 19
....................
.................... setup_adc_ports(NO_ANALOGS|VSS_VDD);
0083: BCF 1F.6
0084: BSF 03.5
0085: BCF 1F.0
0086: BCF 1F.1
0087: BCF 1F.2
0088: BCF 1F.3
.................... setup_adc(ADC_OFF);
0089: BCF 03.5
008A: BCF 1F.0
.................... setup_counters(RTCC_INTERNAL,RTCC_DIV_1);
008B: MOVLW 08
008C: MOVWF 20
008D: CLRF 01
008E: MOVLW 81
008F: MOVWF 04
0090: MOVF 00,W
0091: ANDLW C0
0092: IORLW 07
0093: MOVWF 00
0094: CLRWDT
0095: MOVF 00,W
0096: ANDLW C7
0097: BTFSC 20.3
0098: ANDLW C0
0099: IORWF 20,W
009A: MOVWF 00
.................... setup_timer_1(T1_DISABLED);
009B: CLRF 10
.................... setup_comparator(NC_NC_NC_NC);
009C: MOVLW 07
009D: MOVWF 19
009E: BSF 03.5
009F: MOVF 05,W
00A0: MOVWF 05
00A1: MOVLW 02
00A2: BCF 03.5
00A3: MOVWF 20
00A4: DECFSZ 20,F
00A5: GOTO 0A4
00A6: GOTO 0A7
00A7: NOP
00A8: MOVF 19,W
00A9: BCF 0C.3
.................... setup_vref(FALSE);
00AA: BSF 03.5
00AB: CLRF 19
.................... tris=0b111110;
00AC: MOVLW 3E
00AD: MOVWF 05
....................
....................
.................... while(true){
....................
.................... if((gpio&0x3e)!=0x3e){ //se algum botão estiver apertado
00AE: BCF 03.5
00AF: MOVF 05,W
00B0: ANDLW 3E
00B1: SUBLW 3E
00B2: BTFSC 03.2
00B3: GOTO 0BF
....................
.................... data[0]=make8(serial_number,1);
00B4: MOVLW 89
00B5: MOVWF 24
.................... data[1]=make8(serial_number,0);
00B6: MOVLW AB
00B7: MOVWF 25
.................... data[2]=gpio;
00B8: MOVF 05,W
00B9: MOVWF 26
.................... data[3]=data[0]+data[1]+data[2];
00BA: MOVF 25,W
00BB: ADDWF 24,W
00BC: ADDWF 26,W
00BD: MOVWF 27
....................
.................... transmite();
00BE: GOTO 01E
.................... }
00BF: GOTO 0AF
....................
....................
.................... }
.................... }
00C0: SLEEP

Configuration Fuses:
Word 1: 3FD4 INTRC_IO NOWDT NOPUT NOMCLR BROWNOUT NOPROTECT NOCPD

CCS PCM C Compiler, Version 5.015, 5967 10-nov-19 21:11

Filename: C:\Users\Pictures\TX RX 12F675\cr_5c_675_v2_\cr_5c_675_v2_\rx\rx_5c_675_v2.lst

ROM used: 241 words (24%)
Largest free fragment is 783
RAM used: 20 (31%) at main() level
24 (38%) worst case
Stack used: 2 locations
Stack size: 8

*
0000: MOVLW 00
0001: MOVWF 0A
0002: GOTO 004
0003: NOP
0004: CALL 3FF
0005: BSF 03.5
0006: MOVWF 10
0007: MOVLW 00
0008: MOVWF 0A
0009: GOTO 052
.................... //***************************************************************************
.................... //
.................... // Receptor de 5 canais on/off com pic 12f675
.................... //
.................... //
.................... // Autor: Cláudio Lários Data:10/07/2014
.................... // Atualizado em :18/12/2014
.................... //
.................... // 5 Canais configuravéis para modo pulso/retenção e
.................... // modo invertido/normal por pino individual.
.................... // Configure nas definições de usuário e recompile.
.................... //
.................... // Uso didático apenas.
.................... // Use apenas em conjunto com o tx de 5 canais on/off // (ref156b)
.................... // Obs. Sujeito a bugs ainda não observados.
.................... //***************************************************************************
....................
.................... //DEFINIÇÕES DO USUÁRIO:
.................... //Define o modo de operação das saidas (comente p/ modo pulso e descomente para
.................... // modo 'retenção'):
....................
.................... //#define c1_ret
.................... //#define c2_ret
.................... //#define c3_ret
.................... //#define c4_ret
.................... //#define c5_ret
....................
.................... //Define se modo normal ou invertido (comente para normal e descomente para modo
.................... // invertido):
....................
.................... // c1_inv
.................... //#define c2_inv
.................... //#define c3_inv
.................... //#define c4_inv
.................... //#define c5_inv
....................
.................... //==============================================================================
....................
.................... #include <12F675.h>
.................... //////////// Standard Header file for the PIC12F675 device ////////////////
.................... ///////////////////////////////////////////////////////////////////////////
.................... //// (C) Copyright 1996, 2013 Custom Computer Services ////
.................... //// This source code may only be used by licensed users of the CCS C ////
.................... //// compiler. This source code may only be distributed to other ////
.................... //// licensed users of the CCS C compiler. No other use, reproduction ////
.................... //// or distribution is permitted without written permission. ////
.................... //// Derivative programs created using this software in object code ////
.................... //// form are not restricted in any way. ////
.................... ///////////////////////////////////////////////////////////////////////////
.................... #device PIC12F675
....................
.................... #list
....................
.................... #device adc=8
.................... #use delay(clock=4000000)
.................... #fuses NOWDT,INTRC_IO, NOCPD, NOPROTECT, NOMCLR, NOPUT, BROWNOUT
.................... #zero_ram
.................... #use rs232(baud=9800,parity=N,xmit=PIN_A0,rcv=PIN_A3, bits=8)
....................
.................... #byte gpio = 0x05
.................... #byte tris = 0x85
....................
.................... #bit rfin = 0x05.3
.................... #bit c1 = 0x05.0 //pino 7
.................... #bit c2 = 0x05.1 //pino 6
.................... #bit c3 = 0x05.2 //pino 5
.................... #bit c4 = 0x05.4 //pino 3
.................... #bit c5 = 0x05.5 //pino 2
....................
.................... int1 flag_rok,flag_h,fc1,fc2,fc3,fc4,fc5;
....................
.................... int8 lc,hc,qb,cont_c1,cont_c2,cont_c3,cont_c4,cont_c5,aux_seg,aux_seg1;
.................... int8 buffer[4];
....................
.................... const int tmax= 80; //80
.................... const int8 t_inv=10;
.................... const int16 serial_number = 0x89ab; //use a mesma no tx (obrigatório)
....................
.................... const int8 tempo_seg = 0x07;//0x05 min
....................
.................... void init_ports(){
.................... #ifndef c1_inv
.................... c1=0;
000A: BCF 05.0
.................... #else
.................... c1=1;
.................... #endif
....................
.................... #ifndef c2_inv
.................... c2=0;
000B: BCF 05.1
.................... #else
.................... c2=1;
.................... #endif
....................
.................... #ifndef c3_inv
.................... c3=0;
000C: BCF 05.2
.................... #else
.................... c3=1;
.................... #endif
....................
.................... #ifndef c4_inv
.................... c4=0;
000D: BCF 05.4
.................... #else
.................... c4=1;
.................... #endif
....................
.................... #ifndef c5_inv
.................... c5=0;
000E: BCF 05.5
.................... #else
000F: GOTO 099 (RETURN)
.................... c5=1;
.................... #endif
....................
.................... }
....................
.................... //==============================================================================
.................... // ZERA REGISTRADORES APÓS RECEPÇÃO DE UM BIT
.................... //==============================================================================
.................... void reset_rx (){ lc=0; hc=0; flag_h=0; }
*
0020: CLRF 25
0021: CLRF 26
0022: BCF 24.1
0023: RETURN
....................
.................... //==============================================================================
.................... // Rotina de recepção RF
.................... //==============================================================================
....................
.................... void recebe(){
....................
.................... if(rfin&&!flag_rok){ flag_h=1; if(!++hc) --hc; }
0024: BTFSS 05.3
0025: GOTO 02D
0026: BTFSC 24.0
0027: GOTO 02D
0028: BSF 24.1
0029: INCFSZ 26,F
002A: GOTO 02C
002B: DECF 26,F
002C: GOTO 04C
.................... else {
.................... if(!flag_h){if(!++lc) --lc;} // incrementa lc e limita 0xff
002D: BTFSC 24.1
002E: GOTO 033
002F: INCFSZ 25,F
0030: GOTO 032
0031: DECF 25,F
0032: GOTO 04C
.................... else {
.................... if(lc>tmax) {reset_rx (); qb=32;}
0033: MOVF 25,W
0034: SUBLW 50
0035: BTFSC 03.0
0036: GOTO 03B
0037: CALL 020
0038: MOVLW 20
0039: MOVWF 27
003A: GOTO 04C
.................... else { shift_right(&buffer[0],4,(lc>hc)) ;
003B: MOVF 25,W
003C: SUBWF 26,W
003D: BTFSS 03.0
003E: GOTO 041
003F: BCF 03.0
0040: GOTO 042
0041: BSF 03.0
0042: RRF 32,F
0043: RRF 31,F
0044: RRF 30,F
0045: RRF 2F,F
.................... if (!--qb){
0046: DECFSZ 27,F
0047: GOTO 04B
.................... qb=32; //salva botões
0048: MOVLW 20
0049: MOVWF 27
.................... flag_rok=1;} // há uma recepção no buffer
004A: BSF 24.0
.................... reset_rx();
004B: CALL 020
.................... }
.................... }
.................... }
.................... delay_us(50);
004C: MOVLW 10
004D: MOVWF 20
004E: DECFSZ 20,F
004F: GOTO 04E
0050: NOP
0051: GOTO 0AB (RETURN)
.................... }
....................
.................... //==============================================================================
.................... // Rotina de atualização de flags no modo retenção
.................... //==============================================================================
....................
.................... void at_cont_ret(){
....................
.................... if(!--cont_c1)
*
0010: DECFSZ 28,F
0011: GOTO 013
.................... #ifdef c1_ret
.................... fc1=0;
.................... #else
.................... #ifdef c1_inv
.................... c1=1;
.................... #else
.................... c1=0;
0012: BCF 05.0
.................... #endif
.................... #endif
....................
....................
.................... if(!--cont_c2)
0013: DECFSZ 29,F
0014: GOTO 016
.................... #ifdef c2_ret
.................... fc2=0;
.................... #else
.................... #ifdef c2_inv
.................... c2=1;
.................... #else
.................... c2=0;
0015: BCF 05.1
.................... #endif
.................... #endif
....................
.................... if(!--cont_c3)
0016: DECFSZ 2A,F
0017: GOTO 019
.................... #ifdef c3_ret
.................... fc3=0;
.................... #else
.................... #ifdef c3_inv
.................... c3=1;
.................... #else
.................... c3=0;
0018: BCF 05.2
.................... #endif
.................... #endif
....................
.................... if(!--cont_c4)
0019: DECFSZ 2B,F
001A: GOTO 01C
.................... #ifdef c4_ret
.................... fc4=0;
.................... #else
.................... #ifdef c4_inv
.................... c4=1;
.................... #else
.................... c4=0;
001B: BCF 05.4
.................... #endif
.................... #endif
....................
.................... if(!--cont_c5)
001C: DECFSZ 2C,F
001D: GOTO 01F
.................... #ifdef c5_ret
.................... fc5=0;
.................... #else
.................... #ifdef c5_inv
.................... c5=1;
.................... #else
.................... c5=0;
001E: BCF 05.5
.................... #endif
.................... #endif
001F: GOTO 0A1 (RETURN)
....................
.................... }
.................... //==============================================================================
.................... // Rotina Principal
.................... //==============================================================================
....................
....................
.................... void main() {
*
0052: MOVF 03,W
0053: ANDLW 1F
0054: MOVWF 03
0055: MOVLW 3F
0056: MOVWF 20
0057: MOVLW 21
0058: MOVWF 04
0059: BCF 03.7
005A: CLRF 00
005B: INCF 04,F
005C: DECFSZ 20,F
005D: GOTO 05A
005E: CLRF 20
005F: BSF 03.5
0060: BCF 05.0
0061: BCF 03.5
0062: BSF 05.0
0063: BCF 1F.6
0064: BSF 03.5
0065: BCF 1F.0
0066: BCF 1F.1
0067: BCF 1F.2
0068: BCF 1F.3
0069: MOVLW 07
006A: BCF 03.5
006B: MOVWF 19
....................
.................... setup_adc_ports(NO_ANALOGS|VSS_VDD);
006C: BCF 1F.6
006D: BSF 03.5
006E: BCF 1F.0
006F: BCF 1F.1
0070: BCF 1F.2
0071: BCF 1F.3
.................... setup_adc(ADC_OFF);
0072: BCF 03.5
0073: BCF 1F.0
.................... setup_counters(RTCC_INTERNAL,RTCC_DIV_1);
0074: MOVLW 08
0075: MOVWF 20
0076: CLRF 01
0077: MOVLW 81
0078: MOVWF 04
0079: MOVF 00,W
007A: ANDLW C0
007B: IORLW 07
007C: MOVWF 00
007D: CLRWDT
007E: MOVF 00,W
007F: ANDLW C7
0080: BTFSC 20.3
0081: ANDLW C0
0082: IORWF 20,W
0083: MOVWF 00
.................... setup_timer_1(T1_DISABLED);
0084: CLRF 10
.................... setup_comparator(NC_NC_NC_NC);
0085: MOVLW 07
0086: MOVWF 19
0087: BSF 03.5
0088: MOVF 05,W
0089: MOVWF 05
008A: MOVLW 02
008B: BCF 03.5
008C: MOVWF 20
008D: DECFSZ 20,F
008E: GOTO 08D
008F: GOTO 090
0090: NOP
0091: MOVF 19,W
0092: BCF 0C.3
.................... setup_vref(FALSE);
0093: BSF 03.5
0094: CLRF 19
.................... tris=0b001000;
0095: MOVLW 08
0096: MOVWF 05
.................... init_ports();
0097: BCF 03.5
0098: GOTO 00A
.................... flag_rok=0;
0099: BCF 24.0
.................... aux_seg1=tempo_seg; //inicializa variavel <acrescentar
009A: MOVLW 07
009B: MOVWF 2E
....................
.................... //==============================================================================
.................... // Loop Principal
.................... //==============================================================================
.................... while(true){
.................... int8 conf,aux,aux_ret;
.................... int1 flag_acionar,flag_1rec; //<acrescentar
....................
....................
.................... if(!--aux_ret){aux_ret=250; at_cont_ret();}
009C: DECFSZ 35,F
009D: GOTO 0A1
009E: MOVLW FA
009F: MOVWF 35
00A0: GOTO 010
.................... if(!--aux_seg) { if(!--aux_seg1){aux_seg++,aux_seg1++;flag_1rec=0;}} //<acrescentar
00A1: DECFSZ 2D,F
00A2: GOTO 0A9
00A3: DECFSZ 2E,F
00A4: GOTO 0A9
00A5: MOVF 2D,W
00A6: INCF 2D,F
00A7: INCF 2E,F
00A8: BCF 36.1
.................... flag_rok=0; // <acrescentar
00A9: BCF 24.0
.................... recebe(); // <acrescentar
00AA: GOTO 024
.................... if((flag_rok)&&(!flag_1rec)){
00AB: BTFSS 24.0
00AC: GOTO 0BB
00AD: BTFSC 36.1
00AE: GOTO 0BB
.................... conf=buffer[1]+buffer[2]+buffer[3];
00AF: MOVF 31,W
00B0: ADDWF 30,W
00B1: ADDWF 32,W
00B2: MOVWF 33
.................... if(conf==buffer[0]){flag_1rec=1;aux_seg1=tempo_seg;flag_rok=0;}// // <acrescentar
00B3: MOVF 2F,W
00B4: SUBWF 33,W
00B5: BTFSS 03.2
00B6: GOTO 0BB
00B7: BSF 36.1
00B8: MOVLW 07
00B9: MOVWF 2E
00BA: BCF 24.0
.................... }
....................
.................... if((flag_rok)&&(flag_1rec)){
00BB: BTFSS 24.0
00BC: GOTO 0C7
00BD: BTFSS 36.1
00BE: GOTO 0C7
.................... conf=buffer[1]+buffer[2]+buffer[3];
00BF: MOVF 31,W
00C0: ADDWF 30,W
00C1: ADDWF 32,W
00C2: MOVWF 33
.................... if(conf==buffer[0]){flag_acionar=1; }
00C3: MOVF 2F,W
00C4: SUBWF 33,W
00C5: BTFSC 03.2
00C6: BSF 36.0
.................... }
....................
.................... if(flag_acionar){ // <acrescentar
00C7: BTFSS 36.0
00C8: GOTO 0EF
.................... flag_1rec=0; // <acrescentar
00C9: BCF 36.1
.................... flag_acionar=0; // <acrescentar
00CA: BCF 36.0
.................... //if(flag_rok){ //<comentar
.................... // conf=buffer[1]+buffer[2]+buffer[3]; //<comentar
.................... // if(conf==buffer[0]){ //<comentar
.................... //
.................... if((buffer[3]==make8(serial_number,1))&&(buffer[2]==make8(serial_number,0))){
00CB: MOVF 32,W
00CC: SUBLW 89
00CD: BTFSS 03.2
00CE: GOTO 0EE
00CF: MOVF 31,W
00D0: SUBLW AB
00D1: BTFSS 03.2
00D2: GOTO 0EE
.................... aux=buffer[1];
00D3: MOVF 30,W
00D4: MOVWF 34
....................
.................... if(!bit_test(aux,3)){
00D5: BTFSC 34.3
00D6: GOTO 0DA
.................... cont_c1=t_inv;
00D7: MOVLW 0A
00D8: MOVWF 28
.................... #ifdef c1_ret
.................... if(!fc1){
.................... c1=!c1; fc1=1;
.................... }
.................... #else
.................... #ifdef c1_inv
.................... c1=0;
.................... #else
.................... c1=1;
00D9: BSF 05.0
.................... #endif
.................... #endif
.................... }
.................... if(!bit_test(aux,1)){
00DA: BTFSC 34.1
00DB: GOTO 0DF
.................... cont_c2=t_inv;
00DC: MOVLW 0A
00DD: MOVWF 29
.................... #ifdef c2_ret
.................... if(!fc2){
.................... c2=!c2; fc2=1;
.................... }
.................... #else
.................... #ifdef c2_inv
.................... c2=0;
.................... #else
.................... c2=1;
00DE: BSF 05.1
.................... #endif
.................... #endif
.................... }
....................
.................... if(!bit_test(aux,2)){
00DF: BTFSC 34.2
00E0: GOTO 0E4
.................... cont_c3=t_inv;
00E1: MOVLW 0A
00E2: MOVWF 2A
.................... #ifdef c3_ret
.................... if(!fc3){
.................... c3=!c3; fc3=1;
.................... }
.................... #else
.................... #ifdef c3_inv
.................... c3=0;
.................... #else
.................... c3=1;
00E3: BSF 05.2
.................... #endif
.................... #endif
.................... }
....................
.................... if(!bit_test(aux,4)){
00E4: BTFSC 34.4
00E5: GOTO 0E9
.................... cont_c4=t_inv;
00E6: MOVLW 0A
00E7: MOVWF 2B
.................... #ifdef c4_ret
.................... if(!fc4){
.................... c4=!c4; fc4=1;
.................... }
.................... #else
.................... #ifdef c4_inv
.................... c4=0;
.................... #else
.................... c4=1;
00E8: BSF 05.4
.................... #endif
.................... #endif
.................... }
....................
.................... if(!bit_test(aux,5)){
00E9: BTFSC 34.5
00EA: GOTO 0EE
.................... cont_c5=t_inv;
00EB: MOVLW 0A
00EC: MOVWF 2C
.................... #ifdef c5_ret
.................... if(!fc5){
.................... c5=!c5; fc5=1;
.................... }
.................... #else
.................... #ifdef c5_inv
.................... c5=0;
.................... #else
.................... c5=1;
00ED: BSF 05.5
.................... #endif
.................... #endif
.................... }
....................
....................
.................... }
.................... // }
.................... flag_rok=0;
00EE: BCF 24.0
.................... }//if(flag_rok)
00EF: GOTO 09C
.................... }//while
.................... }//main
00F0: SLEEP

Configuration Fuses:
Word 1: 3FD4 INTRC_IO NOWDT NOPUT NOMCLR BROWNOUT NOPROTECT NOCPD

A única linha que eu mexi no código foi a #use rs232(baud=9800,parity=N,xmit=PIN_A0,rcv=PIN_A3, bits=8)

Analisando o código gerado parece perfeitamente OK. Pode enviar também o hex gerado?

HEX TX

:1000000000308A0004280000FF238316900000308F
:100010008A0073282C308400000803191D28013041
:10002000A100A001A00B1228A10B11284A30A000AA
:10003000A00B18281B28800B0F28080005100B3078
:10004000AC000A200230A900F730AA001230AA0240
:10005000031C38282A308400FC3080050310800CF3
:10006000800C00080319382836280000800B35283A
:10007000A90B24280514A630A000A00B3D280000E1
:1000800005100430A800A8080319722801302802BE
:10009000243E84000008A9002908AA00AB012B080F
:1000A000073C031C70282A1C612805100130AC0095
:1000B0000A200514A630A000A00B5C280000051043
:1000C0006C280510A630A000A00B642800000514C1
:1000D0000130AC000A2005100310AA0CAB0A4F280F
:1000E000A8034328BF2803081F398300831605107F
:1000F000831205141F1383161F109F101F119F11C9
:100100000730831299001F1383161F109F101F11B1
:100110009F1183121F100830A000810181308400DC
:100120000008C0390738800064000008C739A019EA
:10013000C03920048000900107309900831605081B
:10014000850002308312A000A00BA428A72800007D
:1001500019088C11831699013E3085008312050819
:100160003E393E3C0319BF288930A400AB30A500BE
:100170000508A600250824072607A7001E28AF2883
:0201800063001A
:02400E00D43F9D
:00000001FF
;PIC12F675
;CRC=A2E3 CREATED="10-nov-19 21:06"