change the controler

doc/joystick.md

@@ -6,6 +6,12 @@
   * 하드웨어: USB to TTL 컨버터 (`/dev/ttyUSB*` 또는 COM 포트)
   * 수신기: XR1 V1.0
   * 조종기: RadioMaster Pocket
+  * **실측 확인된 시리얼 프로토콜: CRSF(Crossfire), 420000bps, 8N1.**
+    프레임 구조 `[Sync 0xC8][Length][FrameType][Payload][CRC8]`, FrameType
+    `0x16`(RC_CHANNELS_PACKED)의 22바이트 payload에 16채널이 11비트씩
+    리틀엔디안으로 패킹되어 raw `172~1811` 값이 `1000~2000us`로 선형
+    변환된다. (CRC8은 이 송신기에서 표준 DVB-S2 값과 안 맞아 검증 없이
+    Sync+Length 프레이밍만 신뢰함.)
 
 ---
 
@@ -15,10 +21,10 @@
 
 | 채널 | 입력 장치 | Raw Value 범위 | 할당 기능 | 동작 설명 |
 | :--- | :--- | :--- | :--- | :--- |
-| **CH1** | 롤/조향 스틱 | • `1001`: 좌측 끝<br>• `1480 ~ 1500`: 중앙 (데드존)<br>• `2000`: 우측 끝 | **좌우 조향 (Steering / Angular Z)** | • 중앙 데드존(`1480~1500`) 적용<br>• 좌회전(-) / 우회전(+) 정규화 |
+| **CH1** | 롤/조향 스틱 | • `1005`: 좌측 끝<br>• `1481 ~ 1503`: 중앙 (데드존)<br>• `2000`: 우측 끝 | **좌우 조향 (Steering / Angular Z)** | • 중앙 데드존(`1481~1503`) 적용<br>• 좌회전(-) / 우회전(+) 정규화 |
-| **CH2** | 피치/스로틀 스틱 | • `1000`: 위 끝 (전진)<br>• `1500`: 중앙 (정지)<br>• `2000`: 아래 끝 (후진) | **전후진 (Throttle / Linear X)** | • `1000` 방향으로 이동 시 전진<br>• `2000` 방향으로 이동 시 후진<br>• CH7에서 결정된 최대 속도 기준으로 선형 매핑 |
+| **CH2** | 피치/스로틀 스틱 | • `1005`: 최대 후진<br>• `1500`: 중앙 (정지)<br>• `2000`: 최대 전진 | **전후진 (Throttle / Linear X)** | • 값이 높을수록 전진, 낮을수록 후진 (CH1과 반대 방향)<br>• CH6에서 결정된 최대 속도 기준으로 선형 매핑 |
-| **CH5** | 2단 스위치 | • `1011`: 미작동 (OFF)<br>• `1988`: 눌림 (ON) | **전자/비상 브레이크 (Brake)** | • `1988` 수신 시 모든 주행 속도 즉시 0 (`Stop`)<br>• `1011` 수신 시 일반 주행 허용 |
+| **CH5** | 2단 스위치 | • `1012`: 미작동 (OFF)<br>• `1988`: 눌림 (ON) | **전자/비상 브레이크 (Brake)** | • `1988` 수신 시 모든 주행 속도 즉시 0 (`Stop`)<br>• `1012` 수신 시 일반 주행 허용 |
-| **CH7** | 2단 스위치 | • `1988`: 위쪽 누름<br>• `1011`: 아래쪽 누름 | **속도 모드 선택 (Speed Mode)** | • `1988` (위쪽): 저속 모드 (최대 **0.3 m/s**)<br>• `1011` (아래쪽): 고속 모드 (최대 **0.6 m/s**) |
+| **CH6** | 2단 스위치 | • `1832`: 저속 위치<br>• `1012~1090`: 고속 위치 | **속도 모드 선택 (Speed Mode)** | • `1832`(≥1500 부근): 저속 모드 (최대 **0.3 m/s**)<br>• `1012~1090`(<1500): 고속 모드 (최대 **1.5 m/s**) |
 
 ---
 
@@ -27,25 +33,25 @@
 ### 3.1 브레이크 최우선 로직 (CH5)
 * $\text{CH5} \ge 1500$ (누름 / `1988` 부근):
   $$\text{Linear Velocity} = 0.0, \quad \text{Angular Velocity} = 0.0$$
-* $\text{CH5} < 1500$ (안누름 / `1011` 부근): 정상 주행 로직 실행
+* $\text{CH5} < 1500$ (안누름 / `1012` 부근): 정상 주행 로직 실행
 
-### 3.2 속도 제한 설정 (CH7)
+### 3.2 속도 제한 설정 (CH6)
-* $\text{CH7} \ge 1500$ (위쪽 / `1988` 부근): $V_{\max} = 0.3 \text{ m/s}$ (저속 모드)
+* $\text{CH6} \ge 1500$ (`1832` 부근): $V_{\max} = 0.3 \text{ m/s}$ (저속 모드)
-* $\text{CH7} < 1500$ (아래쪽 / `1011` 부근): $V_{\max} = 0.6 \text{ m/s}$ (고속 모드)
+* $\text{CH6} < 1500$ (`1012~1090` 부근): $V_{\max} = 1.5 \text{ m/s}$ (고속 모드)
 
 ### 3.3 전후진 속도 계산 (CH2)
 * **데드존(Deadband):** $1480 \le \text{CH2} \le 1520 \rightarrow V_x = 0.0$
-* **전진 구간 ($1000 \le \text{CH2} < 1480$):**
+* **후진 구간 ($1005 \le \text{CH2} < 1480$):**
-  $$V_x = \left( \frac{1480 - \text{CH2}}{1480 - 1000} \right) \times V_{\max}$$
+  $$V_x = -\left( \frac{1480 - \text{CH2}}{1480 - 1005} \right) \times V_{\max}$$
-* **후진 구간 ($1520 < \text{CH2} \le 2000$):**
+* **전진 구간 ($1520 < \text{CH2} \le 2000$):**
-  $$V_x = -\left( \frac{\text{CH2} - 1520}{2000 - 1520} \right) \times V_{\max}$$
+  $$V_x = \left( \frac{\text{CH2} - 1520}{2000 - 1520} \right) \times V_{\max}$$
 
 ### 3.4 좌우 조향 각속도 계산 (CH1)
