
/***********************************************************************************************************************
* DISCLAIMER ... (생략: 원본 그대로)
***********************************************************************************************************************/

/***********************************************************************************************************************
* File Name    : r_main.c
* Version      : CodeGenerator for RL78/F14 V2.03.07.02 [08 Nov 2021]
* Device(s)    : R5F10PPJ
* Tool-Chain   : CCRL
* Description  : main + UART protocol handler
* Creation Date: 2026-01-29
***********************************************************************************************************************/

#include "r_cg_macrodriver.h"
#include "r_cg_cgc.h"
#include "r_cg_port.h"
#include "r_cg_serial.h"

/* Start user code for include. Do not edit comment generated here */
#include "common.h"
#include "dipSwitch.h"
#include "gatectrl.h"
#include <string.h>
#include <ctype.h>
#include <stddef.h>
#include <stdio.h>
#include <r_cg_port.h>
/* End user code. Do not edit comment generated here */
#include "r_cg_userdefine.h"

/* =========================
 * Config
 * ========================= */
#define CMD_MAX 529
#define UART_RX_BUF_SIZE  256   /* 네 프로젝트 값에 맞춰 유지 */
#define RS485_BRIDGE_FIFO_SZ 256

/* =========================
 * UART RX Buffers
 * ========================= */
volatile uint8_t  uart_rx_done = 0;
volatile uint8_t  uart_rx_index = 0;
volatile uint8_t  uart_rx_buffer[UART_RX_BUF_SIZE] = {0};
volatile uint16_t uart_rx_length = 0;

volatile uint8_t  rs485_rx_done = 0;
volatile uint8_t  rs485_rx_index = 0;
volatile uint8_t  rs485_rx_buffer[UART_RX_BUF_SIZE] = {0};
volatile uint16_t rs485_rx_length = 0;

/* RS485 bridge flags */
volatile uint8_t g_rs485_bridge_active = 0;
volatile uint8_t g_rs485_bridge_done   = 0;

/* (0~31) */
uint8_t g_fixed_addr = 0;

/* =========================
 * Driver globals (Renesas)
 * ========================= */
extern volatile uint16_t g_uart1_tx_count;  /* UART1 TX 진행 카운트 */
extern volatile uint16_t g_uart0_tx_count;  /* UART0 TX 진행 카운트 */

/* =========================
 * RS485 Bridge FIFO
 * ========================= */
static volatile uint8_t s_rb_fifo[RS485_BRIDGE_FIFO_SZ];
static volatile uint8_t s_rb_head = 0;
static volatile uint8_t s_rb_tail = 0;

void RS485_Bridge_Push(uint8_t b)
{
    uint8_t next = (uint8_t)(s_rb_head + 1);
    if (next >= RS485_BRIDGE_FIFO_SZ) next = 0;

    /* FIFO full -> drop oldest (tail++) */
    if (next == s_rb_tail) {
        uint8_t t = (uint8_t)(s_rb_tail + 1);
        if (t >= RS485_BRIDGE_FIFO_SZ) t = 0;
        s_rb_tail = t;
    }

    s_rb_fifo[s_rb_head] = b;
    s_rb_head = next;
}

static void RS485_Bridge_ResetFifo(void)
{
    s_rb_head = 0;
    s_rb_tail = 0;
}

/* =========================
 * ? PC(UART1) Safe TX (중요)
 * - 로컬 버퍼 금지
 * - 항상 전역 버퍼로 복사 후 R_UART1_Send
 * ========================= */
static uint8_t g_uart1_txbuf[128];

static void UART1_WaitTxIdle(void)
{
    unsigned long guard = 0;
    while (g_uart1_tx_count != 0U) {
        if (guard++ > 3000000UL) break; /* 무한루프 방지 */
    }
}

