Olá Rodrigo!

A porção de código responsável para determinar de forma automática o número serial é esta:

//Ao invés de randomizar 3 bytes para servir de endereço do tx,
// usamos os valores indeterminados iniciais dos timers 0 e 1
if(read_eeprom(0))
{
write_eeprom(0,0);
write_eeprom(1,tmr1l&=0b00111111); //apaga os bits dos botões
write_eeprom(2,tmr0);
write_eeprom(3,tmr1h);
}

Basta eliminar esta parte e acrescentar no início do programa a diretiva para carregar um valor fixo na eeprom interna do pic:

#rom 0x2100 = {0,77,44,55}

Veja abaixo o código com as modificações:

/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
// CLONE_HT6P20B
//
// EMULADOR DE PROTOCOLO HT6P20B USANDO PIC12F675
//
// AUTOR: CLAUDIO LÁRIOS DATA: 07/06/2014
//
// NECESSITA ESCOLHER O SERIAL DE 28 BITS  NA CARGA DE EEPROM INTERNA
// 3 BOTÕES DE ACIONAMENTO
//
// PARA FINS DIDÁTICOS APENAS
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

#include <12F675.h>
#device adc=8
#use delay(clock=4000000)
#fuses NOWDT,INTRC_IO, NOCPD, NOPROTECT, NOMCLR, NOPUT, BROWNOUT

#byte tmr1h=0x0f
#byte tmr1l=0x0e
#byte tmr0=0x01
#byte tris=0x85

#ROM 0X3FF = {0X3460}

#ROM 0X2100 = {0,0X22,0X33,0X44}  // ESCOLHA AQUI O SERIAL NUMBER (3 BYTES , NO CASO 223344 HEXA)

INT8 DATA[3];

#bit B_N1 = 0x05.5 //pino 2 BOTÃO PARA INICIAR N1 TRANSMISSÃO
#bit B_N2 = 0x05.4 //pino 3 BOTÃO PARA INICIAR N2 TRANSMISSÃO
#bit B_N3 = 0x05.0 //pino 5 BOTÃO PARA INICIAR N3 TRANSMISSÃO
#bit saida = 0x05.2 //pino 7 SAIDA PARA O TX

const int16 te = 500; //valor de TE

//==============================================================================
// rotina geradora de tempo piloto de 23 TE sem transmissão
//==============================================================================
void pilot_period(){
saida=0;
delay_us(23*te);
}
//==============================================================================
// rotina geradora do start bit
//==============================================================================
void start_bit(){
saida=1;
delay_us(te);
saida=0;
//==============================================================================
// rotina geradora de bit '1'
//==============================================================================
}
void bit1(){
saida=0; //'1'
delay_us(2*te);
saida=1;
delay_us(te);
saida=0;
//==============================================================================
// rotina geradora de bit '0'
//==============================================================================
}
void bit0(){
saida=0; //'0'
delay_us(te);
saida=1;
delay_us(2*te);
saida=0;
}
//==============================================================================
// rotina geradora de bits de fim de transmissão
//==============================================================================
void end_period(){
bit0();
bit1();
bit0();
bit1();
}

//==============================================================================
// rotina de envio para saída rf de um byte
//==============================================================================

void envia(int valor){
int b;
for(b=0;b<8;b++){

if(valor&1){
bit1();
}
else{
bit0();
}
valor>>=1;
}
}
//==============================================================================
// rotina principal
//==============================================================================
void main() {

setup_adc_ports(NO_ANALOGS|VSS_VDD);
setup_adc(ADC_OFF);
// setup_counters(RTCC_INTERNAL,RTCC_DIV_1);
setup_timer_1(T1_INTERNAL | T1_DIV_BY_1);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
tris=0b111011;

//Número Serial definido previamente pelo usuário nas posições 1,2 e 3 da eeprom interna

//==============================================================================
// loop principal de repetição
//==============================================================================

while(true){
int8 a;

if((!b_n1)||(!b_n2)||(!b_n3)){ //algum botão foi pressionado?

for(a=0;a<3;a++){ // carrega data com o serial a enviar
data[a]=read_eeprom(a+1);
}

if(!b_n1)data[0]|=0b10000000; //botão 1 acionado?
if(!b_n2)data[0]|=0b01000000; //botão 2 acionado?
if(!b_n3)data[0]|=0b11000000; //botão 3 acionado?

pilot_period();// 23 TE desligado
start_bit();//bit de inicio

for(a=3;a>0;a--){ //envia os 3 bytes do serial
envia(data[a-1]);
}
end_period();// envia os bits de finalização 0-1-0-1
}

}
}