-* **데드존(Deadband):** $1480 \le \text{CH1} \le 1500 \rightarrow \omega_z = 0.0$
+* **데드존(Deadband):** $1481 \le \text{CH1} \le 1503 \rightarrow \omega_z = 0.0$
-* **좌회전 구간 ($1001 \le \text{CH1} < 1480$):**
+* **좌회전 구간 ($1005 \le \text{CH1} < 1481$):**
-  $$\omega_z = -\left( \frac{1480 - \text{CH1}}{1480 - 1001} \right) \times \Omega_{\max}$$
+  $$\omega_z = -\left( \frac{1481 - \text{CH1}}{1481 - 1005} \right) \times \Omega_{\max}$$
-* **우회전 구간 ($1500 < \text{CH1} \le 2000$):**
+* **우회전 구간 ($1503 < \text{CH1} \le 2000$):**
-  $$\omega_z = +\left( \frac{\text{CH1} - 1500}{2000 - 1500} \right) \times \Omega_{\max}$$
+  $$\omega_z = +\left( \frac{\text{CH1} - 1503}{2000 - 1503} \right) \times \Omega_{\max}$$
 
 ---
 

mac/mac_code

@@ -0,0 +1,79 @@
+import serial
+import time
+
+# 확인된 포트 경로 설정
+SERIAL_PORT = "/dev/cu.usbserial-0001"
+BAUD_RATE = 420000
+
+CRSF_SYNC = 0xC8
+CRSF_FRAMETYPE_RC_CHANNELS_PACKED = 0x16
+
+def parse_channels(payload):
+    if len(payload) < 22:
+        return []
+    
+    # 22바이트의 채널 데이터를 정수로 변환 후 11비트씩 언패킹
+    data = int.from_bytes(payload[:22], byteorder='little')
+    channels = []
+    for _ in range(16):
+        raw_val = data & 0x07FF  # 11-bit 마스크
+        # CRSF 원본 값(172~1811)을 RC 마이크로초(1000~2000µs) 단위로 변환
+        us_val = int((raw_val - 172) * (2000 - 1000) / (1811 - 172) + 1000)
+        channels.append(us_val)
+        data >>= 11
+    return channels
+
+def main():
+    try:
+        ser = serial.Serial(SERIAL_PORT, BAUD_RATE, timeout=0.1)
+        print(f"Connected to {SERIAL_PORT} at {BAUD_RATE} baud.")
+        print("스틱과 스위치를 움직여 채널 값을 확인하세요. (종료: Ctrl+C)\n")
+    except Exception as e:
+        print(f"포트 연결 오류: {e}")
+        return
+
+    buf = bytearray()
+    while True:
+        try:
+            if ser.in_waiting:
+                buf.extend(ser.read(ser.in_waiting))
+
+                while len(buf) > 3:
+                    if buf[0] != CRSF_SYNC:
+                        buf.pop(0)
+                        continue
+
+                    length = buf[1]
+                    total_packet_len = length + 2
+
+                    if len(buf) < total_packet_len:
+                        break  # 전체 패킷 대기
+
+                    packet = buf[:total_packet_len]
+                    buf = buf[total_packet_len:]
+
+                    frame_type = packet[2]
+                    if frame_type == CRSF_FRAMETYPE_RC_CHANNELS_PACKED:
+                        payload = packet[3:-1]  # CRC 제외 payload
+                        channels = parse_channels(payload)
+                        
+                        # read_crsf.py 출력 부분 수정
+                        print(
+                            f"\rCH1: {channels[0]:4d} | CH2: {channels[1]:4d} | "
+                            f"CH3: {channels[2]:4d} | CH4: {channels[3]:4d} | "
+                            f"CH5(SA/SC): {channels[4]:4d} | CH6(SD): {channels[5]:4d} | "
+                            f"CH7: {channels[6]:4d} | CH8: {channels[7]:4d}", 
+                            end="", flush=True
+                            )
+
+        except KeyboardInterrupt:
+            print("\n모니터링 종료")
+            break
+        except Exception as e:
+            print(f"\n데이터 수신 오류: {e}")
+            break
+
+    ser.close()
+
+if __name__ == "__main__":
+    main()

run_4wd.sh

@@ -1,7 +1,9 @@
 #!/usr/bin/env bash
 
 # 1-Click Launch Script for C++ 4WD Motor Control with Mid-360S LiDAR Avoidance
-PORT="${1:-/dev/ttyUSB0}"
+# 현재 고정 배선: 모터 드라이버 = ttyUSB1, RC 수신기(XR1) = ttyUSB0
+PORT="${1:-/dev/ttyUSB1}"
+RC_PORT="${RC_PORT:-/dev/ttyUSB0}"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 cd "$SCRIPT_DIR" || exit 1
@@ -10,10 +12,11 @@ echo "=================================================================="
 echo " 🚀 ZLAC8015D 4WD + Livox Mid-360S 라이다 원클릭 런치 시스템"
 echo "=================================================================="
 
-# 1. USB Latency 1ms 단축
+# 1. USB Latency 1ms 단축 (모터 포트 + RC 수신기 포트 둘 다)
 if [ -f "./set_low_latency.sh" ]; then
-    echo "[1/2] USB 시리얼 포트($PORT) 지연 시간 1ms 최적화 적용 중..."
+    echo "[1/2] USB 시리얼 포트 지연 시간 1ms 최적화 적용 중... (모터: $PORT / RC: $RC_PORT)"
     ./set_low_latency.sh "$PORT"
+    ./set_low_latency.sh "$RC_PORT"
 fi
 
 # 2. C++ 바이너리 존재 여부 확인 및 컴파일
@@ -23,14 +26,16 @@ if [ ! -f "./xbox_motor_control_cpp" ]; then
 fi
 
 echo "=================================================================="
-echo " [시작] C++ 100Hz 초저지연 4WD RC(RadioMaster Pocket + XR1) + 라이다 장애물 회피 시작 ($PORT)"
+echo " [시작] C++ 100Hz 초저지연 4WD RC(RadioMaster Pocket + XR1) + 라이다 장애물 회피 시작"
+echo "  - 모터 포트: $PORT / RC 수신기 포트: $RC_PORT"
 echo "  - 라이다 기능 비활성화: --no_lidar 옵션"
 echo "  - 비상 정지: CH5 브레이크 스위치 또는 Ctrl+C"
 echo "=================================================================="
 
