pic24 Los datos de recepción de UART no son válidos

0

Hola, estoy escribiendo un programa para la interrupción de recepción de UART para PIC24FJ64GA306

estoy recibiendo datos que están en formato 0xAAXXXXXXXX, donde los datos después de AA pueden ser cualquier cosa ... los datos transmitidos a través del host y recibidos por pic no coinciden

También observé un problema extraño: cuando transmito por primera vez que los datos no se reciben completamente, solo se reciben 2 bytes de datos, en donde cuando transmito la segunda vez, obtengo un error de ejecución SUPERIOR.

El código es el siguiente:

static void uart1_DebugSerial_init(void)
{
  /*Setting the RPINRbits to map the peripheral port pins*/
   RPINR18bits.U1RXR = 26;   /*Selects RP26 as UART1 RX pin*/
   /*Setting the RPORbits to map the peripheral port pins to UART TX pin*/    
   RPOR10bits.RP21R = 3;   /*Assign U1TX to RP21*/  

   U1MODEbits.STSEL = 0; // 1-Stop bit
   U1MODEbits.PDSEL = 0; // No Parity, 8-Data bits
   U1MODEbits.ABAUD = 0; // Auto-Baud disabled
   U1MODEbits.BRGH = 0; // Standard-Speed mode
   U1BRG = BRGVAL; // Baud Rate setting for 9600

   //   U1STAbits.UTXISEL0 = 0;        // Interrupt after one TX character     is transmitted
  //    U1STAbits.UTXISEL1 = 0;
  IEC0bits.U1TXIE = 0;           // Disable UART TX interrupt
    IEC0bits.U1RXIE = 1;            // Enable the UART RX interrupt
  U1STAbits.URXISEL = 0;         // Interrupt after one RX character is   received

  U1MODEbits.UARTEN = 1; // Enable UART
  U1STAbits.UTXEN = 1; // Enable UART TX

  /* Wait at least 105 microseconds (1/9600) before sending first char */
  DELAY_105uS
  //U1TXREG = 'a'; // Transmit one character
  }

Código de transmisión de Uart:

int uart1_DebugSerial_send(char *buf)
 {
    int len, buf_length;

   buf_length = strlen(buf);
   len = buf_length;

   while(buf_length--)
   {
       while(!(U1STAbits.TRMT));   //stay here until the UXTSR register is empty
       U1TXREG = *buf++;
    }

   return len;

}

UART Receive ISR

void __attribute__((__interrupt__, no_auto_psv)) _U1RXInterrupt(void)
 {
   static char str[50];
  unsigned char RxChar;
  static uint8_t uart_header_rcvd_flag = false;
  static uint8_t i = 0;

  IFS0bits.U1RXIF = 0;    /*Clear the Rx interrupt flag*/
  /* Check for receive errors */
  if(U1STAbits.FERR == 1)
   {

//          continue;
  }
  /* Must clear the overrun error to keep UART receiving */
  if(U1STAbits.OERR == 1)
  {

    U1STAbits.OERR = 0;
  //        continue;
}
/* Get the data */
if(U1STAbits.URXDA == 1)
{

    RxChar = U1RXREG;

}
/*If the Received char is 0xAA and Header received flag is false, then
 start receiving the packet*/

if (RxChar == 0xAA && uart_header_rcvd_flag == false)
{

    uart_header_rcvd_flag = true;
    i = 0;
}
/*If the Packet reception is already commenced, then check for the PKT_SIZE
 to stop populating the host_rx_buf
 */
if (uart_header_rcvd_flag == true)
{

    host_rx_buf[i++] = RxChar;

    if (i == HOST_PKT_SIZE)
    {

        host_pkt_rcvd_flag = true;
        uart_header_rcvd_flag = false;
    }
}    
 }

Por favor, ayúdame, donde voy mal

Gracias de antemano

    
pregunta Pradeep Dayama

2 respuestas

1
  

los datos transmitidos a través del host y recibidos por pic no coinciden

Compruebe si las velocidades en baudios para el transmisor y el receptor son las mismas.

  

También observé un problema extraño: cuando transmito por primera vez que los datos no se reciben completamente, solo se reciben 2 bytes de datos, en donde cuando transmito la segunda vez, obtengo un error de ejecución SUPERIOR.

Como indica el tipo de error. Su búfer está desbordado. Lo que significa que no está leyendo el búfer más rápido de lo que llegan los nuevos datos. Verifique el tamaño del búfer del receptor y use el control de flujo de hardware o software de manera apropiada. Mirando su ISR, reduzca la cantidad de operaciones realizadas en ISR para evitar el desbordamiento y seguramente debe funcionar. Hacer todos los controles de procesamiento en main ().

    
respondido por el Akshay Immanuel D
0

Hola, aquí está el fragmento de código

uart ISR

void __attribute__((__interrupt__, no_auto_psv)) _U1RXInterrupt(void)
{

   Receive_flag = 1;

   receive_buffer[buffer_wr_address] = U1RXREG;
   buffer_wr_address++;

   IFS0bits.U1RXIF = 0;    /*Clear the Rx interrupt flag*/ 

}

código fuente de Uart

void uart_receive(void)
{
    while ( buffer_rd_address != buffer_wr_address )
    {
        switch (uart_state)
        {
            case RECEIVE_HEADER :        
            if (receive_buffer[buffer_rd_address] == HEADER_BYTE)
            {
                uart_state = RECEIVE_COMMAND;
            }
            break;

        case RECEIVE_COMMAND :            
            uart_state = RECEIVE_DATA_1;
            break;

        case RECEIVE_DATA_1 :           
            uart_state = RECEIVE_DATA_2;
            break;

        case RECEIVE_DATA_2 :          
            uart_state = RECEIVE_DATA_3;
            break;

        case RECEIVE_DATA_3 :            
           /*enter the code to process the data received*/


            buffer_rd_address = 0;
            buffer_wr_address = 0;
            uart_state = RECEIVE_HEADER;
            Receive_flag = 0;
            return;

        default :
            uart_state = RECEIVE_HEADER;
            break;
    }
    buffer_rd_address++;
}

Receive_flag = 0;

}

    
respondido por el Pradeep Dayama

Lea otras preguntas en las etiquetas