static void UART1_SendBytes_Safe(const uint8_t *data, uint16_t len)
{
    if (data == 0 || len == 0) return;

    UART1_WaitTxIdle();

    if (len > (uint16_t)sizeof(g_uart1_txbuf))
        len = (uint16_t)sizeof(g_uart1_txbuf);

    memcpy(g_uart1_txbuf, data, len);

    R_UART1_Send(g_uart1_txbuf, len);

    UART1_WaitTxIdle();
}


static void UART1_SendString_Safe(const char *s)
{
    uint16_t len;

    if (s == 0) return;

    UART1_WaitTxIdle();

    len = (uint16_t)strlen(s);
    if (len >= (uint16_t)sizeof(g_uart1_txbuf))
        len = (uint16_t)(sizeof(g_uart1_txbuf) - 1);

    memcpy(g_uart1_txbuf, s, len);
    g_uart1_txbuf[len] = '\0';

    R_UART1_Send(g_uart1_txbuf, len);

    UART1_WaitTxIdle();
}

/* =========================
 * RS485 Bridge Drain -> PC
 * - uart1_send_string(out) 같은 1바이트 문자열 송신 금지
 * - UART1_SendBytes_Safe로 한 바이트씩이라도 "안전하게" 전송
 * ========================= */
static void RS485_Bridge_DrainToPC(void)
{
    uint16_t n = 0;

    /* UART1이 TX중이면 다음 루프에서 */
    if (g_uart1_tx_count != 0U) return;

    /* FIFO -> 임시 버퍼에 최대 64바이트까지 모아서 한 번에 전송 */
    while (s_rb_tail != s_rb_head && n < 64U) {
        g_uart1_txbuf[n++] = s_rb_fifo[s_rb_tail];
        s_rb_tail++;
        if (s_rb_tail >= RS485_BRIDGE_FIFO_SZ) s_rb_tail = 0;
    }

    if (n > 0) {
        R_UART1_Send(g_uart1_txbuf, n);
    }
}

/* =========================
 * Helpers
 * ========================= */
static unsigned char hex2byte(char h, char l)
{
    unsigned char hi, lo;
    if (h >= 'a' && h <= 'f') h -= 32;
    if (l >= 'a' && l <= 'f') l -= 32;
    hi = (h >= 'A') ? (unsigned char)(h - 'A' + 10) : (unsigned char)(h - '0');
    lo = (l >= 'A') ? (unsigned char)(l - 'A' + 10) : (unsigned char)(l - '0');
    return (unsigned char)((hi << 4) | lo);
}

/* =========================
 * Prefix mode
 * ========================= */
typedef enum {
    PREFIX_NONE = 0,
    PREFIX_CAL,
    PREFIX_EOL
} PrefixMode;

static PrefixMode s_prefix_mode = PREFIX_NONE;

/* =========================
 * parse x-prefix: xNNc_001011:...
 * ========================= */
static int parse_x_prefix(const char *s, int len,
                          uint8_t *addr, uint8_t *ch,
                          char *mode, uint8_t *hash_on, uint8_t *anaout_on, uint8_t *check_on, int *payload_pos)
{
    if (len < 8) return 0;
    if (!(s[0] == 'x' || s[0] == 'X')) return 0;

    if (!isdigit((unsigned char)s[1]) || !isdigit((unsigned char)s[2])) return -1;

    if      (s[3] == 'c' || s[3] == 'C') *mode = 'C';
    else if (s[3] == 'e' || s[3] == 'E') *mode = 'E';
    else return -1;

    if (s[4] != '_') return -1;
    if (!isdigit((unsigned char)s[5]) || !isdigit((unsigned char)s[6]) || !isdigit((unsigned char)s[7])) return -1;

    *addr = (uint8_t)((s[1] - '0') * 10 + (s[2] - '0'));
    *ch   = (uint8_t)((s[5] - '0') * 100 + (s[6] - '0') * 10 + (s[7] - '0'));

    /* prefix only: x01c_001 */
    if (len == 8) {
        *payload_pos = len;
        return 1;
    }

    /* payload: x01c_001:... */
    if (s[8] == ':') {
        *payload_pos = 9;
        return 1;
    }

    /* flags: x01c_001011 or x01c_001011:... */
    if (len >= 11 &&
        (s[8]  == '0' || s[8]  == '1') &&
        (s[9]  == '0' || s[9]  == '1') &&
        (s[10] == '0' || s[10] == '1'))
    {
        *hash_on   = (uint8_t)(s[8]  - '0');
        *anaout_on = (uint8_t)(s[9]  - '0');
        *check_on  = (uint8_t)(s[10] - '0');

        if (len == 11) { *payload_pos = 11; return 1; }
        if (len >= 12 && s[11] == ':') { *payload_pos = 12; return 1; }

        return -1;
    }

    return -1;
}

