PIC12F1572 UART Transmitter and receiver issue

Question

I am designing and RGB LED project and that's controlled by a PIC12F1572. The software that I am using is MPLAB IDE with the XC8 compiler. The plan is to use serial communication to send LED RGB combination data commands to the PIC to be stored in a variable that will make it performs the LED blink and glowing.When I send the RGBFF00001FF001F0 from the PC terminal and catch this in one array but when I wanted to see the value I collected in array so I EUSART_Write(array) again then I got the value with spaces in between each character[R G B F F 0 0 0 0 1 F F 0 0 1 F 0 \n] Anyone knows how it's happening , because on this array value my next task is depending. I share my code Here : Any Hint or advice on where to find information on this will be greatly appreciated.

Thanks!

main.c

#include "mcc_generated_files/mcc.h"
#include <stdlib.h>
#include <stdio.h>
#include "atoh.h"
#include "LED.h"
#define _XTAL_FREQ 16000000
#define FRAMESIZE 18


void main(void)
{
   uint8_t data ,i,j;

   uint16_t R_value, G_value ,B_value;
   uint8_t value;
   uint8_t RX_Buffer[FRAMESIZE] = {0};
   uint8_t RGB_data[6] ,HEX_data[6];

    // initialize the device
    SYSTEM_Initialize();
    INTERRUPT_GlobalInterruptEnable();                       // Enable the Global Interrupts
    INTERRUPT_PeripheralInterruptEnable();                   // Enable the Peripheral Interrupts

   //  while(1)
   // {
   //    //EUSART_Write(0x61);
      while (!RCIF)
      {
          data = EUSART_Read();                              // Read received character
          for (i = 0; i<FRAMESIZE ; i++)
          {
            RX_Buffer[i] = data;
          }

          EUSART_Write(data); 
          EUSART_Write(RX_Buffer);       //HERE I RECHECK MY COLLECTED VALUE
         //check if any data is received
          }

            if(RX_Buffer[0]=='R' && RX_Buffer[FRAMESIZE-1] == '\n')
            {
              //ASCII to HEX separate values
              for (j = 0 ; j = 5; j++ )                   // get the RGB value in the separate array
                {
                    RGB_data[j] = RX_Buffer[j+3];
                    HEX_data[value] = RGB_data[j]/16;
                    EUSART_Write(HEX_data);
                }

              // uint32_t number = (uint32_t)strtol(HEX_data, NULL, 16);
              // R_value = number >>16;
              // G_value = (number & 0xffff) >> 8;
              // B_value = (number & 0x0000FF);

               R_value = (uint16_t) atoh(HEX_data[0], HEX_data[1]);
               G_value = (uint16_t) atoh(HEX_data[2], HEX_data[3]);
               B_value = (uint16_t) atoh(HEX_data[4], HEX_data[5]);
               EUSART_Write(R_value);
            }

               SetLedColor(R_value,G_value,B_value);



    } 

and just incase UART.c

#include "eusart.h"
#include "LED.h"
#include <stdlib.h>
#include <stdio.h>
//#include "atoh.h"
/**
  Section: Macro Declarations
*/
#define EUSART_TX_BUFFER_SIZE 8
#define EUSART_RX_BUFFER_SIZE 8
#define _XTAL_FREQ 16000000
#define FRAMESIZE 18
/**
  Section: Global Variables
*/

static uint8_t eusartTxHead = 0;
static uint8_t eusartTxTail = 0;
static uint8_t eusartTxBuffer[EUSART_TX_BUFFER_SIZE];
volatile uint8_t eusartTxBufferRemaining;

static uint8_t eusartRxHead = 0;
static uint8_t eusartRxTail = 0;
static uint8_t eusartRxBuffer[EUSART_RX_BUFFER_SIZE];
volatile uint8_t eusartRxCount;


/**
  Section: EUSART APIs
*/

void EUSART_Initialize(void)
{
    // disable interrupts before changing states
    PIE1bits.RCIE = 0;
    PIE1bits.TXIE = 0;

    // Set the EUSART module to the options selected in the user interface.

    // ABDOVF no_overflow; SCKP Non-Inverted; BRG16 16bit_generator; WUE disabled; ABDEN disabled; 
    BAUDCON = 0x08;

    // SPEN enabled; RX9 8-bit; CREN enabled; ADDEN disabled; SREN disabled; 
    RCSTA = 0x90;

    // TX9 8-bit; TX9D 0; SENDB sync_break_complete; TXEN enabled; SYNC asynchronous; BRGH hi_speed; CSRC slave; 
    TXSTA = 0x24;

    // Baud Rate = 9600; SPBRGL 160; 
    SPBRGL = 0xA0;

    // Baud Rate = 9600; SPBRGH 1; 
    SPBRGH = 0x01;


    // initializing the driver state
    eusartTxHead = 0;
    eusartTxTail = 0;
    eusartTxBufferRemaining = sizeof(eusartTxBuffer);

    eusartRxHead = 0;
    eusartRxTail = 0;
    eusartRxCount = 0;

    // enable receive interrupt
    PIE1bits.RCIE = 1;
}

