crucial error in a 90% working hardware uart

[mimmmis]

Hi guys. Thanks to all that bother reading my question.
After huge amount of work i wrote the following program (4MHz pic16f876a).Although i can see MessageA and MessageB (when portb.7 is 5volts), and
HSerout [DEC B0,",",DEC B1,",",DEC B2,13,10] the problem is always tha the latter seems to stop the microcontroller. Although i can see HSerout [DEC B0,",",DEC B1,",",DEC B2,13,10] for a couple of times about in the 4th giving of data i take no response from microcontroller.With a reset everything is fine until another 3-4 giving of data.Has anything to do with overrun buffers? but i have included DEFINE HSER_CLOERR 1 ' automatic clear overrun error . Thanks anyway.....



INCLUDE "MODEDEFS.BAS"
DEFINE OSC 4

B0 VAR WORD
B1 VAR WORD
B2 VAR WORD
B3 VAR WORD
B4 VAR WORD

TRISC = %10000000 ' PORTC.7 is the RX input
' PORTC.6 is the TX output
' Serial communication definition
' ===============================
' Using internal USART and MAX232 to interface to PC
'
DEFINE HSER_RCSTA 90h ' enable serial port,
' enable continuous receive

DEFINE HSER_TXSTA 24h ' enable transmit,
' BRGH=1

DEFINE HSER_BAUD 9600
DEFINE HSER_CLOERR 1 ' automatic clear overrun error


RCIF VAR PIR1.5 ' Receive interrupt flag (1=full , 0=empty)
TXIF VAR PIR1.4 ' Transmit interrupt flag (1=empty, 0=full)

Pause 10 ' safe start-up delay
B0=0 '(duty cycle pwm)

HSerout ["Hi"]
main:

IF PORTB.7=1 Then
GoSub MessageA
EndIF

HSerout ["MessageB",13,10]
HPwm 1,B0,1000
High PORTB.5
Pause 1000
Low PORTB.5
Pause 1000
IF (RCIF) AND (PORTB.7=0) Then ' incomming data?
HSerin [WAIT ("d"),DEC B0,DEC B1,DEC B2]
HSerout [DEC B0,",",DEC B1,",",DEC B2,13,10] ' send it
EndIF
GoTo main

GoTo main
MessageA:
HSerout ["MessageA",13,10]
HSerout ["MessageA",13,10]
HSerout ["MessageA",13,10]
Pause 1000
HPwm 1,127,1000
GoTo main
End

[Charles Linquis]

It looks like your send routine takes up so much time that it doesn't get back to HSERIN before the receive buffer overflows. Your CLOERR define clears the overflow error, but that also dumps the buffer. As a result, you are losing characters.

It looks like you need an interrupt-driven receive routine.

Are the characters coming in continuously, or in bursts?

[mimmmis]

thanx for replying! my characters come continuously.actually one thinks it works excellent but after a while it does nothing! i am desperate.have you any idea how to look to inerrupts uart?

[Charles Linquis]

If the data really comes in continuosly, at full speed with no breaks, then you are in real trouble, since eventually you will overflow any size buffer you put in your PIC (which is limited by RAM size).

Is there some way you could send at a baud rate higher (like 2X) than you are receiving? They you would have a chance.

It would help a bit if you would run a faster oscillator as well (20MHz). And *WHY* are you not using an 18F series part?

[Jerson]

Charles is right. You are not looking at the serial port while your code is sending MessageA thrice and then pausing for 1000 ms. During that time, whatever comes in is bound to overflow the receive register. Cloerr will mitigate the problem to an extent, but imagine, you just received your "d" and are waiting for the decimal values for B0, B1 or B2. During that time if the input packet has already finished, you're in trouble. That's because the DEC modifier parses numbers only. If it doesn't find a number, either your number read is wrong or it will end up waiting indefinitely on the "d".

Ideal solution, put in an interrupt routine to capture the incoming serial characters. Catch them to a circular buffer and read that buffer often. How to do it? This is how I would do it....

' These variables are used to save the machine state on interrupt
wsave       var byte    $20     SYSTEM          ' location for W if in bank0
wsave1      var byte    $A0     SYSTEM          ' location for W if in bank1
wsave2      var byte    $120    SYSTEM          ' location for W if in bank2
wsave3      var byte    $1A0    SYSTEM          ' location for W if in bank3
ssave       var byte    BANK0   SYSTEM          ' location for STATUS register
psave       var byte    BANK0   SYSTEM          ' location for PCLATH register
fsave       var byte    BANK0   SYSTEM          ' location for FSR register
intR0       var byte    BANK0   SYSTEM          ' interrupt temporary variables
intR1       var byte    BANK0   SYSTEM

' Receive buffer
RxBuf           var     byte[16]    ' buffer holding received chars
WrPtr           var     byte        ' write index
RdPtr           var     byte        ' write index

' define the interrupt handler
define      INTHAND     _IntHandler

           goto OverInterrupt
IntHandler:
'*******************************************************************************
' Interrupts can be from a number of sources.  See INTCON p25
' We use the following
' RBIF - interrupt on RB change
' T0IF - Timer0 overflow interrupt
IntHandler:
asm   ; identify the interrupt source
      movf  FSR,w
      movwf fsave         ; save the fsr

      btfss PIE1,RCIE     ; if enabled and
      goto  EndInt
      btfss PIR1, RCIF    ; receive interrupt?
      goto  EndInt
RxISR
      movlw   6
      andwf   RCSTA,w           ;FERR(4) + OERR(2)
      btfss   STATUS,Z          ;not set
      bcf     RCSTA,CREN        ;clear errors
      bsf     RCSTA,CREN        ;by putting CREN=0,1
      ;
      movf    _WrPtr, W
      addlw   low (_RxBuf)
      movwf   FSR
      movf    RCREG,w
      movwf   INDF              ;RxBuf[WrPtr]=RCREG
      ;
      incf    _WrPtr
      movlw   0fh
      andwf   _WrPtr
EndInt
      movf  fsave,w       ;restore the FSR
      movwf FSR
      movf  psave,w       ;restore PCH
      movwf PCLATH
      swapf ssave, W      ;restore STATUS
      movwf STATUS
      swapf wsave, F
      swapf wsave, W      ;restore W
      retfie
ENDASM


' initialize the serial buffer
Ser_Init:
  RCSTA=$90             ' Enable serial port & continuous receive
  TXSTA=$20             ' Enable transmit, BRGH = 0
  SPBRG=25              ' 2400 Baud @ 4MHz, 0.0%
  RdPtr=0
  WrPtr=0
  return

' read a serial character
Ser_Getc:
  while RdPtr=WrPtr:wend
  gr[0]=RxBuf[RdPtr]
  RdPtr=RdPtr+1
  RdPtr=RdPtr & $0f
  return

' read the value of a hex digit to gr[0]
Ser_GetHex:
  gosub Ser_Getc
  if gr[0]>"9"then gr[0]=gr[0]-7
  gr[0]=gr[0]-"0"
  return

' read the value of 2 hex digits to gr[0]
Ser_GetHex2:
  gosub Ser_GetHex
  gr[1]=gr[0]<<4
  gosub Ser_GetHex
  gr[0]=gr[1]+gr[0]
  return

ProcessRX:
  while RdPtr <> WrPtr
    gosub Ser_GetC
    if gr[0]="d" then ProcRX10  ' Proceed only after we get the "d"
  wend
  return
ProcRX10:
' process the data here

This is just a framework and is incomplete. Use it at your own risk.

Jerson