Overrun errors using the getc() function

[aroman]

I am relatively new to PIC and C programming. I am writing a program that uses the getc() function of the CCS PIC C Compiler to read data on the RC7/RX pin of a PIC16F876. I review with an oscilloscope and the signal is coming OK on that pin (the start bit, the 8 data bits and 1 stop bit with no parity). I am sending the same character again and again but all I get on the receiving PIC is an overrun error and it stops receiving. Sometimes I get a framing error also. Settings of clock speed, baud rate and pins used are specified correctly on the program.

Does anyone know if there is something special I need to do before using the getc() function? Any initialization? Or does anyone think that it could be a "bug" of the compiler?

The versions of the compiler are the following:
PCW Compiler
IDE Version 2.29
PCB Version 2.731
PCM Version 2.731
Made in the year 2000

The code that I am using on the transmitter PIC is the following (the transmitter is working fine):

#include <16F876.h>
#use delay(clock=76800)
#fuses LP,NOWDT,PUT
#use rs232(baud=2400,parity=N,xmit=PIN_C6,rcv=PIN_C7)
void main() { //aquí inicia el programa principal
char dato;
setup_adc_ports(NO_ANALOGS);
setup_spi(FALSE);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_ccp1(CCP_OFF);
setup_ccp2(CCP_OFF);
dato = 65;
while(1)
{
printf("%1c",dato);
}
}

The code that I am using on the receiver PIC is the following (this is the one thatr I get overrun errors):

#include <16F876.h>
#use delay(clock=76800)
#fuses LP,NOWDT,PUT
#use rs232(baud=2400,parity = N, xmit = PIN_C6,rcv=PIN_C7)
#byte rxdata = 0x1a //Direccion del registro donde se almacena el dato leido de la UART
#byte rxstatus = 0x18 //Direccion del registro donde se controla la recepcion de la UART
#byte txstatus = 0x98 //Direccion del registro donde se controla la transmision de la UART
#bit rxint = 0x0c.5 //Direccion del bit del registro de bandera de interrupcion por recepcion en UART
#byte pir1 = 0x0c //Direccion del registro general que tiene las banderas de las interrupciones
void main() { //aquí inicia el programa principal
char caracter_recibido1; //es el caracter que se recibe por el RS232 del Rx proveniente del recolector
int direccion; //es la dirección en memoria EEPROM interna del PIC
rxstatus = 144; //inicializa el registro de estado del Rx de la UART habilitando el puerto serial (bit 7 en 1=128) y el continuos receive (bit 4 en 1=16). Y 128+16=144
disable_interrupts(global);
enable_interrupts(int_rda); //Habilita únicamente la interrupción por Rx de la UART
setup_adc_ports(NO_ANALOGS);
setup_spi(FALSE);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_ccp1(CCP_OFF);
setup_ccp2(CCP_OFF);
caracter_recibido1 = 6;
direccion = 0;
rxstatus = 0x80; //Deshabilita el continuos receive de la UART (bit 4)
rxstatus = 0x90; //Habilita el continuos receive de la UART para inicializarla
do //la letra "A" es un 41h en ASCII
{
while (rxint==0)//Mientras la bandera de dato recibido en FIFO de Rx de la UART no se levante, no haga nada
{}
caracter_recibido1=getc(); // Espera a recibir el caracter por el puerto serial.
write_eeprom(direccion, rxstatus);
direccion++;
write_eeprom(direccion, rxdata);
direccion++;
write_eeprom(direccion, pir1);
direccion++;
}
while (direccion < 100);
}

If anyone can answer one of these questions, please answer to this post

Thanks.

Greetings,

Alonso Roman

[Mark]

You are writing to a eeprom while you are receiving. This will cause delays and could make you get an overrun. You also have the INT_RDA enabled but no int handler! You should search the board for "ring buffers" and try and do something like that and then process the data in the main loop.

[Ttelmah]

[aroman]

Thanks Mark and Ttelmah for your help. I modified my code based on your recommendations and I got rid off the overrun error.

However, now I have another problem: I am transmiting a 65 in decimal, which corresponds to a 41 in hex and I am receiving a 50 in hex. I analyzed the waveform and I found out that the transmitted waveform is the following:

0 1 0 0 0 0 0 1 0 1 0 1
Start Bit Bit 0 Bit 1 Bit 2 Bit 3 Bit 4 Bit 5 Bit 6 Bit 7 Stop Bit Start Bit Bit 0...

There is a "displacement" of 2 bits to the right in the way the UART of the PIC interprets the data. What is happenning, is that the UART interprets this same waveform as follows:

0 1 0 0 0 0 0 1 0 1 0 1
Bit 7 Stop Bit Start Bit Bit 0 Bit 1 Bit 2 Bit 3 Bit 4 Bit 5 Bit 6 Bit 7 Stop Bit...

Which corresponds to a 50 in hex.

The code for the transmitter is the same as the one I put before. The new code for the reeceiver is the following:

[Mark]

You are still enabling interrupts! I don't see any interrupt handlers either. You do not have to enable ints to have the uart function. Also the statement:

[aroman]

Thanks again to Mark. I followed his suggestion, and the issue reduced. However, I also had to include a “non-confundible” character (a 0x00, because it has a waveform that cannot be confused with another character), and when I was transmitting the 0x41 character (the letter “A”), more than 99% of the times I received the same character.

However, I made another test and I got a lost character: on the transmitter, I modified my code to transmit not just the same character over and over, but a sequence of characters (characters 0x41 to 0x5B, that corresponds to letters “A” to “Z”). On the receiver program, all the characters are written to internal EEPROM. Analyzing those received characters, I found out that the first 13 characters are correctly written to EEPROM, but the character # 14 is lost. Then again the next 13 characters are good and the next character is lost.

I don’t know if this is a restriction with the getch() function. Does anyone has an idea of what could be the problem and how to correct it?

The code of the transmitting PIC is the following:

[Guest]

I think you must re-distribute the different tasks of your project taking in mind the time needed for each task. Reading your code, I see that after you received one char, inmediatly you try to store it in EEPROM -while the next char is comming- wich is not bad, but require a very thight use of time sharing.

Suggests:
1) Make an isr to handle INT_RDA.
2) Store the incoming chars in RAM (circular buffer).
3) In main(), check if the buffer is full, make your verifications and then
4) Disable INT_RDA.
5) Copy the RAM buffer content into EEPROM.
6) Clear the flag wich tell you the buffer is full.
7) Enable INT_RDA, and wait for incoming chars again.

hope this help,

Humberto

[aroman]

Thanks to Humberto for the suggestion. I modified the code of my receiver to use interrupts instead of polling. However, it seems like the UART receives just one "trash" character, stores it into internal EEPROM memory and then it just waits for another character forever. The waveform on the Rx pin is OK, just like is was when I used polling. The code that I am using for interrupt receive is the following: