PIC12F1572 UART Передатчик и ресивер вопрос

Question

Я проектирую и проект RGB LED, и это контролируется PIC12F1572. Программное обеспечение, которое я использую, - это MPLAB IDE с компилятором XC8. План состоит в том, чтобы использовать последовательную связь для отправки командных данных команды LED RGB в PIC, которые будут храниться в переменной, которая заставит ее мигать и светиться светодиодом. Когда я отправляю RGBFF00001FF001F0 с ПК-терминала и поймаю это в одном массиве, когда я захотел увидеть значение, которое я собрал в массиве, так что снова EUSART_Write (массив), то я получил значение с пробелами между каждым символом [RGBFF 0 0 0 0 1 FF 0 0 1 F 0 \ n] Кто-нибудь знает, происходит, потому что на этом значении массива зависит моя следующая задача. Я поделился своим кодом здесь: Любой совет или совет о том, где найти информацию об этом, будем очень благодарны.

Спасибо!

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); 



    } 

и просто упаковывают 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

Так что хранение рамы UART и повторная эхо-копия были моей проблемой здесь, и я решил ее здесь по-своему. вот мой ответ для этого. код:

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

Как EUSART_Put() вы всегда должны вещь оберточной функции, которая используется для передачи данных через UART, имеющие отдельный EUSART_Write() звонки повсюду - плохая практика, эро приходит, вероятно, от EUSART_Write(R_value);, так как R_value определяется здесь:

uint16_t R_value, G_value ,B_value; 

Вы действительно отправляете 2 байта назад (откуда появился пустой байт).