Embedded C, Renesas RL78, передача данных - PullRequest
Новая
       64

Embedded C, Renesas RL78, передача данных

1 голос
/ 18 октября 2019

Я пытаюсь отправить 10-битные данные из MCU Renesas в другой MCU. Я использую 10-битный АЦП, поэтому данные датчика представлены в 10-битном формате, а затем они сохраняются в 2-байтовой переменной. Например:

тип переменной: - 

uint8_t data[2] = { 97, 65 }; 
uint8_t g_uart0_rx_buffer = 0U; 
uint8_t g_uart0_rx_error = 0U; 
volatile uint8_t * gp_uart0_tx_address; 
volatile uint16_t g_uart0_tx_count; 
uint16_t g_result_buffer = 0U; 
uint8_t check; 
uint8_t check_new = 8; 
int old_var = 0

uint8_t data[2] = {97 , 65}

Работает нормально, когда я пытаюсь отправить целые два байта;код приведен ниже: 

R_ADC_Get_Result(&g_result_buffer);
old_var=g_result_buffer;
data[1] = old_var;
data[0] = (old_var >> 8);
g_uart0_tx_end = R_UART0_Send((uint8_t *) data, 2u);

И R_UART0_Send() определяется как: 

MD_STATUS R_UART0_Send(uint8_t * const tx_buf, uint16_t tx_num)
{
    MD_STATUS status = MD_OK;

    if (tx_num < 1U)
    {
        status = MD_ARGERROR;
    }
    else
    {
        gp_uart0_tx_address = tx_buf;     //i.e volatile uint8_t * gp_uart0_tx_address;
        g_uart0_tx_count = tx_num;        //i.e volatile uint16_t  g_uart0_tx_count; 
        STMK0 = 1U;    /* disable INTST0 interrupt */
        TXD0 = *gp_uart0_tx_address;
        gp_uart0_tx_address++;
        g_uart0_tx_count--;
        STMK0 = 0U;    /* enable INTST0 interrupt */
    }

    return (status);
}

Эта часть работает нормально, и я получаю данные из UART и выполняю свою дальнейшую операцию.

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

Я храню 10-битные данные в data[2], поэтому восемь бит хранятся в data[1], а два бита хранятся в data[0]. data[0] может быть 0, 1, 2 или 3. На data[0] существует условие, что, если оно равно 01, MCU будет передавать только один байт (т. Е. data[1]) вместо того, чтобы отправлять все два байта все время. Это продолжается до тех пор, пока data[0] не получит какой-либо другой номер (например, 0, 2 или 3). Это я делаю в приведенном ниже коде. 

R_ADC_Get_Result(&g_result_buffer);
old_var=g_result_buffer;
data[1] = old_var;
data[0] = (old_var >> 8);
check = data[0];

if (check!=check_new) // check_new is declared globally with random variable
{
    if (check == 01)
    {
        //check_val = 'i';
        //g_uart0_tx_end = R_UART0_Send1((char) check_val, 1u);
        g_uart0_tx_end = R_UART0_Send((uint8_t *) data, 2u);
        check_new = check;
        //memset(data, 0, 2);
    }

    if (check == 02)
    {
        //check_val = 'j';
        //g_uart0_tx_end = R_UART0_Send1((char) check_val, 1u);
        g_uart0_tx_end = R_UART0_Send((uint8_t *) data, 2u);
        check_new = check;
        //memset(data, 0, 2);
    }

    if (check == 03)
    {
        //check_val = 'k';
        //g_uart0_tx_end = R_UART0_Send1((char) check_val, 1u);
        g_uart0_tx_end = R_UART0_Send((uint8_t *) data, 2u);
        check_new = check;
        //memset(data, 0, 2);
    }

    if (check == 00)
    {
        //check_val = 'l';
        //g_uart0_tx_end = R_UART0_Send1((char) check_val, 1u);
        g_uart0_tx_end = R_UART0_Send((uint8_t *) data, 2u);
        check_new = check;
        //memset(data, 0, 2);
    }

    //g_uart0_tx_end = R_UART0_Send((uint8_t *) data, 2u);
}
else
{
    g_uart0_tx_end = R_UART0_Send((uint8_t *) data+1, 1u);
    //memset(data, 0, 2);
}

Где R_UART0_Send() определяется с помощью: 

MD_STATUS R_UART0_Send(uint8_t * const tx_buf, uint16_t tx_num)
{
    MD_STATUS status = MD_OK;

    if (tx_num < 1U)
    {
        status = MD_ARGERROR;
    }
    else
    {
        if (tx_num == 1U){
        gp_uart0_tx_address = tx_buf;
        g_uart0_tx_count = tx_num;
        STMK0 = 1U;    /* disable INTST0 interrupt */
        TXD0 = *gp_uart0_tx_address;
        gp_uart0_tx_address++;
        g_uart0_tx_count--;
        STMK0 = 0U;    /* enable INTST0 interrupt */
        }
        else if (tx_num == 2U){
        gp_uart0_tx_address = tx_buf;
        g_uart0_tx_count = tx_num;
        STMK0 = 1U;    /* disable INTST0 interrupt */
        TXD0 = *gp_uart0_tx_address;
        gp_uart0_tx_address++;
        g_uart0_tx_count--;
        STMK0 = 0U;    /* enable INTST0 interrupt */
        }
    }

    return (status);
}

Первоначально двухбайтовые данные верны, и как только они переходят в условиедля отправки однобайтовых данных это все еще правильно. Но когда условие меняется и он снова начинает отправлять двухбайтовые данные, он начинает отправлять data[0] неправильно. Позвольте мне объяснить это на примере:

data[0] должно быть 0, 1, 2 или 3.

Итак, первые двухбайтовые данные1,135, поэтому он сохраняет data[0] (т.е. 1) в переменной check_new и проверяет data[0] на наличие изменений. До этого он отправляет только data[1].

Теперь изначально он отправляет 1,135, а затем отправляет только data[1], например, 145, 225, 254, 65, 69, 67 и т. Д.

Теперь, если он получает data[0] = 2, он должен отправить 2,data[1], но в это время он начинает отправлять data[0] = 65 или data[0] = 165, иличто-то еще, но не 0, 1, 2 или 3. Можете ли вы помочь мне, что я делаю неправильно в этом. Возможно я не увеличиваю адрес или что-то еще.

...