Unable to use receive the UART data through interrupt.

 I am beginner, I want to receive the uart data through the ISR of receive data and my normal code has to be in flow. when I tried sample code it donesn't have ISR routin3, it failed my expection. Please helo me ASAO

  • Hi Hiroshi,

    Can you provide more information like the device that you are using? and the sample code that you've mentioned? Thanks!

    JB
    RenesasRulz Forum Moderator
  • In reply to JB:

    Hello JB,
    I am using RL78 g13.. Thanks i found the solution for Uart RX interrupt.
  • In reply to Hiroshi:

    Hi Hiroshi!

    Do let me know please. I too need to receive the data via UART0. In my case same controller (RL78/G13) and at UART0, ZigBee is interfaced. Please revert back asap.
  • In reply to SUNDAR:

    Hello Sundar,
    /*code*/
    uint8_t buffer[5]="Hello";
    extern unsigned char send, receive;
    uint8_t read[10];
    /* End user code. Do not edit comment generated here */
    void R_MAIN_UserInit(void);

    /***********************************************************************************************************************
    * Function Name: main
    * Description : This function implements main function.
    * Arguments : None
    * Return Value : None
    ***********************************************************************************************************************/
    void main(void)
    {
    R_MAIN_UserInit();
    /* Start user code. Do not edit comment generated here */
    //P1_bit.no7 = 1;
    //R_TAU0_Channel0_Start();
    R_UART0_Start();
    R_UART0_Send(&buffer, sizeof(buffer));
    while(send==0);
    send=0;
    while (1U)
    {
    R_UART0_Receive(&read, sizeof(read));
    while(receive==0);
    receive=0;

    }
    /* End user code. Do not edit comment generated here */
    }
    ////////////////////////////////////////////////

    Serial.c
    /***********************************************************************************************************************
    * DISCLAIMER
    * This software is supplied by Renesas Electronics Corporation and is only intended for use with Renesas products.
    * No other uses are authorized. This software is owned by Renesas Electronics Corporation and is protected under all
    * applicable laws, including copyright laws.
    * THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIESREGARDING THIS SOFTWARE, WHETHER EXPRESS, IMPLIED
    * OR STATUTORY, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
    * NON-INFRINGEMENT. ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY
    * LAW, NEITHER RENESAS ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE FOR ANY DIRECT,
    * INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR
    * ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
    * Renesas reserves the right, without notice, to make changes to this software and to discontinue the availability
    * of this software. By using this software, you agree to the additional terms and conditions found by accessing the
    * following link:
    * www.renesas.com/disclaimer
    *
    * Copyright (C) 2011, 2015 Renesas Electronics Corporation. All rights reserved.
    ***********************************************************************************************************************/

    /***********************************************************************************************************************
    * File Name : r_cg_serial_user.c
    * Version : CodeGenerator for RL78/G13 V2.03.02.01 [15 May 2015]
    * Device(s) : R5F100LE
    * Tool-Chain : CCRL
    * Description : This file implements device driver for Serial module.
    * Creation Date: 01-Sep-16
    ***********************************************************************************************************************/

    /***********************************************************************************************************************
    Includes
    ***********************************************************************************************************************/
    #include "r_cg_macrodriver.h"
    #include "r_cg_serial.h"
    /* Start user code for include. Do not edit comment generated here */
    /* End user code. Do not edit comment generated here */
    #include "r_cg_userdefine.h"

    /***********************************************************************************************************************
    Pragma directive
    ***********************************************************************************************************************/
    #pragma interrupt r_uart0_interrupt_send(vect=INTST0)
    #pragma interrupt r_uart0_interrupt_receive(vect=INTSR0)
    /* Start user code for pragma. Do not edit comment generated here */
    /* End user code. Do not edit comment generated here */

    /***********************************************************************************************************************
    Global variables and functions
    ***********************************************************************************************************************/
    extern volatile uint8_t * gp_uart0_tx_address; /* uart0 send buffer address */
    extern volatile uint16_t g_uart0_tx_count; /* uart0 send data number */
    extern volatile uint8_t * gp_uart0_rx_address; /* uart0 receive buffer address */
    extern volatile uint16_t g_uart0_rx_count; /* uart0 receive data number */
    extern volatile uint16_t g_uart0_rx_length; /* uart0 receive data length */
    /* Start user code for global. Do not edit comment generated here */
    unsigned char send, receive;
    /* End user code. Do not edit comment generated here */

    /***********************************************************************************************************************
    * Function Name: r_uart0_interrupt_receive
    * Description : This function is INTSR0 interrupt service routine.
    * Arguments : None
    * Return Value : None
    ***********************************************************************************************************************/
    static void __near r_uart0_interrupt_receive(void)
    {
    uint8_t rx_data;
    uint8_t err_type;

    err_type = (uint8_t)(SSR01 & 0x0007U);
    SIR01 = (uint16_t)err_type;

    if (err_type != 0U)
    {
    r_uart0_callback_error(err_type);
    }

    rx_data = RXD0;

    if (g_uart0_rx_length > g_uart0_rx_count)
    {
    *gp_uart0_rx_address = rx_data;
    gp_uart0_rx_address++;
    g_uart0_rx_count++;

    if (g_uart0_rx_length == g_uart0_rx_count)
    {
    r_uart0_callback_receiveend();
    }
    }
    else
    {
    r_uart0_callback_softwareoverrun(rx_data);
    }
    }

    /***********************************************************************************************************************
    * Function Name: r_uart0_interrupt_send
    * Description : This function is INTST0 interrupt service routine.
    * Arguments : None
    * Return Value : None
    ***********************************************************************************************************************/
    static void __near r_uart0_interrupt_send(void)
    {
    if (g_uart0_tx_count > 0U)
    {
    TXD0 = *gp_uart0_tx_address;
    gp_uart0_tx_address++;
    g_uart0_tx_count--;
    }
    else
    {
    r_uart0_callback_sendend();
    }
    }

    /***********************************************************************************************************************
    * Function Name: r_uart0_callback_receiveend
    * Description : This function is a callback function when UART0 finishes reception.
    * Arguments : None
    * Return Value : None
    ***********************************************************************************************************************/
    static void r_uart0_callback_receiveend(void)
    {
    /* Start user code. Do not edit comment generated here */
    receive=1;
    /* End user code. Do not edit comment generated here */
    }

    /***********************************************************************************************************************
    * Function Name: r_uart0_callback_softwareoverrun
    * Description : This function is a callback function when UART0 receives an overflow data.
    * Arguments : rx_data -
    * receive data
    * Return Value : None
    ***********************************************************************************************************************/
    static void r_uart0_callback_softwareoverrun(uint16_t rx_data)
    {
    /* Start user code. Do not edit comment generated here */
    /* End user code. Do not edit comment generated here */
    }

    /***********************************************************************************************************************
    * Function Name: r_uart0_callback_sendend
    * Description : This function is a callback function when UART0 finishes transmission.
    * Arguments : None
    * Return Value : None
    ***********************************************************************************************************************/
    static void r_uart0_callback_sendend(void)
    {
    /* Start user code. Do not edit comment generated here */
    send=1;
    /* End user code. Do not edit comment generated here */
    }

    /***********************************************************************************************************************
    * Function Name: r_uart0_callback_error
    * Description : This function is a callback function when UART0 reception error occurs.
    * Arguments : err_type -
    * error type value
    * Return Value : None
    ***********************************************************************************************************************/
    static void r_uart0_callback_error(uint8_t err_type)
    {
    /* Start user code. Do not edit comment generated here */
    /* End user code. Do not edit comment generated here */
    }

    /* Start user code for adding. Do not edit comment generated here */
    /* End user code. Do not edit comment generated here */
  • In reply to Hiroshi:

    Let me implement this & come back to you. Thank you very much!
  • In reply to Hiroshi:

    Hi Hiroshi!

    I request you to clarify few things. Here are those:

    1) The function static void r_uart0_callback_softwareoverrun(uint16_t rx_data) has argument with 16 bit as data type, whereas rx_data is only 8 bit; doesn't it conflict?

    2) In the following lines of code:
    err_type = (uint8_t)(SSR01 & 0x0007U);
    SIR01 = (uint16_t)err_type;

    SSR01 is ANDed of 0x0007U. Serial Status Register 01 (Unit 0 with Channel 1) will have bit-wise operation in the following form:
    0000 0000 0000 0XXX
    ANDed with
    0000 0000 0000 0111

    Now is the the last three bits are
    a) Framing error
    b) Parity error
    c) Overrun error

    For Framing error, the conditions mean as follows:
    <Clear condition>
    • 1 is written to the FECTmn bit of the SIRmn register.
    <Set condition>
    • A stop bit is not detected when UART reception ends.

    For Parity error, the conditions mean as follows:
    <Clear condition>
    • 1 is written to the PECTmn bit of the SIRmn register.
    <Set condition>
    • The parity of the transmit data and the parity bit do not match when UART reception ends (parity error).
    • No ACK signal is returned from the slave channel at the ACK reception timing during I2C transmission (ACK is
    not detected).

    For Overrun error, the conditions mean as follows:
    <Clear condition>
    • 1 is written to the OVCTmn bit of the SIRmn register.
    <Set condition>
    • Even though receive data is stored in the SDRmn register, that data is not read and transmit data or the next
    receive data is written while the RXEmn bit of the SCRmn register is set to 1 (reception or transmission and
    reception mode in each communication mode).
    • Transmit data is not ready for slave transmission or transmission and reception in CSI mode.

    So my question is when do we check these errors to AND them?

    3) Now the most important question, in the following line of code -
    R_UART0_Receive(&read, sizeof(read));

    read is declared as follows:
    uint8_t read[10];

    When does read[] gets populated? What are we reading? What do we do after reading? Will this happen without any interrupt like some continuous flow of data?

    4) What is the purpose of the following lines of codes?
    R_UART0_Send(&buffer, sizeof(buffer));
    while(send==0);
    send=0;

    I mean is it just to send something and then be in while() to receive?

    5) Few other things I would like to know is:
    Hardware User Manual says, we need to use Odd numbered Channel for reception and Even numbered for transmission. Hope you have done that.
    Other than the above, what are clock settings you have configured?
    Do we have to configure interrupts as such or INTSR0 will be generated on it's own and is independent of other interrupts?
    With respect to device at UART, do we have to make settings on the device to make Renesas read the UART string?
    Have you used Watchdog timer?
    What are the baud rates? Have you calculated them? What was the value put in SDR01 to set the Baud Rate? In any case both the communicating devices should be with same baud rate but does the rate hinder the transmission/reception in some cases?

    Last but the least - I have not been able to get the result as I wanted. If possible do help me out.