Pessoal só para tentar facilitar a compreensão dos códigos existe uma ferramenta "Inserir código" que preserva o código fonte original.

Exemplo:
include "C:\Program Files\PICC\PICC\receptor 16f628A.h"

#int_timer0
void trata_to()
{
   int conta;
   static boolean led;
   set_timer0(131 + get_timer0());
   conta++;
   if(conta == 125)
   {
   conta=0;
   output_bit(PIN_B0,led);
   led=!led;
   }
}
char pacote[16],pacote_liga[16],pacote_desliga[16];
int x,y;
void carrega_valores()
{
   x=0;
   y=15;
   while(x<16)
   {
   pacote_desliga[x] =y;

   x++;
   y--;
   }
   x=0;
   while(x<16)
   {
   pacote_liga[x] =x;

   x++;
   }
}
void main()
{

   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_64);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
   enable_interrupts(global|int_timer0);
   carrega_valores();
   while(true)
   {
   x=0;
   while(x<16)
   {
   pacote[x] = getc();

   x++;
   }
   x=0;
   while(x<16)
   {
   xxxx(pacote[x]);

   delay_ms(50);
   x++;
   }
   x=0;
   while(x<16)
   {
   if(pacote[x]==pacote_liga[x])

   {
   output_high(PIN_B3);
   }
   x++;
   }
   x=0;
   while(x<16)
   {
   if(pacote[x] == pacote_desliga[x])
   {
   output_low(PIN_B3);
   }
   x++;
   }
   }
}


Fiz um programa agora e botei no PIC e na placa.
Terminei de montar ela agora a pouco.
No programa mandei ele pegar o que tivesse no ar e mostrar no LCD.
Realmente a quantidade de informações é enorme.
Eu não sei o q aconteceu que ele só está recebendo 3 valores e parando.
Vou revisar o programa, mas acho que está tudo certo.

#include "C:\Program Files\PICC\PICC\receptor 16f877a.h"


#define LCD_ENABLE_PIN PIN_B0
#define LCD_RS_PIN PIN_B1
#define LCD_RW_PIN PIN_B2
#define LCD_TYPE 2
#include <lcd.c>
int x;
void main()
{
   lcd_init();



   setup_adc_ports(NO_ANALOGS);
   setup_adc(ADC_OFF);
   setup_psp(PSP_DISABLED);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);

   while(true)
   {
   printf(lcd_putc,"\fRecebi=");
   x=getch();
   printf(lcd_putc,"%i ",x);
   delay_ms(100);
   x=getch();
   printf(lcd_putc,"%i ",x);
   delay_ms(100);
   x=getch();
   printf(lcd_putc,"%i ",x);
   delay_ms(100);
   x=getch();
   printf(lcd_putc,"\n%i ",x);
   delay_ms(100);
   x=getch();
   printf(lcd_putc,"%i ",x);
   delay_ms(100);
   x=getch();
   printf(lcd_putc,"%i ",x);
   delay_ms(100);
   x=getch();
   printf(lcd_putc,"%i ",x);
   delay_ms(100);
   x=getch();
   printf(lcd_putc,"%i ",x);
   delay_ms(100);
   }

}
Esse é o programa.

Plancton, vou dar uma olhada nos seus arquivos.
Cfreund não entendo porque colocar um caracter no começo e outro no fim.
Se da no mesmo eu colocar números ou não.

o programa do plancton é um excelente exemplo.

mas como vc terá um ingrediente a mais na seu projeto, o ruído, eu te aconselho a colocar a paridade para saber se o caractere recebido faz parte do pacote ou não. fazendo isso seu pacote terá mais chances de estar íntegro com os 16 caracteres.

Smarley,

se vc trabalhar a 4800bps (q é maximo segundo o datashit do receptor), quando vc estiver recebendo dados do transmissor, as chances de entrar um byte intrometido é mínima. e se você usar paridade, diminui ainda mais.

tava pensando aqui e bolei um jeito facil e eficiente para essa verificacao:

se vc trabalhar com números de 0 a 7, vc usaria somente 3 bits.

definiria o número 7 como inicio de pacote e o número 0 como fim e deixaria o resto para comandos.

sobrariam 5 bits, certo? entao vamos aproveita-los:

1' ao 3' - Utilizaria para os números de 0 a 7.
4' ao 7' - Utilizaria para enviar a posição do byte atual dentro do pacote.
8'        - Paridade. Se a contagem dos bits '1' for par, setaria em '1'.

Ex.:

Pacote[00] = 0b1 0000 000; // bit8: P; bit7~4: Posição 0; bit3~0: Inicio de Pacote

Pacote[01] = 0b1 0001 001; // bit8: P; bit7~4: Posição 01; bit3~0: Número 1.
Pacote[02] = 0b1 0010 010; // bit8: P; bit7~4: Posição 02; bit3~0: Número 2.
Pacote[03] = 0b1 0011 011; // bit8: P; bit7~4: Posição 03; bit3~0: Número 3.
Pacote[04] = 0b1 0100 100; // bit8: P; bit7~4: Posição 04; bit3~0: Número 4.
Pacote[05] = 0b1 0101 101; // bit8: P; bit7~4: Posição 05; bit3~0: Número 5.
Pacote[06] = 0b1 0110 110; // bit8: P; bit7~4: Posição 06; bit3~0: Número 6.
Pacote[07] = 0b1 0111 111; // bit8: P; bit7~4: Posição 07; bit3~0: Número 7.
Pacote[08] = 0b1 1000 111; // bit8: P; bit7~4: Posição 08; bit3~0: Número 7.
Pacote[09] = 0b0 1001 111; // bit8: I; bit7~4: Posição 09; bit3~0: Número 7.
Pacote[10] = 0b0 1010 111; // bit8: I; bit7~4: Posição 10; bit3~0: Número 7.
Pacote[11] = 0b1 1011 111; // bit8: P; bit7~4: Posição 11; bit3~0: Número 7.
Pacote[12] = 0b0 1100 111; // bit8: I; bit7~4: Posição 12; bit3~0: Número 7.
Pacote[13] = 0b1 1101 111; // bit8: P; bit7~4: Posição 13; bit3~0: Número 7.
Pacote[14] = 0b0 1111 111; // bit8: I; bit7~4: Posição 14; bit3~0: Número 7.

Pacote[15] = 0b0 1111 111; // bit8: I; bit7~4: Posição 15; bit3~0: Fim de Pacote

da pra amadurecer a idéia, mas o propóstio principal é te dar uma luz das varias maneiras de que pode ser feito isso.

Jorge, poderia me explicar o porque dessa sua afirmação?

Nem preciso, sei muito bem como funciona.

não somente eu como: fabricantes de memória ecc, usuários de varios protocolos como o f2f, e uma kctada de gente...

utilize interrupcoes e filtre logo no inicio para ser processados somente os caracteres q vc utilizar