uint8_t EUSART_Read(void)
{
    uint8_t readValue  = 0;

    while(0 == eusartRxCount)
    {
    }

    readValue = eusartRxBuffer[eusartRxTail++];
    if(sizeof(eusartRxBuffer) <= eusartRxTail)
    {
        eusartRxTail = 0;
    }
    PIE1bits.RCIE = 0;
    eusartRxCount--;
    PIE1bits.RCIE = 1;

    return readValue;
}



void EUSART_Write(uint8_t txData)
{
    while(0 == eusartTxBufferRemaining)
    {
    }

    if(0 == PIE1bits.TXIE)
    {
        TXREG = txData;
    }
    else
    {
        PIE1bits.TXIE = 0;
        eusartTxBuffer[eusartTxHead++] = txData;
        if(sizeof(eusartTxBuffer) <= eusartTxHead)
        {
            eusartTxHead = 0;
        }
        eusartTxBufferRemaining--;
    }
    PIE1bits.TXIE = 1;
}

void EUSART_Transmit_ISR(void)
{

    // add your EUSART interrupt custom code
    if(sizeof(eusartTxBuffer) > eusartTxBufferRemaining)
    {
        TXREG = eusartTxBuffer[eusartTxTail++];
        if(sizeof(eusartTxBuffer) <= eusartTxTail)
        {
            eusartTxTail = 0;
        }
        eusartTxBufferRemaining++;
    }
    else
    {
        PIE1bits.TXIE = 0;
    }
}

void EUSART_Receive_ISR(void)
{

    if(1 == RCSTAbits.OERR)
    {
        // EUSART error - restart

        RCSTAbits.CREN = 0;
        RCSTAbits.CREN = 1;
    }

    // buffer overruns are ignored
    eusartRxBuffer[eusartRxHead++] = RCREG;
    if(sizeof(eusartRxBuffer) <= eusartRxHead)
    {
        eusartRxHead = 0;
    }
    eusartRxCount++;
}

void EUSART_Put(const unsigned char *string)
{
    //int i;
    for (i=0;string[i]!='\0';i++)
    {
        EUSART_Write(string[i]);
    }
}

Answer 1

So Storing the UART frame and echoed back was my issue here and I solved it here by my way. here is my answer for this. code:

void main(void)
{
   uint8_t data,i,j,got_char;

   uint8_t R_value, G_value ,B_value;
   uint8_t value;
   uint8_t RX_Buffer[FRAMESIZE];
   uint8_t RGB_data[6] ,HEX_data[6];

    // initialize the device
    SYSTEM_Initialize();
    INTERRUPT_GlobalInterruptEnable();                       // Enable the Global Interrupts
    INTERRUPT_PeripheralInterruptEnable();                   // Enable the Peripheral Interrupts

  while (1)
 {

        if (EUSART_DataReady)
        {
            for (i = 0; i<FRAMESIZE; i++)
            {
                RX_Buffer[i] = EUSART_Read();
                if (RX_Buffer[i] == '\n')
                   break;
            }

            RX_Buffer[i] = '\n';                        //append '\n' at the end of stoaring array for detection of frame
            RX_Buffer[i+1] = '\0';                      // End of an array
            EUSART_WriteAnArrayOfBytes(RX_Buffer);


        if(RX_Buffer[0]=='R' && RX_Buffer[FRAMESIZE-2] == '\n')   //check for correct frame
          {

            LATAbits.LATA2 = 1;
            __delay_ms(2000);
            LATAbits.LATA2 = 0;
            __delay_ms(1000);
          }
        }

  }       

}

Answer 2

Just like EUSART_Put() you should always thing of wrapping function that you use to send data through the UART, having separate EUSART_Write() calls all over the place is a bad practice, the erro comes probably from EUSART_Write(R_value); since R_value is defined here :

uint16_t R_value, G_value ,B_value;

You’re actually sending 2 bytes back (that's where the empty byte came from).