/* =========================
 * Print routing
 * ========================= */
typedef enum {
    CMD_SRC_PC = 0,
    CMD_SRC_RS485 = 1
} CmdSource;

/* ? PC 출력은 무조건 Safe로 */
static void OUT_PRINT(CmdSource src, const char *s)
{
    if (src == CMD_SRC_PC) {
        UART1_SendString_Safe(s);
    } else {
        /* RS485_PRINT는 네 프로젝트 기존 함수(보통 UART0 TX) */
        RS485_PRINT(s);
    }
}


static void send_end_response(void)
{
    OUT_PRINT(CMD_SRC_PC, "<end>\r\n");
}
/* =========================
 * xNNv command
 * ========================= */
static int parse_x_v_cmd(const char *s, int len, uint8_t *addr)
{
    if (len != 4) return 0;
    if (!(s[0] == 'x' || s[0] == 'X')) return 0;
    if (!isdigit((unsigned char)s[1]) || !isdigit((unsigned char)s[2])) return 0;
    if (!(s[3] == 'v' || s[3] == 'V')) return 0;

    *addr = (uint8_t)((s[1] - '0') * 10 + (s[2] - '0'));
    return 1;
}
static void send_n_response(uint8_t addr)
{
    char resp[8];
    resp[0] = 'N';
    resp[1] = (char)('0' + (addr / 10));
    resp[2] = (char)('0' + (addr % 10));
    resp[3] = '\r';
    resp[4] = '\n';
    resp[5] = '\0';
    OUT_PRINT(CMD_SRC_PC, resp);
}

/* ? 여기서도 OUT_PRINT가 Safe를 타므로 깨짐 없음 */
static void send_v_response(CmdSource src, uint8_t addr)
{
    char resp[8];

    resp[0] = 'V';
    resp[1] = (char)('0' + (addr / 10));
    resp[2] = (char)('0' + (addr % 10));
    resp[3] = '\r';
    resp[4] = '\n';
    resp[5] = '\0';
    
    if (src == CMD_SRC_RS485) {
        delay_us(300);   // 200~500us 권장 (환경 따라 조정)
    }

    OUT_PRINT(src, resp);
}

/* =========================
 * RS485 scan: xNNv\r\n
 * ========================= */