-# 3. C++ 4WD 프로그램 실행 (추가 인자 전달 가능)
+# 3. C++ 4WD 프로그램 실행 (추가 인자 전달 가능. --rc_port를 다시 넘기면
+# 아래 기본값을 덮어쓸 수 있다 — 인자 파싱은 뒤에 온 값이 우선 적용됨)
 if [ $# -gt 1 ]; then
-    ./xbox_motor_control_cpp --port "$PORT" "${@:2}"
+    ./xbox_motor_control_cpp --port "$PORT" --rc_port "$RC_PORT" "${@:2}"
 else
-    ./xbox_motor_control_cpp --port "$PORT"
+    ./xbox_motor_control_cpp --port "$PORT" --rc_port "$RC_PORT"
 fi

xbox_motor_control.cpp

@@ -1,4 +1,5 @@
 #include <algorithm>
+#include <array>
 #include <atomic>
 #include <cerrno>
 #include <chrono>
@@ -604,28 +605,56 @@ LidarObstacleDetector *LidarObstacleDetector::instance_ = nullptr;
 
 // -----------------------------------------------------------------------------
 // RadioMaster Pocket + XR1 V1.0 RC 수신기 (USB-to-TTL 시리얼) 입력 모듈
-// doc/joystick.md 기능 명세서 기반: 텍스트 라인 "CH1:1500,CH2:1500,..." 포맷을
+// 실기 캡처로 확인한 실제 프로토콜: CRSF(Crossfire), 420000bps, 8N1.
-// 파싱해 채널별 raw 값(1000~2000)을 제공한다.
+// 프레임: [0]=Sync(0xC8) [1]=Length [2]=FrameType [3..]=Payload [-1]=CRC8
+// FrameType 0x16(RC_CHANNELS_PACKED)의 22바이트 payload에 16채널이 11비트씩
+// 리틀엔디안으로 패킹되어 있다 (raw 172~1811 -> 1000~2000us로 선형 변환).
+// 참고: mac/mac_code (맥에서 정상 동작 확인된 레퍼런스 파이썬 스크립트)와
+// 동일한 파싱 방식을 따른다 — 실측 결과 CRC8이 표준 DVB-S2(poly 0xD5) 값과
+// 맞지 않아(송신기별 구현 차이로 추정) 레퍼런스와 동일하게 CRC는 검증하지
+// 않고 Sync+Length 기반 프레이밍만 신뢰한다.
 // -----------------------------------------------------------------------------
+#ifndef BOTHER
+#define BOTHER 0010000 // 커널 termbits.h: CBAUDEX와 동일값, 임의 보드레이트 지정용
+#endif
+struct termios2 { // <asm/termbits.h>의 커널 ABI와 동일 레이아웃 (glibc의
+                   // struct termios와 이름 충돌을 피하기 위해 직접 선언).
+                   // 420000bps처럼 표준 B-상수가 없는 보드레이트를
+                   // TCSETS2/BOTHER ioctl로 설정하기 위해 필요하다.
+  tcflag_t c_iflag, c_oflag, c_cflag, c_lflag;
+  cc_t c_line;
+  cc_t c_cc[19];
+  speed_t c_ispeed, c_ospeed;
+};
+
 struct RcConfig {
-  std::string port = "/dev/ttyUSB1";
+  std::string port = "/dev/ttyUSB0"; // 현재 고정 배선: RC 수신기(XR1) = ttyUSB0
-  int baud = 115200;
+  int baud = 420000; // CRSF 표준 보드레이트
 
   int ch_steer = 1;    // CH1: 좌우 조향
   int ch_throttle = 2; // CH2: 전후진
   int ch_brake = 5;    // CH5: 비상 브레이크
-  int ch_speed = 7;    // CH7: 속도 모드
+  int ch_speed = 6;    // CH6: 속도 모드
 
-  int steer_min = 1001, steer_center_lo = 1480, steer_center_hi = 1500,
+  // 실기 캡처로 확인한 실측값 (좌 1005 ~ 중 1481~1503 ~ 우 2000)
+  int steer_min = 1005, steer_center_lo = 1481, steer_center_hi = 1503,
       steer_max = 2000;
-  int throttle_min = 1000, throttle_center_lo = 1480, throttle_center_hi = 1520,
+  // 실측값: 후진끝 1005 ~ 중 1500 ~ 전진끝 2000 (CH2는 값이 높을수록 전진 —
+  // CH1과 반대 방향이라 아래 3.3 매핑 로직도 그에 맞춰 부호가 반대다)
+  int throttle_min = 1005, throttle_center_lo = 1480, throttle_center_hi = 1520,
       throttle_max = 2000;
 
   int brake_threshold = 1500; // 이상이면 브레이크 ON
   int speed_threshold = 1500; // 이상이면 저속 모드
 
-  float v_max_low = 0.3f;  // m/s (CH7 저속 모드)
+  // CH1/CH2(연속 아날로그 스틱) 슬루레이트 한계: 메인 루프 한 틱(~10ms)
-  float v_max_high = 0.6f; // m/s (CH7 고속 모드)
+  // 사이에 raw 값이 이 이상 튀면 사람이 스틱으로 낼 수 없는 변화로 보고
+  // 손상된 프레임으로 간주해 버린다. CH5/CH6(스위치)는 원래 한 번에 크게
+  // 뛰는 게 정상이라 이 제한을 적용하지 않는다.
+  int max_slew_per_tick = 200;
+
+  float v_max_low = 0.3f;  // m/s (CH6 저속 모드)
+  float v_max_high = 1.5f; // m/s (CH6 고속 모드)
 
   int failsafe_timeout_ms = 200; // 이 시간 이상 신호 미수신 시 비상정지
 };
@@ -679,7 +708,27 @@ private:
   std::chrono::steady_clock::time_point last_rx_time_{};
   bool port_open_ = false;
 
-  std::string line_buf_;
+  std::vector<uint8_t> frame_buf_;
+
+  // 채널별 미디언(median-of-3) 필터 히스토리. 이 송신기는 CRC/체크섬이
+  // 표준 방식으로 검증되지 않아(전수조사로 확인) 단발성 손상 프레임이
+  // 섞여 들어올 수 있는데, 최근 3개 raw 값 중 가운데 값을 채택하면 3개
+  // 중 하나가 손상돼도 자동으로 걸러진다. 스위치 채널도 전환 시 최대
+  // 1프레임(~4ms)만 지연될 뿐이라 안전하게 전 채널에 적용 가능하다.
+  std::map<int, std::array<int, 2>> raw_history_;
+  std::map<int, int> history_count_;
+
+  static int median3(int a, int b, int c) {
+    if ((a <= b && b <= c) || (c <= b && b <= a))
+      return b;
+    if ((b <= a && a <= c) || (c <= a && a <= b))
+      return a;
+    return c;
+  }
+
+  static constexpr uint8_t CRSF_SYNC = 0xC8;
+  static constexpr uint8_t CRSF_FRAMETYPE_RC_CHANNELS_PACKED = 0x16;
+  static constexpr size_t CRSF_MAX_FRAME_LEN = 64; // 스펙상 프레임은 훨씬 작음
 
   bool openPort() {
     fd_ = open(cfg_.port.c_str(), O_RDWR | O_NOCTTY | O_NDELAY);
@@ -688,46 +737,40 @@ private:
 
     fcntl(fd_, F_SETFL, O_NONBLOCK);
 
-    struct termios options;
+    // CRSF 표준 420000bps는 termios의 표준 B-상수 목록에 없어 TCSETS2 +
-    tcgetattr(fd_, &options);
+    // BOTHER + c_ispeed/c_ospeed(임의 정수 보드레이트) ioctl로 설정한다.
-
+    struct termios2 tio;
-    speed_t speed = B115200;
+    if (ioctl(fd_, TCGETS2, &tio) < 0) {
-    switch (cfg_.baud) {
+      close(fd_);
-    case 9600:
+      fd_ = -1;
-      speed = B9600;
+      return false;
-      break;
-    case 19200:
-      speed = B19200;
-      break;
-    case 38400:
-      speed = B38400;
-      break;
-    case 57600:
-      speed = B57600;
-      break;
-    default:
-      speed = B115200;
-      break;
     }
 
-    cfsetispeed(&options, speed);
+    tio.c_cflag &= ~CBAUD;
-    cfsetospeed(&options, speed);
+    tio.c_cflag |= BOTHER;
+    tio.c_ispeed = static_cast<speed_t>(cfg_.baud);
+    tio.c_ospeed = static_cast<speed_t>(cfg_.baud);
 
-    options.c_cflag &= ~PARENB;
+    tio.c_cflag &= ~PARENB;
-    options.c_cflag &= ~CSTOPB;
+    tio.c_cflag &= ~CSTOPB;
-    options.c_cflag &= ~CSIZE;
+    tio.c_cflag &= ~CSIZE;
-    options.c_cflag |= CS8;
+    tio.c_cflag |= CS8;
-    options.c_cflag &= ~CRTSCTS;
+    tio.c_cflag &= ~CRTSCTS;
-    options.c_cflag |= CREAD | CLOCAL;
+    tio.c_cflag |= CREAD | CLOCAL;
 
-    // 텍스트 라인 프로토콜이므로 canonical 모드(라인 단위)로 사용
+    // 바이너리 프로토콜이므로 raw 모드(비정규/논캐노니컬)로 읽는다.
-    options.c_lflag |= ICANON;
+    tio.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG | IEXTEN);
-    options.c_lflag &= ~(ECHO | ECHOE | ISIG);
+    tio.c_iflag &= ~(IXON | IXOFF | IXANY | IGNBRK | BRKINT | PARMRK |
-    options.c_iflag &= ~(IXON | IXOFF | IXANY | IGNBRK | BRKINT | PARMRK |
+                     ISTRIP | INLCR | IGNCR | ICRNL);
-                         ISTRIP | INLCR | IGNCR | ICRNL);
+    tio.c_oflag &= ~OPOST;
-    options.c_oflag &= ~OPOST;
+    tio.c_cc[VMIN] = 0;
+    tio.c_cc[VTIME] = 0;
 
-    tcsetattr(fd_, TCSANOW, &options);
+    if (ioctl(fd_, TCSETS2, &tio) < 0) {
+      close(fd_);
+      fd_ = -1;
+      return false;
+    }
     tcflush(fd_, TCIOFLUSH);
     return true;
   }
@@ -741,38 +784,78 @@ private:
     port_open_ = false;
   }
 