Recompile usando o compilador CCS C para obter o novo arquivo hex.

Claudio, obrigado pela resposta.

Ocorre que eu fiz o que voce sugeriu, ele funciona, porem não recebo o valor que inseri, vou explicar.

Com um arduino eu fiz um sisteminha que recebe o sinal do TX (HT6P20B) e de alguma forma converte para decimal, o numero exibido em um display sempre é de 7 digitos (TX´s intelbras são de 6 digitos)  Ex: 2953227. Eu inseri como mandou em hex o valor {0,0X1C,0XB,0XDE} que seria 28 11 222 porem eu recebo um numero completamente diferente do que tentei enviar.

Estou tentando clonar um TX ja cadastrado em um receptor, com o sistema do arduino eu consigo, pois coloco na prog.  o numero que leio do TX, e funciona. Tipo o valor lido do referido controle é 2953227, no sistema ht6p20b do arduino (neste caso o trasnmissor) eu insiro esse mesmo numero e ele funciona.

O que poderia estar ocorrendo?

Não consegui editar a mensagem anterior.

Um exemplo do que está ocorrendo: eu programo isso:

#ROM 0X2100 = {0,28,0,0}  //DECIMAL

ou

#ROM 0X2100 = {0,0X1C,0X00,0X00} // HEXA

ou

#ROM 0X2100 = {0,0b11100,0B0,0B0}// BIN

  E em todos esses casos eu recebo na tela do display o numero 14. 

Olá Rodrigo!

O envio dos bytes ocorre da seguinte forma:

Começa enviando o byte da posição da eeprom n.3
envia o bit menos significativo primeiro (LSB) até chegar no mais significativo (MSB).
Depois envia o byte da posição da eeprom n.2
igualmente, envia o bit menos significativo primeiro (LSB) até chegar no mais significativo (MSB).
E finalmente envia o byte da posição da eeprom n.1.
Como os bytes anteriores, envia o bit menos significativo primeiro (LSB) até chegar no mais significativo (MSB).
A posição n.0 da eeprom era usada apenas para controle, impedindo a alteração do serial number após a programação automática inicial, e portanto sem uso quando entramos manualmente o serial number (no seu caso).

Resumindo: chega primeiro o byte da posição 3 da eeprom, depois o byte 2 e finalmente o byte 1. Tente alterar os seriais numbers e anote o que chegou para cada um deles, tentando ver se consegue encontrar uma lógica, como por exemplo, alteração entre nibbles ou posição de bytes (analise em binário que fica fácil ver deslocamentos de bits).

Tem a questão também da velocidade de transmissão que pode estar alterada em relação ao que o seu programa receptor suporta. No programa é dada pela constante 'te' (no caso 500). Tente aumentar ou diminuir este valor por tentativa e erro.

Não sei como trabalha a sua rotina de recepção pois arduino não é minha praia.

Talvez seja melhor você usar o transmissor do próprio arduino, uma vez que ele funciona para suas necessidades. Poderia talvez ser uma versão de arduino com chip de 8 pinos, que no final, vai dar na mesma, sem dor de cabeça para você.

Claudio, eu sou um pouco iniciante nessa questão de LSB MSB, não entendo muito, desculpe, mas tenho boas noticias.

Eu fiz um teste aqui, peguei o seu codigo que recebe o sinal do HT6P20B e grava na eeprom (o receptor generico) e mesclei com o TX_clone_random, então o sinal recebido é reenviado, para conseguir fazer isso, tive que gravar o sinal recebido na eeprom, e depois ler a eeprom para formar o DATA[3], colocando direto não dava certo.

Então segunda vou fazer um teste, vou gravar um mvalor na eeprom e depois no momento de enviar vou ler a eeprom para formar o DATA e ver se assim funciona.

Sobre a questão da velocidade de transmissão, naõ deve ser, pois usando o tx_clone_random o meu leitor de codigo com o arduino funciona lendo os codigo "criados" pelo timrr do pic, inclusive, a cada re-gravação do pic o codigo muda.

Mas obrigado por enquanto, agradeço a atenção.