static void scan_one_addr_rs485(uint8_t addr)
{
    char cmdline[8];

    if (addr == 0) return;

    cmdline[0] = 'x';
    cmdline[1] = (char)('0' + (addr / 10));
    cmdline[2] = (char)('0' + (addr % 10));
    cmdline[3] = 'v';
    cmdline[4] = '\r';
    cmdline[5] = '\n';
    cmdline[6] = '\0';

    // --- bridge 준비 ---
    g_rs485_bridge_active = 1;
    g_rs485_bridge_done   = 0;
    RS485_Bridge_ResetFifo();

    // RX arm
    rs485_rx_done = 0;
    rs485_rx_index = 0;
    rs485_rx_length = 0;
    R_UART0_Receive((uint8_t*)&rs485_rx_buffer[0], 1);

    // ? (A) 이전 송신이 남아있으면 정리
    UART0_WaitTxDone_Us(5000);

    // ? (B) 송신
    RS485_PRINT(cmdline);

    // ? (C) “진짜 송신 끝 + RX 전환”까지 대기
    UART0_WaitTxDone_Us(5000);

    // ? (D) 턴어라운드 여유 (보드/트랜시버 따라 200~500us 권장)
    delay_us(300);

    // ? (E) 응답 대기 (예: 20ms)
    {
        uint32_t wait_us = 80000;
        while (!g_rs485_bridge_done && wait_us >= 50) {
            RS485_Bridge_DrainToPC();
            delay_us(50);
            wait_us -= 50;
        }
        RS485_Bridge_DrainToPC();
    }

    g_rs485_bridge_active = 0;

    if (!g_rs485_bridge_done) {
        send_n_response(addr);
    }

    // 다음을 위해 RX 재arm
    rs485_rx_done = 0;
    rs485_rx_index = 0;
    rs485_rx_length = 0;
    R_UART0_Receive((uint8_t*)&rs485_rx_buffer[0], 1);
}

/* =========================
 * Build line from rx buffer
 * ========================= */
static int build_line_from_rx(const volatile uint8_t *rx_buf, int rx_len,
                              char *out, int out_sz)
{
    int i, idx = 0;

    if (rx_len < 0) rx_len = 0;
    if (rx_len > out_sz - 1) rx_len = out_sz - 1;

    for (i = 0; i < rx_len && idx < out_sz - 1; i++) {
        char c = (char)rx_buf[i];
        if (c == '\r') continue;
        if (c == '\n') break;
        out[idx++] = c;
    }
    out[idx] = '\0';
    return idx;
}

/* =========================
 * Protocol detect
 * ========================= */
typedef enum {
    PROTOCOL_I2CT,
    PROTOCOL_OWIT,
    PROTOCOL_I2CW,
    PROTOCOL_I2CR,
    PROTOCOL_OWIW,
    PROTOCOL_OWIR,
    PROTOCOL_UNKNOWN
} ProtocolType;

static ProtocolType detect_protocol(char header1, char header2)
{
    if (header1 == 'I' && header2 == 'W') return PROTOCOL_I2CW;
    if (header1 == 'I' && header2 == 'R') return PROTOCOL_I2CR;
    if (header1 == 'O' && header2 == 'W') return PROTOCOL_OWIW;
    if (header1 == 'O' && header2 == 'R') return PROTOCOL_OWIR;
    return PROTOCOL_UNKNOWN;
}

static void cmd_unknown(const unsigned char *d, unsigned int len)
{
    (void)d; (void)len;
    OUT_PRINT(CMD_SRC_PC, "Unknown cmd\r\n");
    delay(100000);
}

/* 여기는 네 프로젝트 기존 함수들 호출 */
static void process_cmd(ProtocolType protocol, uint8_t id,
                        const unsigned char *data, unsigned int len)
{
    switch (protocol) {
        case PROTOCOL_I2CT: I2C_T_Command_Mode_receiveData(data, (uint8_t)len, id); break;
        case PROTOCOL_OWIT: OWI_T_CommandMode(data, (uint8_t)len, id); break;
        case PROTOCOL_I2CW: I2C_Command_Mode_receiveData(data, (uint8_t)len, id); break;
        case PROTOCOL_I2CR: I2C_Command_Mode_Send((uint8_t)len, id); break;
        case PROTOCOL_OWIW: OWI_CommandMode(data, (uint8_t)len, id); break;
        case PROTOCOL_OWIR: OWI_ReadBytesAndPrint(len, id); break;
        default:            cmd_unknown(data, len); break;
    }
}

static void process_cmd_by_prefix(PrefixMode pm,
                                  ProtocolType protocol, uint8_t id,
                                  const unsigned char *data, unsigned int len)
{
    (void)pm;
    process_cmd(protocol, id, data, len);
}

