/*********************************************************************************************************************** * 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 WARRANTIES REGARDING 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: * http://www.renesas.com/disclaimer * * Copyright (C) 2012, 2021 Renesas Electronics Corporation. All rights reserved. ***********************************************************************************************************************/ /*********************************************************************************************************************** * File Name : r_main.c * Version : CodeGenerator for RL78/F14 V2.03.07.02 [08 Nov 2021] * Device(s) : R5F10PPJ * Tool-Chain : CCRL * Description : This file implements main function. * Creation Date: 2026-01-21 ***********************************************************************************************************************/ /*********************************************************************************************************************** Includes ***********************************************************************************************************************/ #include "r_cg_macrodriver.h" #include "r_cg_cgc.h" #include "r_cg_port.h" #include "r_cg_serial.h" #include "r_cg_wdt.h" /* Start user code for include. Do not edit comment generated here */ #include "common.h" #include "dipSwitch.h" #include "gatectrl.h" #include #include #include #include #define CMD_MAX 529 #define RS485_BRIDGE_FIFO_SZ 256 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; volatile uint8_t g_rs485_bridge_active = 0; volatile uint8_t g_rs485_bridge_done = 0; // (1~32) uint8_t g_fixed_addr = 1; /* End user code. Do not edit comment generated here */ #include "r_cg_userdefine.h" /*********************************************************************************************************************** Pragma directive ***********************************************************************************************************************/ /* Start user code for pragma. Do not edit comment generated here */ 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이면 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; } static void RS485_Bridge_DrainToPC(void) { // UART1이 전송 중이면(드라이버 카운트) 새 전송 시작하지 않음 extern volatile uint16_t g_uart1_tx_count; static char out[2]; while (s_rb_tail != s_rb_head) { if (g_uart1_tx_count != 0U) break; out[0] = (char)s_rb_fifo[s_rb_tail]; out[1] = '\0'; uart1_send_string(out); // PC(UART1)로 1바이트 전송 시작 s_rb_tail++; if (s_rb_tail >= RS485_BRIDGE_FIFO_SZ) s_rb_tail = 0; } } 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); } typedef enum { PREFIX_NONE = 0, PREFIX_CAL, PREFIX_EOL } PrefixMode; static PrefixMode s_prefix_mode = PREFIX_NONE; 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) { *hash_on = 0; *anaout_on = 0; *check_on = 1; 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만 온 케이스: x01e_001 / x01c_001 if (len == 8) { *payload_pos = len; return 1; } // payload 있는 케이스: x01c_001:... if (s[8] == ':') { *payload_pos = 9; return 1; } // 3) 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'); // flags only if (len == 11) { *payload_pos = 11; return 1; } // flags + payload if (len >= 12 && s[11] == ':') { *payload_pos = 12; return 1; } return -1; } return -1; } typedef enum { CMD_SRC_PC = 0, CMD_SRC_RS485 = 1 } CmdSource; static void OUT_PRINT(CmdSource src, const char *s) { if (src == CMD_SRC_PC) PC_PRINT(s); else RS485_PRINT(s); } // xNNv (예: x00v, x31v) 판별 static int parse_x_v_cmd(const char *s, int len, uint8_t *addr) { if (len != 4) return 0; // "x" + 2digit + "v" = 4 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_v_response(CmdSource src, uint8_t addr) { char resp[8]; // "V00\r\n\0" resp[0] = 'V'; resp[1] = (char)('0' + (addr / 10)); resp[2] = (char)('0' + (addr % 10)); resp[3] = '\r'; resp[4] = '\n'; resp[5] = '\0'; OUT_PRINT(src, resp); } // 보드1이 addr(1~31)을 RS485로 조회하고, 응답이 오면 스트리밍으로 PC에 전달 static void scan_one_addr_rs485(uint8_t addr) { char cmdline[8]; unsigned long guard; // "xNNv\r\n" 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'; // 브릿지 준비 g_rs485_bridge_active = 1; g_rs485_bridge_done = 0; RS485_Bridge_ResetFifo(); R_UART0_Receive((uint8_t*)&rs485_rx_buffer[0], 1); // 조회 커맨드 송신 RS485_PRINT(cmdline); // 응답 들어오면(done)까지 드레인 guard = 0; while (!g_rs485_bridge_done && guard++ < 300000UL) { RS485_Bridge_DrainToPC(); } // 남은 FIFO 마저 RS485_Bridge_DrainToPC(); // 브릿지 종료 g_rs485_bridge_active = 0; // 다음 RS485 RX 재시작(기존 라인처리도 계속 돌릴 거면 유지) rs485_rx_done = 0; rs485_rx_index = 0; rs485_rx_length = 0; R_UART0_Receive((uint8_t*)&rs485_rx_buffer[0], 1); } 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; } 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) { HOST_PRINT("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) { if (pm == PREFIX_EOL) { // TODO: EOL 전용 처리 필요 시 여기에 process_cmd(protocol, id, data, len); } else { // CAL 또는 Prefix 없음 process_cmd(protocol, id, data, len); } } 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; // 1) RX 버퍼 -> line 구성 (CR/LF 제거) idx = build_line_from_rx(rx_buf, (int)rx_len, line, (int)sizeof(line)); if (idx <= 0) return; // 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(ADDR0) + 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 순차 조회 (존재하는 보드만 VNN이 PC로 흘러옴) 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; // v 커맨드 처리는 여기서 종료 } } // 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; } // 내 주소가 아니면: // - 보드1(ADDR0) + PC에서 들어온 것: RS485로 중계 + RS485응답을 PC로 전달 // - 그 외(슬레이브거나 RS485수신): 조용히 무시 if (addr != g_fixed_addr) { // 보드1(ADDR0) + PC에서 들어온 것만 RS485 중계 if (g_fixed_addr == 0 && src == CMD_SRC_PC) { // 0) 브릿지 준비 g_rs485_bridge_active = 1; g_rs485_bridge_done = 0; RS485_Bridge_ResetFifo(); // 1) RS485 RX 재시작(1바이트씩 계속 받게) rs485_rx_done = 0; rs485_rx_index = 0; rs485_rx_length = 0; R_UART0_Receive((uint8_t*)&rs485_rx_buffer[0], 1); // 2) RS485로 커맨드 송신 RS485_PRINT(orig_line); RS485_PRINT("\r\n"); // 3) “응답이 들어오는 동안” 드레인 하면서 대기 { unsigned long guard = 0; while (!g_rs485_bridge_done && guard++ < 600000UL) { RS485_Bridge_DrainToPC(); // ? 스트리밍 } // 남은 FIFO도 끝까지 한번 더 드레인 RS485_Bridge_DrainToPC(); // 브릿지 종료 g_rs485_bridge_active = 0; rs485_rx_done = 0; rs485_rx_index = 0; rs485_rx_length = 0; R_UART0_Receive((uint8_t*)&rs485_rx_buffer[rs485_rx_index], 1); if (!g_rs485_bridge_done) { PC_PRINT("Err:rs485_timeout\r\n"); } } } // 슬레이브(다른 보드)에서 addr mismatch는 조용히 무시 return; } // 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') { // EOL은 payload 없어도 OK OUT_PRINT(src, "XE\r\n"); return; } else { // CAL은 payload 필수 OUT_PRINT(src, "Err:CAL_need_payload\r\n"); return; } } // payload 있는 케이스인데 EOL이면 금지 if (mode == 'E') { OUT_PRINT(src, "Err:EOL_no_payload\r\n"); return; } // CAL + payload만 통과: payload를 line 앞으로 당김 for (i = 0; i < rem; i++) line[i] = line[payload_pos + i]; line[rem] = '\0'; idx = rem; pos = 2; } } // r==0 (prefix 없음): 그냥 아래 일반 커맨드 파싱으로 진행 } // 3) 최소 길이 체크 if (idx < 7) { OUT_PRINT(src, "Err:short\r\n"); return; } // 4) 프로토콜 판별 { 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; } // 5) T 모드 처리 (OT/IT 등) if (line[pos] == 't' || line[pos] == 'T') { if (proto == PROTOCOL_OWIW) proto = PROTOCOL_OWIT; else if (proto == PROTOCOL_I2CW) proto = PROTOCOL_I2CT; pos++; } // 6) 구분자 처리 if (line[pos] == '_' || line[pos] == ':') pos++; // 7) ID (hex 2글자) if (pos + 1 >= idx) { OUT_PRINT(src, "Err:id_short\r\n"); return; } id = hex2byte(line[pos], line[pos + 1]); pos += 2; // 8) 길이(3자리 10진) 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; } // 9) Write 계열: payload(hex) 파싱 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; } } // 10) Read 계열: payload 없어야 함 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; } } // 11) 실제 실행 (prefix 모드 반영) process_cmd_by_prefix(s_prefix_mode, proto, id, cmd, byte_len); } 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; // 브릿지 중엔 “RS485 라인 커맨드 처리”는 하지 않음(응답 스트리밍 중이니까) 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); } } } /* End user code. Do not edit comment generated here */ /*********************************************************************************************************************** Global variables and functions ***********************************************************************************************************************/ /* Start user code for global. Do not edit comment generated here */ /* 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 */ R_UART0_Create(); // UART0 R_UART1_Create(); // UART1 R_IICA0_Create(); // I2C R_UART0_Start(); // RS485 R_UART1_Start(); // PC 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(); delay(100000); while (1U) { ; } /* End user code. Do not edit comment generated here */ } /*********************************************************************************************************************** * Function Name: R_MAIN_UserInit * Description : This function adds user code before implementing main function. * Arguments : None * Return Value : None ***********************************************************************************************************************/ void R_MAIN_UserInit(void) { /* Start user code. Do not edit comment generated here */ EI(); R_PORT_Create(); rs485_init(); DipSwitch_Init(); g_fixed_addr = DipSwitch_ReadAddr_0to31(); /* 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 */