PIC16F1827 EUSART communication

//****************************
// EUSART Define
//****************************
// TXSTA, RCSTA, BAUDCON
#define EUSART_MODETRANSMIT 0x00                // Transmit off, async, low speed
#define EUSART_MODERECEIVE 0x80                 // SerialPort on, 8bit, receive off
#define EUSART_MODEBAUDRATE 0x00                // Non-inverted data, 8-bit baud rate

// Baud rate generator (9600b/s)
#define BRGHIGH 0x01                            // Baud rate generator High = 1h
#define BRGLOW 25                               // Baud rate generator Low = 25d

// Transmission
#define EUSART_INTTRANSMITFLAG PIR1bits.TXIF    // Flag TXREG empty/full
#define EUSART_TSREGFLAG TXSTAbits.TRMT         // Flag transmit ready

// Reception
#define EUSART_INTRECEIVE PIE1bits.RCIE         // Enable RCIF interruption
#define EUSART_INTRECEIVEFLAG PIR1bits.RCIF     // Flag RCREG have new data

#define MSGMAXSIZE 0x08                         // Max size (in byte) RS-232 can save

// Register bits define
#define EUSART_CREN RCSTAbits.CREN              // Enable continuous reception
#define EUSART_OERR RCSTAbits.OERR              // Flag Overrun error
#define EUSART_TXEN TXSTAbits.TXEN              // Enable transmission
#define EUSART_SPEN RCSTAbits.SPEN              // Enable buffer
#define EUSART_SCKP BAUDCONbits.SCKP            // Data inverted or non-inverted

// Pins
#define EUSART_IOPINTX TRISBbits.TRISB5         // IO TX
#define EUSART_IOPINRX TRISBbits.TRISB1         // IO RX

// Pins 2
#define INITGIE INTCONbits.GIE                  // Enable General interuption
#define INITPEIE INTCONbits.PEIE                // Enable Peripheral interrupt

//****************************
// EUSART Initialization
//****************************
void EUSART_Initialize(void)                    // Initialisation de l'EUSART
{
    RCSTA = EUSART_MODERECEIVE;                 // Receive control register
    TXSTA = EUSART_MODETRANSMIT;                // Transmit control register
    BAUDCON = EUSART_MODEBAUDRATE;              // Baud rate generator control register
    SPBRGH = BRGHIGH;                           // Baud rate generator register High
    SPBRGL = BRGLOW;                            // Baud rate generator register Low
    APFCON0bits.RXDTSEL = 0;                    // Pin des data = 0:RB1 , 1:RB2
    APFCON1bits.TXCKSEL = 1;                    // Pin de la clock = 0:RB2 , 1:RB5
}

//****************************
// Ecoute les message en RS-232
//****************************
void Receive(void)                              // Reception de données
{
    EUSART_IOPINRX = 1;                         // Met la pin en entrée pour la reception
    EUSART_INTRECEIVE = 1;                      // Enable Reception interruption
    EUSART_CREN = 1;                            // Activate continuous reception

    while(!Flags1.ReceiveOFF)                   // Tant que données reçues < 8
    {                                           // Blink LED @ 4Hz
        __delay_ms(125);
        PERIPHERAL_LED = (!PERIPHERAL_LED);

        if(EUSART_OERR)                         // Si Overrunn error
        {
            EUSART_CREN = 0;                    // CREN = 0
            __delay_ms(1);
            EUSART_CREN = 1;                    // CREN = 1
        }
    }

    PERIPHERAL_LED = 1;                         // Eteint la led
}

//****************************
// Transmet a Message
//****************************
void TransmitMsg(unsigned char Msg[])           // Transmet un message de taille ilimitée
{
    EUSART_IOPINTX = 0;                         // Pins en sortie
    EUSART_TXEN = 1;                            // Enable transmission

    unsigned char Counter;
    for (Counter = 0; Msg[Counter] != 0; Counter++) {
        while(!EUSART_INTTRANSMITFLAG);         // Tant que TXREG est plein
        __delay_ms(2);                          // Délai anti-parasites
        TXREG = (Msg[Counter] ^ 0xFF);          // Transmet le caractère du tableau inversé
    }
    while(!EUSART_TSREGFLAG);                   // Attendre qu'une nouvelle transmission est prête

    EUSART_TXEN = 0;                            // Disable transmission
    EUSART_IOPINTX = 1;                         // Pins en entrée
    __delay_ms(5);                              // Délai anti-parasites
}


void interrupt ISR(void)
{
//****************************
// Interruption a la reception de message
//****************************
    if(EUSART_INTRECEIVE && EUSART_INTRECEIVEFLAG)  // Interuption Data received
    {
        EUSART_INTRECEIVE = 0;                  // Reception interruption off
        unsigned char Temp = RCREG;             // Copie les données reçues dans une variable temporaire
        DataRECEIVED[DataCounter] = (Temp^0xFF);// Place les données reçues inversées dans un tableau

        if(DataRECEIVED[DataCounter] == 0x00)   // Test valeur reçue est nulle
        {
            DataCounter--;                      // Décrémente l'addresse du tableau pour supprimer cette donnée
        } else {
            Flags1.DataRC = 1;                  // Si data reçue pas nulle, set flag Data received
        }

        DataCounter++;                          // Incrémente l'adresse du tableau de 1

                                                // Test si c'est le tableau à 8 bytes et que une valeur n'est pas nulle
        if((DataCounter >= 8) && Flags1.DataRC == 1)
        {
            EUSART_IOPINRX = 0;                 // Met la pin en sortie pour utiliser l'afficheur LCD
            EUSART_SPEN = 0;                    // Désactive le buffer, et donc la réception
            __delay_ms(10);                     // Délai pour éviter la transmission parasite au LCD
            LCD_Clear();                        // Efface l'écran
            LCD_WriteMessage(RECEIVED);         // Affiche message quand données reçues
            LCD_SetEntry(1,0);                  // Se déplacer à la 2e ligne
            LCD_WriteMessage(DataRECEIVED);     // Afficher le message reçu
            Flags1.ReceiveOFF = 1;              // Termine la réception de données
        }

        EUSART_INTRECEIVE = 1;                  // Reception interruption on
    }
}