/* =========================
 * Main line processor
 * ========================= */
static void process_one_line(CmdSource src, const volatile uint8_t *rx_buf, uint16_t rx_len)
{
    char line[UART_RX_BUF_SIZE];

    uint8_t v_addr = 0;
    int is_v = 0;
    uint8_t a = 0;

    int i;
    int idx = 0;
    int pos = 2;

    ProtocolType proto;
    uint8_t id;
    unsigned int byte_len;
    uint8_t cmd[CMD_MAX];
    unsigned int k = 0;

    char orig_line[UART_RX_BUF_SIZE];
    int  orig_len = 0;

    s_prefix_mode = PREFIX_NONE;

    idx = build_line_from_rx(rx_buf, (int)rx_len, line, (int)sizeof(line));
    if (idx <= 0) return;
    
    if (src == CMD_SRC_RS485) {
        if (!(line[0] == 'x' || line[0] == 'X')) return; // V/N/Err 응답 등 무시
    }

    /* =========================
     * 1) xNNv 처리 (x-prefix보다 먼저)
     * ========================= */
    is_v = parse_x_v_cmd(line, idx, &v_addr);
    if (is_v) {

        if (v_addr > 31) { OUT_PRINT(src, "Err:addr_range\r\n"); return; }

        /* 보드1(addr=0) + PC에서 x00v => 00~31 스캔 */
        if (g_fixed_addr == 0 && src == CMD_SRC_PC && v_addr == 0) {

            /* 자기 자신(00) 응답 */
            send_v_response(CMD_SRC_PC, 0);

            /* 01~31 순차 조회 */
            for (a = 1; a <= 31; a++) {
                scan_one_addr_rs485(a);
            }
            return;
        }

        /* 그 외: 내 주소와 일치할 때만 응답 */
        if (v_addr == g_fixed_addr) {
            send_v_response(src, g_fixed_addr);
        }
        return;
    }

    /* RS485 중계용 원본 저장 */
    orig_len = idx;
    memcpy(orig_line, line, (size_t)orig_len);
    orig_line[orig_len] = '\0';

    /* =========================
     * 2) x-prefix 처리
     * ========================= */
    {
        uint8_t addr = 0;
        uint8_t ch = 0;
        char mode = 0;
        int payload_pos = 0;

        uint8_t hash_on = 0;
        uint8_t anaout_on = 0;
        uint8_t check_on = 1;

        int r = parse_x_prefix(line, idx, &addr, &ch, &mode, &hash_on, &anaout_on, &check_on, &payload_pos);

        if (r == -1) {
            OUT_PRINT(src, "Err:X_prefix\r\n");
            return;
        }

        if (r == 1) {
            if (addr > 31) { OUT_PRINT(src, "Err:addr_range\r\n"); return; }
            if (ch < 1 || ch > 20)   { OUT_PRINT(src, "Err:ch_range\r\n"); return; }

            /* addr mismatch */
            if (addr != g_fixed_addr) {

                /* 보드1(addr=0) + PC에서만 RS485 중계 */
                if (g_fixed_addr == 0 && src == CMD_SRC_PC) {

                    g_rs485_bridge_active = 1;
                    g_rs485_bridge_done   = 0;
                    RS485_Bridge_ResetFifo();

                    rs485_rx_done   = 0;
                    rs485_rx_index  = 0;
                    rs485_rx_length = 0;
                    R_UART0_Receive((uint8_t*)&rs485_rx_buffer[0], 1);

                    {
    		   	static char txbuf[UART_RX_BUF_SIZE + 4];
    			int n = orig_len;
	
    			if (n > (int)sizeof(txbuf) - 3) n = (int)sizeof(txbuf) - 3;

    			memcpy(txbuf, orig_line, (size_t)n);
    			txbuf[n++] = '\r';
    			txbuf[n++] = '\n';
    			txbuf[n]   = '\0';

    			/* (권장) UART0 TX busy면 잠깐 대기 후 송신 */
    			{
        		     unsigned long g = 0;
          		    while (g_uart0_tx_count != 0U) {
            		    if (g++ > 3000000UL) break; /* 무한 대기 방지 */
        		    }
    			}

    			RS485_PRINT(txbuf);
		    }

                    {
                        /* 시간 기반 대기(us)로 변경: OWT/I2C 동작 포함해서 여유 있게 */
			    uint32_t wait_us = 80000;   /* 80ms (필요시 50~120ms로 조정) */
			    
			    if (strstr(orig_line, ":OR") || strstr(orig_line, ":or")) {
					    wait_us = 3000000; // 300ms
					}

			    while (!g_rs485_bridge_done && wait_us >= 50U) {
			        RS485_Bridge_DrainToPC();
			        delay_us(50);
			        wait_us -= 50U;
			    }
			    RS485_Bridge_DrainToPC();
			    g_rs485_bridge_active = 0;

			    /* 다음을 위해 RX 재arm */
			    rs485_rx_done   = 0;
			    rs485_rx_index  = 0;
			    rs485_rx_length = 0;
			    R_UART0_Receive((uint8_t*)&rs485_rx_buffer[0], 1);

			    if (!g_rs485_bridge_done) {
			        OUT_PRINT(CMD_SRC_PC, "Err:rs485_timeout\r\n");
                        }
                    }
                }
                return; /* 슬레이브는 addr mismatch 무시 */
            }

            /* addr == g_fixed_addr: 로컬 처리(채널 선택 등) */
            if (mode == 'C') {
                s_prefix_mode = PREFIX_CAL;
                Cal_Init();
                Gate_SetByNum(ch, hash_on, anaout_on, check_on);
                GateCtrl_SelectChannel(ch);
            } else {
                s_prefix_mode = PREFIX_EOL;
                Eol_Init();
                Gate_SetByNum(ch, hash_on, anaout_on, check_on);
                GateCtrl_SelectChannel(ch);
            }

            /* prefix만 온 경우 / payload 처리 */
            {
                int rem = idx - payload_pos;

                if (rem <= 0) {
                    if (mode == 'E') {
                        OUT_PRINT(src, "<ACK>XE51\r\n");
                        return;
                    } else {
                        OUT_PRINT(src, "Err:CAL_need_payload\r\n");
                        return;
                    }
                }

                if (mode == 'E') {
                    OUT_PRINT(src, "Err:EOL_no_payload\r\n");
                    return;
                }

                for (i = 0; i < rem; i++) line[i] = line[payload_pos + i];
                line[rem] = '\0';
                idx = rem;
                pos = 2;
            }
        }
    }

    /* =========================
     * 3) 일반 커맨드 파싱
     * ========================= */
    if (idx < 7) { OUT_PRINT(src, "Err:short\r\n"); return; }

    {
        char h0 = (char)toupper((unsigned char)line[0]);
        char h1 = (char)toupper((unsigned char)line[1]);
        proto = detect_protocol(h0, h1);
    }
    if (proto == PROTOCOL_UNKNOWN) { OUT_PRINT(src, "Err:ID\r\n"); return; }

    if (line[pos] == 't' || line[pos] == 'T') {
        if (proto == PROTOCOL_OWIW) proto = PROTOCOL_OWIT;
        else if (proto == PROTOCOL_I2CW) proto = PROTOCOL_I2CT;
        pos++;
    }

    if (line[pos] == '_' || line[pos] == ':') pos++;

    if (pos + 1 >= idx) { OUT_PRINT(src, "Err:id_short\r\n"); return; }
    id = hex2byte(line[pos], line[pos + 1]);
    pos += 2;

    if (pos + 2 >= idx ||
        !(line[pos]   >= '0' && line[pos]   <= '9') ||
        !(line[pos+1] >= '0' && line[pos+1] <= '9') ||
        !(line[pos+2] >= '0' && line[pos+2] <= '9')) {
        OUT_PRINT(src, "Err:len_dec\r\n");
        return;
    }

    byte_len = (unsigned int)(100*(line[pos]-'0') + 10*(line[pos+1]-'0') + (line[pos+2]-'0'));
    pos += 3;

    if (byte_len > CMD_MAX) { OUT_PRINT(src, "Err:len_range\r\n"); return; }

    if (proto == PROTOCOL_OWIT || proto == PROTOCOL_I2CT ||
        proto == PROTOCOL_OWIW || proto == PROTOCOL_I2CW)
    {
        if (byte_len == 0) { OUT_PRINT(src, "Err:payload0\r\n"); return; }

        if ((int)(pos + (int)byte_len*2) > idx) { OUT_PRINT(src, "Err:len_mismatch\r\n"); return; }

        for (k = 0; k < byte_len; k++) {
            cmd[k] = hex2byte(line[pos + 2*k], line[pos + 2*k + 1]);
        }

        pos += (int)byte_len * 2;

        if (pos != idx) { OUT_PRINT(src, "Err:len_trail\r\n"); return; }
    }
    else if (proto == PROTOCOL_OWIR || proto == PROTOCOL_I2CR)
    {
        if (byte_len == 0) { OUT_PRINT(src, "Err:read_len_nonzero\r\n"); return; }
        if (pos != idx)    { OUT_PRINT(src, "Err:read_no_payload\r\n"); return; }
    }

    process_cmd_by_prefix(s_prefix_mode, proto, id, cmd, byte_len);
}