-  void parseLine(const std::string &line) {
+  // 축적된 바이트 버퍼에서 CRSF 프레임을 최대한 뽑아낸다. Sync 바이트를
+  // 찾고, 선언된 Length만큼 버퍼에 데이터가 쌓일 때까지 기다린 뒤
+  // RC_CHANNELS_PACKED(0x16) 프레임이면 16채널(11비트씩)을 언패킹한다.
+  // (CRC8은 이 송신기에서 표준 DVB-S2 값과 맞지 않아 검증하지 않음 — 실기
+  // 캡처로 확인된 mac/mac_code 레퍼런스와 동일한 방식.)
+  void parseCrsfBuffer() {
     std::map<int, int> parsed;
-    size_t pos = 0;
+    size_t i = 0;
-    while (pos <= line.size()) {
+    while (i < frame_buf_.size()) {
-      size_t comma = line.find(',', pos);
+      if (frame_buf_[i] != CRSF_SYNC) {
-      std::string tok = line.substr(
+        ++i;
-          pos, comma == std::string::npos ? std::string::npos : comma - pos);
+        continue;
+      }
+      if (i + 1 >= frame_buf_.size())
+        break; // length 바이트 대기
 
-      size_t b = tok.find_first_not_of(" \t\r\n");
+      uint8_t length = frame_buf_[i + 1];
-      size_t e = tok.find_last_not_of(" \t\r\n");
+      size_t total_len = static_cast<size_t>(length) + 2;
-      if (b != std::string::npos) {
+      if (length < 2 || total_len > CRSF_MAX_FRAME_LEN) {
-        tok = tok.substr(b, e - b + 1);
+        // Sync처럼 보이는 노이즈 바이트: 1바이트만 버리고 재동기화
-        if (tok.size() >= 4 && (tok[0] == 'C' || tok[0] == 'c') &&
+        ++i;
-            (tok[1] == 'H' || tok[1] == 'h')) {
+        continue;
-          size_t colon = tok.find(':');
+      }
-          if (colon != std::string::npos) {
+      if (i + total_len > frame_buf_.size())
-            try {
+        break; // 프레임 전체 수신 대기
-              int ch_num = std::stoi(tok.substr(2, colon - 2));
+
-              int val = std::stoi(tok.substr(colon + 1));
+      uint8_t frame_type = frame_buf_[i + 2];
-              parsed[ch_num] = val;
+      if (frame_type == CRSF_FRAMETYPE_RC_CHANNELS_PACKED && length >= 23) {
-            } catch (...) {
+        // payload = frame_buf_[i+3 .. i+total_len-2] (CRC 바이트 제외 22바이트
-              // 손상된 토큰은 무시
+        // = 176비트 = 16채널×11비트). uint64_t 하나에 통째로 담으면 64비트를
-            }
+        // 넘는 시프트가 발생해 정의되지 않은 동작(UB)이 되므로, 32비트 롤링
+        // 비트 누산기로 바이트를 하나씩 채워가며 11비트씩 뽑아낸다.
+        uint32_t bit_accum = 0;
+        int bit_count = 0;
+        int byte_idx = 0;
+        for (int ch = 0; ch < 16; ++ch) {
+          while (bit_count < 11) {
+            bit_accum |= static_cast<uint32_t>(frame_buf_[i + 3 + byte_idx])
+                         << bit_count;
+            bit_count += 8;
+            ++byte_idx;
           }
+          int raw_val = static_cast<int>(bit_accum & 0x7FFU);
+          bit_accum >>= 11;
+          bit_count -= 11;
+          int us_val = static_cast<int>(
+              std::lround((raw_val - 172) * 1000.0 / 1639.0 + 1000.0));
+
+          // 미디언-3 필터: 최근 2개 raw 값 + 이번 값 중 가운데 값을 채택.
+          // 히스토리는 항상 raw 값으로 갱신한다(필터링된 결과가 아니라).
+          int ch_num = ch + 1;
+          std::array<int, 2> &hist = raw_history_[ch_num];
+          int &count = history_count_[ch_num];
+          int filtered = us_val;
+          if (count >= 2) {
+            filtered = median3(hist[0], hist[1], us_val);
+          } else {
+            ++count; // 워밍업 구간(처음 2개)은 그대로 통과
+          }
+          hist[0] = hist[1];
+          hist[1] = us_val;
+          parsed[ch_num] = filtered; // CH1..CH16 (1-based)
         }
       }
-
+      i += total_len;
-      if (comma == std::string::npos)
-        break;
-      pos = comma + 1;
     }
 
+    // 처리하지 못한 잔여 바이트(다음 프레임 일부)만 남기고 버퍼 정리
+    frame_buf_.erase(frame_buf_.begin(), frame_buf_.begin() + i);
+    if (frame_buf_.size() > CRSF_MAX_FRAME_LEN * 4) // 비정상 누적 방지
+      frame_buf_.clear();
+
     if (!parsed.empty()) {
       std::lock_guard<std::mutex> lock(mutex_);
       for (auto &kv : parsed)
@@ -812,15 +895,8 @@ private:
 
       ssize_t n = read(fd_, buf, sizeof(buf));
       if (n > 0) {
-        line_buf_.append(buf, static_cast<size_t>(n));
+        frame_buf_.insert(frame_buf_.end(), buf, buf + n);
-        size_t nl;
+        parseCrsfBuffer();
-        while ((nl = line_buf_.find('\n')) != std::string::npos) {
-          std::string line = line_buf_.substr(0, nl);
-          line_buf_.erase(0, nl + 1);
-          parseLine(line);
-        }
-        if (line_buf_.size() > 4096) // 개행 없는 쓰레기 데이터 누적 방지
-          line_buf_.clear();
       } else if (n < 0 && errno != EAGAIN && errno != EWOULDBLOCK) {
         std::cerr << "\n[경고] RC 수신기 포트 통신 오류. 재연결 시도...\n";
         closePort();
@@ -835,7 +911,7 @@ int main(int argc, char **argv) {
   std::signal(SIGINT, signalHandler);
   std::signal(SIGTERM, signalHandler);
 
-  std::string port1 = "/dev/ttyUSB0";
+  std::string port1 = "/dev/ttyUSB1"; // 현재 고정 배선: 모터 드라이버 = ttyUSB1
   std::string port2 = "";
   uint8_t id1 = 1;
   uint8_t id2 = 2;
@@ -845,12 +921,12 @@ int main(int argc, char **argv) {
   float track_width = 0.576f;     // 좌우 바퀴 중심 거리 576mm
   float wheelbase = 0.3684f;      // 전후 바퀴 중심 거리 368.4mm
   float wheel_radius = 0.131517f; // 사용자 실측 정밀 10.35인치 휠 반지름
-  float accel_rate = 120.0f;      // RPM/s (최대 가속도 한계)
+  // 가속은 역기전력 보호회로가 하드웨어로 구성되어 목표값에 1:1로 즉시
+  // 추종하므로 별도의 가속 한계값이 없다. decel_rate/jerk_rate(및
+  // spin_jerk_rate)는 감속에만 적용된다.
   float decel_rate = 180.0f;      // RPM/s (최대 감속도 한계)
-  float jerk_rate = 600.0f;       // RPM/s^2 (직진/커브 선회 저크 한계)
+  float jerk_rate = 600.0f;       // RPM/s^2 (직진/커브 선회 감속 저크 한계)
-  float spin_jerk_rate = 220.0f;  // RPM/s^2 (제자리 회전 저크 한계: 고마찰 노면에서
+  float spin_jerk_rate = 220.0f;  // RPM/s^2 (제자리 회전 감속 저크 한계)
-                                   // 정지마찰이 급격히 파괴되지 않도록 accel_rate에
-                                   // 도달하는 시간을 더 길게 늘림)
   float spin_arc_bias = 0.12f;    // 0~1 (제자리 회전 시 섞을 최소 회전반경용
                                    // 미세 전진 성분 비율. ICR을 로봇 중심에서
                                    // 살짝 벗어나게 해 스크럽 마찰 저항을 줄임)
@@ -912,8 +988,6 @@ int main(int argc, char **argv) {
       wheel_radius = std::stof(argv[++i]);
     else if (arg == "--bumper" && i + 1 < argc)
       bumper_offset = std::stof(argv[++i]);
-    else if (arg == "--accel" && i + 1 < argc)
-      accel_rate = std::stof(argv[++i]);
     else if (arg == "--decel" && i + 1 < argc)
       decel_rate = std::stof(argv[++i]);
     else if (arg == "--jerk" && i + 1 < argc)
@@ -992,6 +1066,8 @@ int main(int argc, char **argv) {
       rc_cfg.brake_threshold = std::stoi(argv[++i]);
     else if (arg == "--rc_speed_threshold" && i + 1 < argc)
       rc_cfg.speed_threshold = std::stoi(argv[++i]);
+    else if (arg == "--rc_max_slew" && i + 1 < argc)
+      rc_cfg.max_slew_per_tick = std::stoi(argv[++i]);
     else if (arg == "--rc_vmax_low" && i + 1 < argc)
       rc_cfg.v_max_low = std::stof(argv[++i]);
     else if (arg == "--rc_vmax_high" && i + 1 < argc)
@@ -1025,7 +1101,7 @@ int main(int argc, char **argv) {
             << "mm\n";
   std::cout << "  - 최고 속도: 저속 " << rc_cfg.v_max_low << "m/s / 고속 "
             << rc_cfg.v_max_high << "m/s (CH" << rc_cfg.ch_speed
-            << " 전환) | 가속: " << accel_rate << "RPM/s | Jerk: " << jerk_rate
+            << " 전환) | 가속: 즉시 추종(1:1) | 감속 Jerk: " << jerk_rate
             << "RPM/s² (제자리회전: " << spin_jerk_rate
             << "RPM/s²) | 회전 곡선혼합: " << spin_arc_bias * 100.0f << "%\n";
   std::cout << "  - RC 수신기: " << rc_cfg.port << " @" << rc_cfg.baud
@@ -1052,6 +1128,7 @@ int main(int argc, char **argv) {
     log_stream.open(log_path);
     if (log_stream.is_open()) {
       log_stream << "t_ms,state,rc_steer,rc_throttle,rc_ok,brake,vmax,vx,omega,"
+                    "ch1,ch2,ch3,ch4,ch5,ch6,ch7,ch8,"
                     "cmd_fl,cmd_fr,cmd_rl,cmd_rr,"
                     "fb_fl,fb_fr,fb_rl,fb_rr,"
                     "amp_fl,amp_fr,amp_rl,amp_rr,"
@@ -1077,6 +1154,18 @@ int main(int argc, char **argv) {
     }
   }
 
+  // 모터(--port)와 RC 수신기(--rc_port)가 같은 물리 포트를 가리키면 두
+  // 스레드가 같은 장치의 read()를 두고 경쟁해 RC 라인 파싱이 깨진다.
+  // 흔한 실수(예: 모터 미연결 상태에서 RC 수신기가 ttyUSB0에 꽂혀있는데
+  // --rc_port를 기본값 ttyUSB1로 둔 채 실행)를 바로 알아차리도록 경고한다.
+  if (port1 == rc_cfg.port) {
+    std::cout << "\n[경고] --port(모터, " << port1 << ")와 --rc_port(RC 수신기, "
+              << rc_cfg.port
+              << ")가 동일한 포트로 설정되어 있습니다. 두 기능이 같은 장치를 "
+                 "동시에 읽으면 RC 데이터 파싱이 깨질 수 있으니 서로 다른 "
+                 "포트로 지정하세요.\n\n";
+  }
+
   RcReceiver rc(rc_cfg);
   rc.start();
   std::cout << "[정보] RadioMaster Pocket / XR1 V1.0 RC 수신기 리더 시작 ("
@@ -1156,13 +1245,14 @@ int main(int argc, char **argv) {
   const float loop_hz = 100.0f;
   const float dt = 1.0f / loop_hz;
 
-  // 저크 제한(jerk-limited) S-curve: 가속도 자체를 매 틱 jerk_limit 만큼만
+  // 가속: 역기전력 보호회로가 하드웨어로 구성되어 더 이상 소프트웨어로
-  // 변화시켜 서서히 목표 가속도에 도달하게 함. 기존 구현은 목표 접근 구간만
+  // 완만하게 램프업할 필요가 없어져, 조이스틱 목표값에 1:1로 즉시 추종한다.
-  // 부드러웠고 정지 상태에서 출발할 때는 첫 틱부터 거의 풀가속도가 걸려
+  // 감속: 기존과 동일하게 저크 제한(jerk-limited) S-curve 유지 — 가속도
-  // 정지마찰이 급격히 파괴되는 문제가 있었음.
+  // 자체를 매 틱 jerk_limit 만큼만 변화시켜 서서히 목표 가속도에 도달하게
+  // 해서, 급감속 시 타이어 스크럽/전복 위험을 줄인다.
   auto jerkLimitedStep = [dt](float current_vel, float target_vel,
-                              float &current_accel, float max_accel_mag,
+                              float &current_accel, float max_decel_mag,
-                              float max_decel_mag, float jerk_limit) {
+                              float jerk_limit) {
     float diff = target_vel - current_vel;
     if (std::abs(diff) < 0.01f) {
       current_accel = 0.0f;
@@ -1170,9 +1260,13 @@ int main(int argc, char **argv) {
     }
 
     bool is_accelerating = std::abs(target_vel) > std::abs(current_vel);
-    float accel_cap = is_accelerating ? max_accel_mag : max_decel_mag;
+    if (is_accelerating) {
+      current_accel = 0.0f;
+      return target_vel;
+    }
+
     // 이번 틱에 diff를 없애는데 필요한 가속도(부호 포함)를 물리적 한계로 클램프
-    float desired_accel = std::clamp(diff / dt, -accel_cap, accel_cap);
+    float desired_accel = std::clamp(diff / dt, -max_decel_mag, max_decel_mag);
 
     float max_delta_accel = jerk_limit * dt;
     current_accel = std::clamp(desired_accel, current_accel - max_delta_accel,
@@ -1197,9 +1291,9 @@ int main(int argc, char **argv) {
   bool airborne_rl = false, airborne_rr = false;
   int air_count_fl = 0, air_count_fr = 0, air_count_rl = 0, air_count_rr = 0;
   // 착지(airborne 해제) 직후 한 틱 동안: 차체는 이미 그 속도로 움직이고
-  // 있는데 cmd는 정지출발용 accel_rate로 천천히 재가속되면, 그 사이 바퀴가
+  // 있는데 cmd가 뒤늦게 target을 쫓아가면 그 사이 바퀴가 지면 이동속도를
-  // 지면 이동속도를 못 따라가 끌리며 긁히는 문제가 있어 즉시 target으로
+  // 못 따라가 끌리며 긁히는 문제가 있어 즉시 target으로 스냅시켜 지연을
-  // 스냅시켜 지연을 없앤다.
+  // 없앤다.
   bool just_landed_fl = false, just_landed_fr = false;
   bool just_landed_rl = false, just_landed_rr = false;
   char wheel_status_str[5] = "OOOO";
@@ -1208,6 +1302,18 @@ int main(int argc, char **argv) {
   bool prev_rc_ok = false;    // RC 연결 직전 틱 상태 (Fail-safe 로그용)
   float omega_max = (effective_w > 0.0f) ? (max_spin_v / (effective_w / 2.0f))
                                           : 0.0f; // CH1 조향 최대 각속도
+  // CRC 미검증으로 인해 손상된 CRSF 프레임이 드물게 통과할 수 있다.
+  // (실측 결과 이 송신기는 표준 CRC8 변형 어떤 것과도 안 맞아 — poly
+  // 전수조사+여러 바이트 범위로 확인해도 일치율이 최대 33% 수준이라
+  // CRC 자체를 신뢰할 수 없다고 판단, 검증 시도를 포기함.) 대신 두 가지
+  // 물리적 타당성 검사로 걸러낸다:
+  //  1) 캘리브레이션 범위(steer_min~max, throttle_min~max) 밖의 값 거부
+  //  2) 슬루레이트: 한 틱(~10ms) 사이에 사람이 스틱으로 낼 수 없을 만큼
+  //     크게 튀는 값 거부 (예: 1227 -> 1800 같은 순간 점프)
+  // 두 경우 모두 그 틱은 버리고 마지막으로 유효했던 값을 그대로 사용한다.
+  int last_raw_steer = rc_cfg.steer_center_lo;
+  int last_raw_throttle = 1500;
+  bool steer_initialized = false, throttle_initialized = false;
 
   while (g_running) {
     // ---------------------------------------------------------------------
@@ -1221,6 +1327,38 @@ int main(int argc, char **argv) {
     rc.getChannel(rc_cfg.ch_brake, raw_brake);
     rc.getChannel(rc_cfg.ch_speed, raw_speed_mode);
 
+    bool steer_range_ok =
+        raw_steer >= rc_cfg.steer_min && raw_steer <= rc_cfg.steer_max;
+    bool steer_slew_ok = !steer_initialized ||
+                         std::abs(raw_steer - last_raw_steer) <=
+                             rc_cfg.max_slew_per_tick;
+    if (steer_range_ok && steer_slew_ok) {
+      last_raw_steer = raw_steer;
+      steer_initialized = true;
+    } else {
+      raw_steer = last_raw_steer; // 범위 밖 또는 비정상 점프 -> 손상된 프레임으로 간주
+    }
+
+    bool throttle_range_ok = raw_throttle >= rc_cfg.throttle_min &&
+                             raw_throttle <= rc_cfg.throttle_max;
+    bool throttle_slew_ok = !throttle_initialized ||
+                            std::abs(raw_throttle - last_raw_throttle) <=
+                                rc_cfg.max_slew_per_tick;
+    if (throttle_range_ok && throttle_slew_ok) {
+      last_raw_throttle = raw_throttle;
+      throttle_initialized = true;
+    } else {
+      raw_throttle = last_raw_throttle;
+    }
+
+    // CH1~CH8 raw 값 전체를 확인용으로 읽는다 (CH5=브레이크 값을 실시간으로
+    // 직접 눈으로 검증할 수 있도록 HUD/CSV에 그대로 노출).
+    int raw_ch[9]; // 인덱스 1..8 사용
+    for (int ch = 1; ch <= 8; ++ch) {
+      if (!rc.getChannel(ch, raw_ch[ch]))
+        raw_ch[ch] = 0; // 아직 수신 못한 채널은 0으로 표시
+    }
+
     if (!rc_ok && prev_rc_ok) {
       std::cout << "\n[경고] RC 신호 Fail-safe 발동 (" << rc_cfg.failsafe_timeout_ms
                 << "ms 이상 미수신) -> 비상 정지.\n";
@@ -1230,7 +1368,7 @@ int main(int argc, char **argv) {
     // 3.1 브레이크 최우선 로직 (CH5) - 미수신(Fail-safe) 상태도 동일하게 처리
     bool brake_on = !rc_ok || (raw_brake >= rc_cfg.brake_threshold);
 
-    // 3.2 속도 제한 설정 (CH7)
+    // 3.2 속도 제한 설정 (CH6)
     float v_max_now = (raw_speed_mode >= rc_cfg.speed_threshold)
                            ? rc_cfg.v_max_low
                            : rc_cfg.v_max_high;
@@ -1239,17 +1377,18 @@ int main(int argc, char **argv) {
     float omega = 0.0f; // 각속도 rad/s
 
     if (!brake_on) {
-      // 3.3 전후진 속도 계산 (CH2)
+      // 3.3 전후진 속도 계산 (CH2) — 실측 결과 raw 값이 높을수록 전진(+),
+      // 낮을수록 후진(-)이라 CH1(조향)과는 반대 부호 방향이다.
       int t = std::clamp(raw_throttle, rc_cfg.throttle_min, rc_cfg.throttle_max);
       if (t >= rc_cfg.throttle_center_lo && t <= rc_cfg.throttle_center_hi) {
         v_x = 0.0f;
       } else if (t < rc_cfg.throttle_center_lo) {
-        v_x = (static_cast<float>(rc_cfg.throttle_center_lo - t) /
+        v_x = -(static_cast<float>(rc_cfg.throttle_center_lo - t) /
-               static_cast<float>(rc_cfg.throttle_center_lo - rc_cfg.throttle_min)) *
+                static_cast<float>(rc_cfg.throttle_center_lo - rc_cfg.throttle_min)) *
               v_max_now;
       } else {
-        v_x = -(static_cast<float>(t - rc_cfg.throttle_center_hi) /
+        v_x = (static_cast<float>(t - rc_cfg.throttle_center_hi) /
-                static_cast<float>(rc_cfg.throttle_max - rc_cfg.throttle_center_hi)) *
+               static_cast<float>(rc_cfg.throttle_max - rc_cfg.throttle_center_hi)) *
               v_max_now;
       }
 
@@ -1381,6 +1520,8 @@ int main(int argc, char **argv) {
     // 3.1 브레이크 최우선 로직 (CH5/Fail-safe): 저크 램프를 건너뛰고 즉시
     // 0으로 스냅 후 브레이크를 잠근다. 해제되면 STOPPED 상태에서 아래
     // 상태머신이 정상적으로 재가속을 시작한다.
+    // 전자식 브레이크(솔레노이드)는 오직 CH5로만 제어한다 — 스로틀을 중립으로
+    // 되돌려 자연 정지했을 때는 잠그지 않고, CH5를 눌렀을 때만 잠근다.
     if (brake_on && !prev_brake_on) {
       cmd_fl = cmd_fr = cmd_rl = cmd_rr = 0.0f;
       accel_fl = accel_fr = accel_rl = accel_rr = 0.0f;
@@ -1392,6 +1533,10 @@ int main(int argc, char **argv) {
       if (driver_rear_ptr)
         driver_rear_ptr->setBrakes(true);
       state = "STOPPED";
+    } else if (!brake_on && prev_brake_on) {
+      driver_front.setBrakes(false);
+      if (driver_rear_ptr)
+        driver_rear_ptr->setBrakes(false);
     }
     prev_brake_on = brake_on;
 
@@ -1399,10 +1544,6 @@ int main(int argc, char **argv) {
       // target_fl..rr은 이미 0(v_x=omega=0)이며 STOPPED 상태를 유지한다.
     } else if (state == "STOPPED") {
       if (std::abs(target_fl) > 0.1f || std::abs(target_fr) > 0.1f) {
-        driver_front.setBrakes(false);
-        if (driver_rear_ptr)
-          driver_rear_ptr->setBrakes(false);
-        std::this_thread::sleep_for(std::chrono::milliseconds(50));
         state = "RUNNING";
       }
     } else if (state == "RUNNING") {
@@ -1430,14 +1571,10 @@ int main(int argc, char **argv) {
       }
 
       float jerk_now = is_spin_turn ? spin_jerk_rate : jerk_rate;
-      cmd_fl = jerkLimitedStep(cmd_fl, target_fl, accel_fl, accel_rate,
+      cmd_fl = jerkLimitedStep(cmd_fl, target_fl, accel_fl, decel_rate, jerk_now);
-                               decel_rate, jerk_now);
+      cmd_fr = jerkLimitedStep(cmd_fr, target_fr, accel_fr, decel_rate, jerk_now);
-      cmd_fr = jerkLimitedStep(cmd_fr, target_fr, accel_fr, accel_rate,
+      cmd_rl = jerkLimitedStep(cmd_rl, target_rl, accel_rl, decel_rate, jerk_now);
-                               decel_rate, jerk_now);
+      cmd_rr = jerkLimitedStep(cmd_rr, target_rr, accel_rr, decel_rate, jerk_now);
-      cmd_rl = jerkLimitedStep(cmd_rl, target_rl, accel_rl, accel_rate,
-                               decel_rate, jerk_now);
-      cmd_rr = jerkLimitedStep(cmd_rr, target_rr, accel_rr, accel_rate,
-                               decel_rate, jerk_now);
 
       if (std::abs(target_fl) < 0.1f && std::abs(target_fr) < 0.1f &&
           std::abs(cmd_fl) < 0.5f && std::abs(cmd_fr) < 0.5f) {
@@ -1445,14 +1582,10 @@ int main(int argc, char **argv) {
       }
     } else if (state == "STOPPING") {
       float jerk_now = is_spin_turn ? spin_jerk_rate : jerk_rate;
-      cmd_fl = jerkLimitedStep(cmd_fl, target_fl, accel_fl, decel_rate,
+      cmd_fl = jerkLimitedStep(cmd_fl, target_fl, accel_fl, decel_rate, jerk_now);
-                               decel_rate, jerk_now);
+      cmd_fr = jerkLimitedStep(cmd_fr, target_fr, accel_fr, decel_rate, jerk_now);
-      cmd_fr = jerkLimitedStep(cmd_fr, target_fr, accel_fr, decel_rate,
+      cmd_rl = jerkLimitedStep(cmd_rl, target_rl, accel_rl, decel_rate, jerk_now);
-                               decel_rate, jerk_now);
+      cmd_rr = jerkLimitedStep(cmd_rr, target_rr, accel_rr, decel_rate, jerk_now);
-      cmd_rl = jerkLimitedStep(cmd_rl, target_rl, accel_rl, decel_rate,
-                               decel_rate, jerk_now);
-      cmd_rr = jerkLimitedStep(cmd_rr, target_rr, accel_rr, decel_rate,
-                               decel_rate, jerk_now);
 
       if (std::abs(cmd_fl) < 0.1f && std::abs(cmd_fr) < 0.1f) {
         cmd_fl = 0.0f;
@@ -1463,10 +1596,8 @@ int main(int argc, char **argv) {
         driver_front.setRPMs(0, 0);
         if (driver_rear_ptr)
           driver_rear_ptr->setRPMs(0, 0);
-        std::this_thread::sleep_for(std::chrono::milliseconds(50));
+        // 스로틀 중립 복귀로 인한 자연 정지: 전자식 브레이크는 잠그지 않는다
-        driver_front.setBrakes(true);
+        // (CH5를 눌렀을 때만 잠금 — 위 브레이크 최우선 로직 참고).
-        if (driver_rear_ptr)
-          driver_rear_ptr->setBrakes(true);
         state = "STOPPED";
       }
     }
@@ -1619,7 +1750,10 @@ int main(int argc, char **argv) {
       log_stream << t_ms << ',' << state << ',' << raw_steer << ','
                 << raw_throttle << ',' << (rc_ok ? 1 : 0) << ','
                 << (brake_on ? 1 : 0) << ',' << v_max_now << ',' << v_x << ','
-                << omega << ',' << cmd_fl << ',' << cmd_fr << ',' << cmd_rl
+                << omega << ',' << raw_ch[1] << ',' << raw_ch[2] << ','
+                << raw_ch[3] << ',' << raw_ch[4] << ',' << raw_ch[5] << ','
+                << raw_ch[6] << ',' << raw_ch[7] << ',' << raw_ch[8] << ','
+                << cmd_fl << ',' << cmd_fr << ',' << cmd_rl
                 << ',' << cmd_rr << ',' << fl_fb << ',' << fr_fb << ','
                 << rl_fb << ',' << rr_fb << ',' << fl_amp << ',' << fr_amp
                 << ',' << rl_amp << ',' << rr_amp << ',' << wheel_status_str[0]
@@ -1629,9 +1763,19 @@ int main(int argc, char **argv) {
                 << dist_axle << ',' << comm_ms << '\n';
     }
 
-    printf("\r\033[K[%-8s] RC:%s%s AXLE:%5.3fm | %-28s | I(A):FL%+4.1f FR%+4.1f "
+    // RC 조종기 입력값 피드백: 실기 조작 중 CH1~CH8 raw 값(CH5=브레이크 값
-          "RL%+4.1f RR%+4.1f | WHL(FL/FR/RL/RR):%s%s | %4.1fms",
+    // 직접 확인용 포함)과 그로부터 계산된 선속도/각속도 지령을 실시간으로
+    // 확인할 수 있도록 HUD에 표시한다.
+    const char *speed_mode_str =
+        (v_max_now <= rc_cfg.v_max_low + 0.001f) ? "LOW " : "HIGH";
+    printf("\r\033[K[%-8s] RC:%s%s "
+          "C1:%4d C2:%4d C3:%4d C4:%4d C5:%4d C6:%4d C7:%4d C8:%4d "
+          "SPD:%s VX:%+4.2f OMG:%+4.2f | AXLE:%5.3fm | %-28s | "
+          "I(A):FL%+4.1f FR%+4.1f RL%+4.1f RR%+4.1f | "
+          "WHL(FL/FR/RL/RR):%s%s | %4.1fms",
           state.c_str(), rc_ok ? "OK" : "LOST", brake_on ? "[BRK]" : "     ",
+          raw_ch[1], raw_ch[2], raw_ch[3], raw_ch[4], raw_ch[5], raw_ch[6],
+          raw_ch[7], raw_ch[8], speed_mode_str, v_x, omega,
           dist_axle, lidar_telemetry.c_str(), fl_amp, fr_amp,
           rl_amp, rr_amp, wheel_status_str,
           fault_active ? " [!!알람!!]" : "", comm_ms);