/* =========================
 * Main loop handler
 * ========================= */
void handle_uart_command_line(void)
{
    while (1)
    {
        /* 브릿지 중이면 RS485->PC 계속 드레인 */
        if (g_rs485_bridge_active) {
            RS485_Bridge_DrainToPC();
        }

        /* PC(UART1) */
        if (uart_rx_done)
        {
            uart_rx_done = 0;

            process_one_line(CMD_SRC_PC, uart_rx_buffer, uart_rx_length);

            uart_rx_index = 0;
            uart_rx_length = 0;
            R_UART1_Receive((uint8_t *)&uart_rx_buffer[uart_rx_index], 1);
        }

        /* RS485(UART0) */
        if (rs485_rx_done)
        {
            rs485_rx_done = 0;

            if (!g_rs485_bridge_active) {
                process_one_line(CMD_SRC_RS485, rs485_rx_buffer, rs485_rx_length);
            }

            rs485_rx_index = 0;
            rs485_rx_length = 0;
            R_UART0_Receive((uint8_t *)&rs485_rx_buffer[rs485_rx_index], 1);
        }
        else
        {
		
        }
    }
}

/* =========================
 * Renesas entrypoints
 * ========================= */
void R_MAIN_UserInit(void);

void main(void)
{
    char b[64];

    R_MAIN_UserInit();

    R_UART0_Create();    /* UART0 : RS485 */
    R_UART1_Create();    /* UART1 : PC */

    R_IICA0_Create();    /* I2C */

    R_UART0_Start();
    R_UART1_Start();

    sprintf(b, "BOOT addr=%u\r\n", g_fixed_addr);

    /* ? BOOT 출력도 안전 출력 사용 */
    UART1_SendString_Safe(b);
    RS485_PRINT(b);

    R_UART1_Receive((uint8_t *)&uart_rx_buffer[uart_rx_index], 1);
    R_UART0_Receive((uint8_t *)&rs485_rx_buffer[rs485_rx_index], 1);

    handle_uart_command_line();

    while (1U) { ; }
}

void R_MAIN_UserInit(void)
{
    EI();
    R_PORT_Create();

    rs485_init();

    DipSwitch_Init();
    g_fixed_addr = DipSwitch_ReadAddr_0to31();
}