hsl's tsmaster 사용기

타이어 마모 인덱스

hsl7 — Fri, 10 Apr 2026 13:49:23 +0900

타이어 마모 인덱스¶

타이어는 언제 많이 마모될까?
- 휠 슬립율이 클 때
  - 같은 슬립율이라도 아스팔트, 코블스톤, 흙길, 자갈길 등 노면 종류에 따라 다를 것이다.
- 타이어에 걸리는 수직 하중이 클 때
  - 같은 슬립율이라도 수직 하중이 클 때 더 마모가 많이 될 것 같다.
- 코너링할 때
  - 사이드 슬립이 크면 많이 닿겠지.
- 그 외에 많은 다른 요인이 있을 것이다. 타이어 공기압, 온도, 비/눈, ...
- Tlog100x로 측정한 CAN 데이터와 GPS 데이터 처리하는 방법을 데모하는 목적이니까 단순하게 계산해본다.

휠 슬립율을 어떻게 구할까?

휠 슬립율은 아래와 같이 정의한다.

    r_slip_xx = (ws_xx - vs) / vs * 100
        ws: wheel_speed
        vs: vehicle_speed
        xx: fl, fr, rl, rr 
            fl: front left 
            fr: front right
            rl: rear left
            rr: rear right

vs는 어떻게 구할까?
- 여러 가지 옵션이 있다.
  - A: GPS 좌표를 이용해서 구한다.
  - B: CAN 신호들에서 구한다.
- A: GPS 좌표를 이용해서 구하기
  - 두 지점 (위도, 경도) 좌표들로 부터 거리를 구한다. 거리와 이동 시간을 이용해서 속도를 구한다.
  - 데모의 취지에 맞다.
  - GPS 신호가 갖고 있는 오차 때문에 충분히 정확하지 못할 것이다.
- B: CAN 신호들에서 구하기
  - 측정한 데이터에 ABS 작동 같은 깊은 휠 슬립이 발생하는 경우가 없다. 아래와 같이 한다.
  - 감속 중에는 가장 빠른 바퀴 속도를 vs로 하자.
  - 가속 중에는 가장 느린 바퀴 속도를 vs로 하자.
  - 선회 중일 때는 안쪽 바퀴와 바깥쪽 바퀴 속도 차이가 있으니까 ... 네 바퀴 속도 대신 앞축의 평균과 뒤축의 평균을 사용하여 가감속 상태를 고려하여 vs를 계산하자.
  - 가감속이 없을 때는 네 바퀴의 평균을 vs로 하자.
  - 가감속을 어떻게 판단할 것인가?
    - 얼핏 3가지 방법이 생각난다. A, B, C라고 하자.
    - 가감속 판단 A
      - Engine Speed와 Transmission Input Shaft Speed (TISS)를 비교한다.
      - engine_speed > tiss : 가속
      - engine_speed < tiss : 감속
      - 단순히 위와 같이 정의하면 가감속이 너무 자주 바뀌는 소위 busy state change 문제가 발생할 것이다. 이를 방지하기 위해서 히스테리시스가 필요하다.
      - 토크 컨버터가 잠겨 (lock) 직결될 수 있다. 이것도 고려해야 하는가? <-- 이 신호가 CAN에 없다.
    - 가감속 판단 B
      - 브레이크 마스터 실린더 압력 > 5 bar 이상일 때를 제동으로 본다.
      - 가속 페달 위치 > 2% 이상일 때를 구동으로 본다.
      - 브레이크도 밟지 않고 가속 페달도 밟지 않은 상태에서 엔진 브레이크로 감속하는 경우는?
      - 엔진과 연결된 바퀴들이 그렇지 않은 바퀴들 보다 더 마모 되지 않을까?
    - 가감속 판단 C
      - 엔진이 생산하는 토크와 엔진의 마찰 토크를 비교한다.
      - 엔진이 생산하는 토크: TQI
      - 엔진의 마찰 토크: TQFR <-- 이 신호가 CAN에 없다.
    - A 방법으로 해보자.

사전 준비¶

주행하면서 Tlog1004로 CAN 신호와 GPS 신호를 함께 저장한다.
Tlog1004에 저장된 데이터를 blf 파일로 다운로드 받는다.
TSMaster의 Log Converter 기능을 이용하여 blf 파일을 GPS 신호를 포함한 asc 파일로 변환한다.
전에 개발한 blf_asc_dbc_to_mdf_csv_mp_ctb.py를 이용하여 asc를 mdf로 변환한다. 변환할 때, 측정 주기를 100msec로 한다.

In [1]:

# modules

from pathlib import Path
import asammdf
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from scipy.signal import medfilt, butter, filtfilt
import numpy as np

mdf 파일 읽기¶

In [2]:

dir_current = Path.cwd()
path_mdf = dir_current / r'venue_2026-03-11_08-11-53_resampled_100ms.mf4'
mdf = asammdf.MDF(path_mdf)

In [3]:

# channels of interest
coi = [
    # 엔진 정보
    'EMS11__N',                         # engine speed
    'EMS12__PV_AV_CAN',                 # accelerator pedal position
    'EMS12__TQ_STND',                   # engine torque standard
    'EMS16__TQI',                       # engine torque
    'EMS16__TQI_MIN',                   # engine torque minimum
    'EMS16__TQI_MAX',                   # engine torque maximum

    # 기어 정보
    'TCU13__CF_Tcu_TarGr',              # gear (기어단)
    # 'TCU16__TCU_NCC_RPM',             # Transmission Input Shaft Speed? 항상 0이어서 제외 
    'TCU16__CF_Tcu_NCC_Stat',           # torque converter state으로 추정됨. 항상 일정해서 제외
    'TCU15__TCU_RPM_Cluster',           # Transmission Input Shaft Speed?
    'TCU14__CF_Tcu_DrivingModeReq',     # 항상 일정해서 제외
    'TCU14__CF_Tcu_DrivingModeDisp',    # 항상 일정해서 제외
    
    # 마스터 실린더 압력
    'ESP12__CYL_PRES',                  # brake pressure

    # 모션 유닛
    'ESP12__LONG_ACCEL',                # longitudinal acceleration
    'ESP12__LAT_ACCEL',                 # lateral acceleration
    'ESP12__YAW_RATE',                  # yaw rate

    # 바퀴 속도
    'WHL_SPD11__WHL_SPD_FL',            # wheel speed front left
    'WHL_SPD11__WHL_SPD_FR',            # wheel speed front right
    'WHL_SPD11__WHL_SPD_RL',            # wheel speed rear left
    'WHL_SPD11__WHL_SPD_RR',            # wheel speed rear right

    # GPS 정보
    'longitude',                        # longitude (경도)         
    'latitude',                         # latitude (위도)   
    'altitude'                          # altitude (고도)
]

# df로 변환한다. 
# 이렇게 쉽다니. blf_asc_dbc_to_mdf_csv_mp_ctb.py의 resampling 부분 코드를 수정해야겠다.  
df = mdf.to_dataframe(channels=coi)

# 컬럼 이름을 변경한다.
df.rename(
    columns={
        'timestamps': 'ts',                                     # timestamp. 인덱스. 인덱스라 rename이 안 된다.

        'EMS11__N': 'engine_speed',                             # engine speed
        'EMS12__PV_AV_CAN': 'aps',                              # accelerator pedal position  
        'EMS12__TQ_STND': 'engine_torque_stnd',                 # engine torque standard
        'EMS16__TQI': 'engine_torque',                          # engine torque  
        'EMS16__TQI_MIN': 'engine_torque_min',                  # engine torque minimum
        'EMS16__TQI_MAX': 'engine_torque_max',                  # engine torque maximum

        'TCU13__CF_Tcu_TarGr': 'gear',                          # gear (기어단)
        'TCU16__TCU_NCC_RPM': 'tiss',                           # Transmission Input Shaft Speed? 항상 0이어서 제외
        'TCU16__CF_Tcu_NCC_Stat': 'tc_stat',                    # torque converter state으로 추정됨. 항상 일정해서 제외
        'TCU15__TCU_RPM_Cluster': 'tiss',                       # Transmission Input Shaft Speed
        'TCU14__CF_Tcu_DrivingModeReq': 'driving_mode_req',     # 항상 일정해서 제외
        'TCU14__CF_Tcu_DrivingModeDisp': 'driving_mode_disp',   # 항상 일정해서 제외
        
        'ESP12__CYL_PRES': 'brake_pressure',                    # brake pressure  
        'ESP12__LONG_ACCEL': 'long_accel',                      # longitudinal acceleration
        'ESP12__LAT_ACCEL': 'lat_accel',                        # lateral acceleration
        'ESP12__YAW_RATE': 'yaw_rate',                          # yaw rate

        'WHL_SPD11__WHL_SPD_FL': 'ws_fl',                       # wheel speed front left
        'WHL_SPD11__WHL_SPD_FR': 'ws_fr',                       # wheel speed front right 
        'WHL_SPD11__WHL_SPD_RL': 'ws_rl',                       # wheel speed rear left
        'WHL_SPD11__WHL_SPD_RR': 'ws_rr',                       # wheel speed rear right
    }, 
    inplace=True
)

어떤 신호가 어떤 신호인지 그래프로 확인한다.¶

변속기 신호 확인¶

In [ ]:

# gear, tc_stat, tiss, driving_mode_req, driving_mode_disp, aps, ws_fl, brake_pressure를 
# 8 x 1 subplot으로 그려본다.


fig = make_subplots(rows=8, cols=1, shared_xaxes=True, vertical_spacing=0.02)
fig.add_trace(go.Scatter(x=df.index, y=df['ws_fl'], mode='lines', name='ws_fl'), row=1, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['brake_pressure'], mode='lines', name='brake_pressure'), row=2, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['aps'], mode='lines', name='aps'), row=3, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['gear'], mode='lines', name='gear'), row=4, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['tiss'], mode='lines', name='tiss'), row=5, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['tc_stat'], mode='lines', name='tc_stat'), row=6, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['driving_mode_req'], mode='lines', name='driving_mode_req'), row=7, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['driving_mode_disp'], mode='lines', name='driving_mode_disp'), row=8, col=1)
fig.update_layout(width=1000, height=1000, title_text="Transmission Signals Over Time")
fig.show()

발견 - 변속기 신호¶

tc_stat, driving_mode_req, driving_mode_disp'는 값이 항상 일정하다. 유용하지 않다.

엔진 신호 확인¶

In [ ]:

# 'engine_speed', 'aps', 'engine_torque', 'engine_torque_min', 'engine_torque_max' 
# 신호들을 5 x 1 subplot으로 그려본다.

fig = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.02)
fig.add_trace(go.Scatter(x=df.index, y=df['engine_speed'], mode='lines', name='engine_speed'), row=1, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['aps'], mode='lines', name='aps'), row=2, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['engine_torque_stnd'], mode='lines', name='engine_torque_stnd'), row=3, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['engine_torque'], mode='lines', name='engine_torque'), row=3, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['engine_torque_min'], mode='lines', name='engine_torque_min'), row=3, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['engine_torque_max'], mode='lines', name='engine_torque_max'), row=3, col=1)
fig.update_layout(width=1000, height=600, title_text="Engine Signals Over Time")   
fig.show()

발견 - 엔진 신호¶

위 엔진 토크 신호들로는 가감속을 판정할 수 없다.

가감속 상태 계산¶

토크 컨버터 슬립 (torque converter slip)으로 가감속 상태를 판정한다.

In [6]:

df['slip_tc'] = df['engine_speed'] - df['tiss']

In [ ]:

# 2 x 1 subplot으로 engine_speed, tiss, slip_tc를 그려본다.
# 슬라이더를 추가하여 시간 범위를 조절할 수 있도록 한다.

fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.02)
fig.add_trace(go.Scatter(x=df.index, y=df['engine_speed'], mode='lines', line=dict(dash='dash'), name='engine_speed'), row=1, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['tiss'], mode='lines', line=dict(dash='dash'), name='tiss'), row=1, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['slip_tc'], mode='lines', name='slip_tc'), row=2, col=1)
fig.update_layout(width=1000, height=500, title_text="Engine Speed, TISS, and Torque Converter Slip Over Time")
fig.update_xaxes(rangeslider_visible=False, row=1, col=1)
fig.update_xaxes(rangeslider_visible=True, row=2, col=1)
fig.show()

In [8]:

df['slip_tc_sign_change'] = np.sign(df['slip_tc']).diff().fillna(0).abs()

# 전체 데이터 수
total_data_points = len(df)
print(f'{total_data_points = :,}')

# slip_tc의 부호는 얼마나 자주 바뀌는가?
num_sign_changes = df['slip_tc_sign_change'].sum()
print(f'{num_sign_changes = :,.0f}')

# slip_tc 부호가 바뀐 비율
sign_change_rate = num_sign_changes / total_data_points
print(f'{sign_change_rate = :.1%}')
print()

df["slip_tc"].describe()

total_data_points = 28,793
num_sign_changes = 19,420
sign_change_rate = 67.4%

Out[8]:

count    28793.000000
mean         0.003647
std          2.511806
min        -42.500000
25%         -0.500000
50%          0.000000
75%          0.500000
max         38.000000
Name: slip_tc, dtype: float64

발견 - 가감속 상태¶

엔진 속도 (engine_speed)와 변속기 입력축 속도 (tiss: transmission input shaft speed)의 차이인 토크 컨버터 슬립(slip_tc: torque converter slip)이 두 신호에 비해 작아서 그래프에서 두 신호가 겹쳐보인다.
토크 컨버터 슬립의 평균은 거의 0 rpm 이다. 표준 편차는 2.5 rpm이다.
토크 컨버터 슬립의 부호가 너무 자주 (전체 데이터의 67%) 바뀐다. 즉, 가감속 상태 변화가 너무 심하다. 필터가 필요하다.

토크 컨버터 슬립 필터하기¶

ai의 추천에 따라 median 필터와 butter 필터를 적용한다.
나는 위 두 필터가 어떤 원리인지 모른다. :-)

In [9]:

# 샘플링 주파수 추정 (숫자 index/시간 index 모두 지원)
didx = df.index.to_series().diff().dropna()
if pd.api.types.is_timedelta64_dtype(didx):
    dt = didx.dt.total_seconds().median()
else:
    dt = float(didx.median())
fs = 1.0 / dt

# 1) 스파이크 제거
x = medfilt(df['slip_tc'].to_numpy(), kernel_size=7)

# 2) 저역통과 필터 (zero-phase)
b, a = butter(N=4, Wn=1.0 / (fs / 2), btype='low')
df['slip_tc_filt'] = filtfilt(b, a, x)

In [ ]:

# slip_tc와 slip_tc_filt를 그래프로 비교한다.
px.line(
    df,
    x=df.index,
    y=['slip_tc', 'slip_tc_filt'],
    title='Torque Converter Slip (Raw vs Filtered)',
    labels={'value': 'RPM', 'ts': 'Time'},
    width=1000,
    height=600
)

In [11]:

df['slip_tc_filt_sign_change'] = np.sign(df['slip_tc_filt']).diff().fillna(0).abs()

# 전체 데이터 수
total_data_points = len(df)
print(f'{total_data_points = :,.0f}')

# slip_tc_filt의 부호는 얼마나 자주 바뀌는가?
num_sign_changes = df['slip_tc_filt_sign_change'].sum()
print(f'{num_sign_changes = :,.0f}')

# slip_tc_filt 부호가 바뀐 비율
sign_change_rate = num_sign_changes / total_data_points
print(f'{sign_change_rate = :.1%}')
print()

df["slip_tc_filt"].describe()

total_data_points = 28,793
num_sign_changes = 7,550
sign_change_rate = 26.2%

Out[11]:

count    2.879300e+04
mean     8.022783e-03
std      1.097424e+00
min     -1.398160e+01
25%     -8.988829e-02
50%     -3.938577e-72
75%      4.936604e-02
max      1.242765e+01
Name: slip_tc_filt, dtype: float64

발견 - slip_tc_filt¶

토크 컨버터 슬립의 평균은 거의 0 rpm 이다. 표준 편차는 1.1 rpm이다.
토크 컨버터 슬립의 부호 변동이 필터 적용 전 64%에서 필터 적용 후 26%로 감소하였다.

차속 구하기 - B: CAN 신호들에서 구하기¶

In [12]:

df['slip_tc_filt'].describe()

Out[12]:

count    2.879300e+04
mean     8.022783e-03
std      1.097424e+00
min     -1.398160e+01
25%     -8.988829e-02
50%     -3.938577e-72
75%      4.936604e-02
max      1.242765e+01
Name: slip_tc_filt, dtype: float64

In [13]:

def classify_slip_tc(slip, k_rpm_slip_acceleration=1.1, k_rpm_slip_deceleration=-1.1):
    '''
    slip이 k_rpm_slip_acceleration 이상이면 가속으로 인한 슬립이 발생한 상태로 생각하고 sign_slip을 1로 한다.
    slip이 k_rpm_slip_deceleration 이하이면 감속으로 인한 슬립이 발생한 상태로 생각하고 sign_slip을 -1로 한다.
    그 사이면 slip이 없는 상태로 간주하고 sign_slip을 0으로 한다.
    k_rpm_slip_acceleration과 k_rpm_slip_deceleration은 각각 가속과 감속으로 인한 슬립을 판단하는 기준값이다. slip_tc_filt의 표준 편차를 적용한다. 
    '''

    if slip > k_rpm_slip_acceleration:
        return 1
    elif slip < k_rpm_slip_deceleration:
        return -1
    else:
        return 0

df['sign_slip'] = df['slip_tc_filt'].apply(classify_slip_tc)

In [14]:

yaw_rate_summary = df['yaw_rate'].describe()
yaw_rate_summary

Out[14]:

count    28793.000000
mean         1.446362
std          4.728123
min        -35.860000
25%          0.730000
50%          0.870000
75%          1.100000
max         35.330000
Name: yaw_rate, dtype: float64

In [15]:

def classify_turning(yaw_rate, yaw_rate_mean, yaw_rate_std):
    '''
    abs(yaw_rate)가 k_deg_per_sec_turning 이상이면 선회라고 생각하고 is_turning을 True로 한다. 그렇지 않으면 False로 한다.
    k_deg_per_sec_turning은 선회 여부를 판단하는 기준값이다. yaw_rate의 표준 편차를 적용한다.
    '''
    k_deg_per_sec_turning = yaw_rate_std * 0.5  # 필요에 따라 조정
    return k_deg_per_sec_turning if abs(yaw_rate - yaw_rate_mean) >= k_deg_per_sec_turning else 0   

yaw_rate_mean = df['yaw_rate'].mean()
yaw_rate_std = df['yaw_rate'].std()
df['is_turning'] = df['yaw_rate'].apply(classify_turning, args=(yaw_rate_mean, yaw_rate_std))

In [16]:

def calc_vs(df):
    '''
    vehicle speed를 구한다. 
    sign_slip이 0이면 slip이 없는 상태이므로, wheel speed의 평균을 vehicle speed로 간주한다.
    is_turning이 False 이고 sign_slip이 양수이면 가속으로 인한 슬립이 발생한 상태이므로, min(ws_fl, ws_fr, ws_rl, ws_rr)를 vehicle speed로 간주한다.
    is_turning이 True 이고 sign_slip이 양수이면 선회로 인한 슬립이 발생한 상태이므로, min(mean(ws_fl, ws_fr), mean(ws_rl, ws_rr))를 vehicle speed로 간주한다.
    is_turning이 False 이고 sign_slip이 음수이면 감속으로 인한 슬립이 발생한 상태이므로, max(ws_fl, ws_fr, ws_rl, ws_rr)를 vehicle speed로 간주한다.
    is_turning이 True 이고 sign_slip이 음수이면 선회로 인한 슬립이 발생한 상태이므로, max(mean(ws_fl, ws_fr), mean(ws_rl, ws_rr))를 vehicle speed로 간주한다. (추후에 추가할 수 있도록 주석으로 남겨둔다.)
    '''

    df['vs'] = (df['ws_fl'] + df['ws_fr'] + df['ws_rl'] + df['ws_rr']) / 4

    df.loc[(df['sign_slip'] > 0) & (df['is_turning'] == 0), 'vs'] = df[['ws_fl', 'ws_fr', 'ws_rl', 'ws_rr']].min(axis=1)
    df.loc[(df['sign_slip'] > 0) & (df['is_turning'] != 0), 'vs'] = df[['ws_fl', 'ws_fr']].mean(axis=1).combine(df[['ws_rl', 'ws_rr']].mean(axis=1), min)
    df.loc[(df['sign_slip'] < 0) & (df['is_turning'] == 0), 'vs'] = df[['ws_fl', 'ws_fr', 'ws_rl', 'ws_rr']].max(axis=1)
    df.loc[(df['sign_slip'] < 0) & (df['is_turning'] != 0), 'vs'] = df[['ws_fl', 'ws_fr']].mean(axis=1).combine(df[['ws_rl', 'ws_rr']].mean(axis=1), max)       

    return df

df = calc_vs(df)

In [ ]:

# vs, ws_fl, ws_fr, ws_rl, ws_rr와 yaw_rate와 slip_tc_filt를 서브프롯으로 그린다.

fig = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.02)
fig.add_trace(go.Scatter(x=df.index, y=df['vs'], mode='lines', name='vs'), row=1, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['ws_fl'], mode='lines', name='ws_fl'), row=1, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['ws_fr'], mode='lines', name='ws_fr'), row=1, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['ws_rl'], mode='lines', name='ws_rl'), row=1, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['ws_rr'], mode='lines', name='ws_rr'), row=1, col=1)

fig.add_trace(go.Scatter(x=df.index, y=df['yaw_rate'], mode='lines', name='yaw_rate'), row=2, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['is_turning'], mode='lines', name='is_turning'), row=2, col=1)

fig.add_trace(go.Scatter(x=df.index, y=df['slip_tc_filt'], mode='lines', name='slip_tc_filt'), row=3, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['sign_slip'], mode='lines', name='sign_slip'), row=3, col=1)

fig.update_layout(width=1000,height=700, title_text="Vehicle Speed, Wheel Speeds, Yaw Rate, and Torque Converter Slip Over Time")
fig.update_xaxes(rangeslider_visible=False, row=1, col=1)
fig.update_xaxes(rangeslider_visible=False, row=2, col=1)
fig.update_xaxes(rangeslider_visible=True, row=3, col=1)
fig.show()

발견 - vs¶

vs가 너무 거친 구간들이 있다.
vs를 필터링한다.

차속 필터하기¶

In [18]:

# 저역통과 필터
b_vs, a_vs = butter(N=2, Wn=0.8 / (fs / 2), btype='low')
df['vs_filt'] = filtfilt(b_vs, a_vs, df['vs'].to_numpy())

In [ ]:

# vs와 vs_filt를 그래프로 비교한다.
px.line(
    df,
    x=df.index,
    y=['vs', 'vs_filt'],
    title='Vehicle Speed: Raw vs Filtered',
    labels={'value': 'Speed (km/h)', 'ts': 'Time'},
    width=1000,
    height=600
)

발견 - vs_filt¶

확대하면 아래 그림과 같다.
vs_filt를 사용하기로 한다.
현재 개념을 수립하는 단계이다. 위 필터가 왜 적합한지 따지는 것은 2차 관심사이다.

차속 구하기 - A: GPS 좌표를 이용하여 구한다.¶

In [20]:

def haversine_distance(lat1, lon1, lat2, lon2):
    """
    Calculate distance between two GPS coordinates using Haversine formula (in meters)
    
    Parameters:
    lat1, lon1: Latitude and longitude of first point (in degrees)
    lat2, lon2: Latitude and longitude of second point (in degrees)
    
    Returns:
    distance: Distance between two points (in meters)
    """
    # Earth radius (meters)
    R = 6371000
    
    # Convert degrees to radians
    lat1_rad = np.radians(lat1)
    lat2_rad = np.radians(lat2)
    delta_lat = np.radians(lat2 - lat1)
    delta_lon = np.radians(lon2 - lon1)
    
    # Haversine formula
    a = np.sin(delta_lat/2)**2 + np.cos(lat1_rad) * np.cos(lat2_rad) * np.sin(delta_lon/2)**2
    c = 2 * np.arctan2(np.sqrt(a), np.sqrt(1-a))
    distance = R * c
    
    return distance

In [21]:

# latitude, longitude 컬럼의 이웃한 좌표 간의 거리를 계산하여 distance 컬럼에 저장한다.

# 좌표의 이전 행 데이터를 준비하기 위해 shift를 사용한다.
df.loc[:, 'lat_prev'] = df.loc[:, 'latitude'].shift(1)
df.loc[:, 'lon_prev'] = df.loc[:, 'longitude'].shift(1)

# 첫 번째 행 제거 (이전 데이터 없음)
df = df.dropna()

df.loc[:, 'd_lat'] = df.loc[:, 'latitude'] - df.loc[:, 'lat_prev']
df.loc[:, 'd_lon'] = df.loc[:, 'longitude'] - df.loc[:, 'lon_prev']

In [ ]:

px.line(
    df,
    x=df.index,
    y=['d_lat', 'd_lon'],
    title='Change in Latitude and Longitude Over Time',
    labels={'value': 'Degrees', 'ts': 'Time'},
    width=1000,
    height=600
)

발견 - GPS 신호와 resample¶

확대하면 아래와 같다.
GPS 좌표가 포함된 asc 파일을 mdf 파일로 변환할 때, 리샘플을 하였다. 리샘플의 주기가 실제 GPS 좌표 측정 주기보다 짧다. 새 행들이 추가되었고, 그 값들은 ffill로 채워졌다. 그 결과 새로 도입된 행들만큼 d_lat, d_long이 0인 행들이 있다.
가장 이상적인 방법은 asc를 mdf로 변환할 때, distance_gps와 speed_gps를 계산하는 것이다.
지금은 어떻게 처리하면 좋을까? ai와 대응책을 물었다. 아래와 같이 데이터 처리를 시도한다.

In [23]:

# 가정: df 인덱스가 datetime, 컬럼은 latitude/longitude
# 1) 실제 GPS 갱신 여부 판단 (부동소수 오차 대응용 tolerance)
eps = 1e-10
gps_changed = (
    (df["latitude"].diff().abs() > eps) |
    (df["longitude"].diff().abs() > eps)
)
# 첫 행은 기준점으로 포함
gps_changed.iloc[0] = True

gps = df.loc[gps_changed, ["latitude", "longitude"]].copy()

# 2) GPS 갱신 시점끼리 거리 계산
gps["lat_prev"] = gps["latitude"].shift(1)
gps["lon_prev"] = gps["longitude"].shift(1)

gps["distance_m"] = haversine_distance(
    gps["lat_prev"].values,
    gps["lon_prev"].values,
    gps["latitude"].values,
    gps["longitude"].values
)
gps["distance_m"] = gps["distance_m"].fillna(0)

# 3) GPS 갱신 간 dt로 속도 계산
idx_series = gps.index.to_series()
if pd.api.types.is_datetime64_any_dtype(gps.index) or pd.api.types.is_timedelta64_dtype(gps.index):
    dt = idx_series.diff().dt.total_seconds()
else:
    dt = pd.Series(pd.to_numeric(pd.Index(gps.index), errors="coerce"), index=gps.index).diff()

dt = dt.replace(0, np.nan)

gps["vs_gps_mps"] = (gps["distance_m"] / dt).replace([np.inf, -np.inf], np.nan)
gps["vs_gps_mps"] = gps["vs_gps_mps"].fillna(0)

# 4) 전체 리샘플 프레임으로 매핑
df["distance_m_step"] = 0.0
df.loc[gps.index, "distance_m_step"] = gps["distance_m"]

df["distance_m_cum"] = df["distance_m_step"].cumsum()

# 속도 표현 선택:
# A) 계단형 유지(마지막 GPS 속도 유지)
df["vs_gps_kph_ffill"] = np.nan
df.loc[gps.index, "vs_gps_kph_ffill"] = gps["vs_gps_mps"] * 3.6
df["vs_gps_kph_ffill"] = df["vs_gps_kph_ffill"].ffill().fillna(0)

# B) 선형 보간(원하면)
df["vs_gps_kph_interp"] = np.nan
df.loc[gps.index, "vs_gps_kph_interp"] = gps["vs_gps_mps"] * 3.6
df["vs_gps_kph_interp"] = df["vs_gps_kph_interp"].interpolate().fillna(0)

In [ ]:

# GPS 속도 비교 그래프
px.line(
    df,
    x=df.index,
    y=['vs_filt', 'vs_gps_kph_ffill', 'vs_gps_kph_interp'],
    title='GPS Speed: Forward-Filled vs Interpolated',
    labels={'value': 'Speed (kph)', 'ts': 'Time'},
    width=1000,
    height=600
)

발견 - vs_gps¶

시동을 걸면 Tlog100x가 즉시 데이터 저장을 시작한다.
지하 주차장에서 출발하여 지상으로 올라와서 Tlog100x가 GPS 신호를 잡을 때까지 차속을 계산할 수 없다는 단점이 있다.
계산된 차속이 거칠고, 정차(0kph) 할 때, 차속 왜곡 기간이 지나치게 길 수 있다.
asc -> mdf 변환 시에 차속 계산을 하는 것으로 하고, 여기서는 CAN 신호 기반 차속 신호를 이용한다.

바퀴 슬립율 구하기¶

In [25]:

df['r_slip_fl'] = (df['ws_fl'] - df['vs_filt']) / df['vs_filt'] * 100
df['r_slip_fr'] = (df['ws_fr'] - df['vs_filt']) / df['vs_filt'] * 100
df['r_slip_rl'] = (df['ws_rl'] - df['vs_filt']) / df['vs_filt'] * 100
df['r_slip_rr'] = (df['ws_rr'] - df['vs_filt']) / df['vs_filt'] * 100

# vs_filt가 낮은 경우, slip 계산이 불안정할 수 있으므로, vs_filt가 k_speed_too_low 미만인 경우 slip을 0으로 간주한다.
k_speed_too_low = 2.5  # km/h, 필요에 따라 조정
df.loc[df['vs_filt'] < k_speed_too_low, ['r_slip_fl', 'r_slip_fr', 'r_slip_rl', 'r_slip_rr']] = 0

In [ ]:

# slip_fl, slip_fr, slip_rl, slip_rr를 서브플롯으로 그린다.
fig = make_subplots(rows=5, cols=1, shared_xaxes=True, vertical_spacing=0.02)
fig.add_trace(go.Scatter(x=df.index, y=df['r_slip_fl'], mode='lines', name='slip_fl'), row=1, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['r_slip_fr'], mode='lines', name='slip_fr'), row=2, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['r_slip_rl'], mode='lines', name='slip_rl'), row=3, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['r_slip_rr'], mode='lines', name='slip_rr'), row=4, col=1)
fig.add_trace(go.Scatter(x=df.index, y=df['yaw_rate'], mode='lines', name='yaw_rate'), row=5, col=1)
fig.update_layout(width=1000, height=1100, title_text="Wheel Slip Ratios Over Time")
fig.update_xaxes(rangeslider_visible=True, row=5, col=1)
fig.show()

발견 - 슬립률과 선회¶

선회 구간에서 바퀴 슬립율이 높다.
선회 시에는 가중치를 낮추야 하는 것인가?

타이어 마모 인덱스¶

타이어는 마모 인덱스라는 것을 만든다.
타이어마다 개별적으로 있어야 하겠지.
슬립율을 적분해서 만들면 될 것 같다.
슬립율은 음수여도 인덱스는 증가하도록 계산식을 만들어야 한다.
슬립율에 가중치가 적용되어 마모 인덱스가 계산되도록 해야겠다.

In [46]:

# 선회 중 바퀴 슬립률의 통계량을 구한다.
turning_slip_stats = df[df['is_turning'] != 0][['r_slip_fl', 'r_slip_fr', 'r_slip_rl', 'r_slip_rr']].describe()
turning_slip_stats

Out[46]:

	r_slip_fl	r_slip_fr	r_slip_rl	r_slip_rr
count	3654.000000	3654.000000	3654.000000	3654.000000
mean	-0.601213	2.703639	-2.606825	0.868139
std	4.560471	5.562668	5.849281	4.666240
min	-12.366665	-9.246471	-30.474144	-22.942318
25%	-3.373488	-0.202702	-4.952815	-0.622306
50%	-0.146422	0.594971	-0.613929	0.148466
75%	0.615643	4.743949	0.188193	3.330762
max	29.132756	27.226436	17.747275	17.527176

In [28]:

# 선회가 아닌 중 바퀴 슬립률의 통계량을 구한다.
non_turning_slip_stats = df[df['is_turning'] == 0][['r_slip_fl', 'r_slip_fr', 'r_slip_rl', 'r_slip_rr']].describe()
non_turning_slip_stats

Out[28]:

	r_slip_fl	r_slip_fr	r_slip_rl	r_slip_rr
count	25138.000000	25138.000000	25138.000000	25138.000000
mean	0.129247	0.192052	-0.180969	-0.123421
std	0.493932	0.528245	0.520399	0.511055
min	-7.891926	-7.877434	-12.601392	-9.648983
25%	0.000000	0.000000	-0.338130	-0.273805
50%	0.000000	0.041585	-0.073588	-0.015805
75%	0.284475	0.357648	0.000000	0.000000
max	15.463468	12.169217	12.133596	11.509765

In [29]:

turning_slip_stats.loc['mean'] / non_turning_slip_stats.loc['mean']

Out[29]:

r_slip_fl   NaN
r_slip_fr   NaN
r_slip_rl   NaN
r_slip_rr   NaN
Name: mean, dtype: float64

발견 - turning¶

turning 일 때 r_slip_xx가 turning이 아닐 때 대비 차이가 크다.
turning 일 때 r_slip_xx를 제한한다.

In [30]:

# 튜닝 파라미터
k_r_slip_deadzone = 0.01 # 마모가 없다고 설정한 슬립 비율 기준
k_slip_power = 2.0 # >1 이면 큰 슬립에 더 큰 패널티
k_speed_min_kmh = 2.5 # 저속 구간 제외 기준
k_limit_factor_r_slip_in_turning = 2 # 선회 중 슬립이 과대평가되는 것을 보정하는 계수 (필요에 따라 조정 가능)

def wear_increment_from_slip(r_slip_xx: pd.Series, r_slip_max_no_turning: float) -> pd.Series:
    '''
    slip_series: 슬립 비율 시리즈 (예: r_slip_fl)

    앞뒤 바퀴의 수직 하중 차이가 고려되야 한다. 
    동일한 슬립율이라도 수직 하중이 큰 바퀴에서의 마모 증가량이 더 클 것이다. 
    앞 바퀴 하중 : 뒷 바퀴 하중 = 6 : 4 로 한다. 
    즉, 앞바퀴는 슬립으로 인한 마모 증가량이 1.5배가 된다. (필요에 따라 조정 가능)

    return: 슬립으로 인한 마모 증가량 시리즈 (0 이상)
    '''

    # 1) 절대값 사용: 양/음 슬립 모두 마모 증가
    r_slip_abs = r_slip_xx.abs()

    # 2) 데드존: 미소 슬립 노이즈 제거
    r_slip_eff = (r_slip_abs - k_r_slip_deadzone).clip(lower=0.0)

    # 3) 선회 중 r_slip이 크게 계산된다. 
    # 선회 여부 시 r_slip_eff를 보정한다. 
    r_slip_eff = r_slip_eff.where(df['is_turning'] > 0, r_slip_max_no_turning * k_limit_factor_r_slip_in_turning)  
    

    # 4) 수직 하중 가중 (앞바퀴 1.5배, 뒷바퀴 1.0배)
    if 'fl' in r_slip_xx.name:
        r_slip_eff *= 1.5
    elif 'rl' in r_slip_xx.name:
        r_slip_eff *= 1.0
    elif 'fr' in r_slip_xx.name:
        r_slip_eff *= 1.5
    elif 'rr' in r_slip_xx.name:
        r_slip_eff *= 1.0
    
    # 5) 비선형 가중
    severity = r_slip_eff.pow(k_slip_power)
    
    # 6) 시간 적분
    inc = severity * dt
    
    return inc.where(valid_speed, 0.0)

In [31]:

# 인덱스에서 dt[s] 계산 (timedelta index / numeric index 모두 지원)
didx = df.index.to_series().diff()
if pd.api.types.is_timedelta64_dtype(didx):
    dt = didx.dt.total_seconds().fillna(0.0)
else:
    dt = didx.astype(float).fillna(0.0)

# 유효 속도 마스크
valid_speed = df["vs_filt"] >= k_speed_min_kmh

# 타이어별 누적 인덱스 계산
for wheel in ["fl", "fr", "rl", "rr"]:
    col_r_slip = f"r_slip_{wheel}"
    col_inc = f"wear_inc_{wheel}"
    col_idx = f"wear_idx_{wheel}"

    r_slip_max_no_turning = df.loc[df['is_turning'] == 0, col_r_slip].max()

    df[col_inc] = wear_increment_from_slip(df[col_r_slip], r_slip_max_no_turning)
    df[col_idx] = df[col_inc].cumsum()

In [32]:

def plot_wear_index(df):

    color_map = {
        "fl": "#1f77b4",
        "fr": "#d62728",
        "rl": "#2ca02c",
        "rr": "#ff7f0e"
    }

    fig = make_subplots(
        rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.08,
        subplot_titles=(
            "Vehicle Speed (filtered)",
            "Wheel Slip Ratios",
            "Tire Wear Estimation Index"
        )
    )


    fig.add_trace(
        go.Scatter(
            x=df.index,
            y=df["vs_filt"],
            mode="lines",
            name="vs_filt",
            line=dict(color="#444444", width=2)
        ),
        row=1, col=1
    )

    for wheel in ["fl", "fr", "rl", "rr"]:
        fig.add_trace(
            go.Scatter(
                x=df.index,
                y=df[f"r_slip_{wheel}"],
                mode="lines",
                name=f"slip_{wheel}",
                line=dict(color=color_map[wheel], width=1.8)
            ),
            row=2, col=1
        )

    for wheel in ["fl", "fr", "rl", "rr"]:
        fig.add_trace(
            go.Scatter(
                x=df.index,
                y=df[f"wear_idx_{wheel}"],
                mode="lines",
                name=f"wear_idx_{wheel}",
                line=dict(color=color_map[wheel], width=2.2)
            ),
            row=3, col=1
        )

    fig.update_yaxes(title_text="km/h", row=1, col=1)
    fig.update_yaxes(title_text="slip ratio", row=2, col=1)
    fig.update_yaxes(title_text="wear index", row=3, col=1)

    # rangeslider를 맨 아래 서브플롯에만 표시
    fig.update_xaxes(rangeslider_visible=False, row=1, col=1)
    fig.update_xaxes(rangeslider_visible=False, row=2, col=1)
    fig.update_xaxes(rangeslider_visible=False,  row=3, col=1)

    fig.update_layout(
        width=1000,
        height=600, 
        title_text="Vehicle Speed and Tire Wear Estimation",
        legend_title_text="Signals"
    )

    return fig

In [ ]:

plot_wear_index(df).show()

타이어 마모 인덱스와 고도¶

In [34]:

def plot_wear_index_with_altitude(df):
    # altitude와 wear_idx_fl의 관계를 산점도로 그려본다.
    # 두 그래프의 스케이일이 많이 다르므로 y축을 각각 따로 만들어서 그려본다.

    fig = make_subplots(
        rows=1, cols=1, shared_xaxes=True,
        specs=[[{"secondary_y": True}]],
        subplot_titles=["Altitude vs Front Left Tire Wear Index"]
    )
    fig.add_trace(
        go.Scatter(
            x=df.index,
            y=df["altitude"],
            mode="lines",
            name="altitude",
            line=dict(color="#888888", width=2)
        ),
        row=1, col=1, secondary_y=False
    )
    fig.add_trace(
        go.Scatter(
            x=df.index,
            y=df["wear_idx_fl"],
            mode="lines",
            name="wear_idx_fl",
            line=dict(color="#1f77b4", width=2)
        ),
        row=1, col=1, secondary_y=True
    )
    fig.update_yaxes(title_text="Altitude (m)", row=1, col=1, secondary_y=False)
    fig.update_yaxes(title_text="Front Left Tire Wear Index", row=1, col=1, secondary_y=True)
    fig.update_layout(
        width=1000,
        height=600, 
        title_text="Altitude and Front Left Tire Wear Index Over Time",
        legend_title_text="Signals"
    )   

    return fig

In [ ]:

plot_wear_index_with_altitude(df).show()

발견 - 산을 넘을 때 타이어가 많이 닿지 않을까?¶

그래프를 보면 1500 ~ 2000초 구간에서 산을 넘어간다. 나는 이 구간에서 타이어 마모가 많을 것으로 생각했다. 그런데 타이어 마모 인덱스를 보면 인덱스의 증가가 거의 없다.
경사를 마모에 반영해 보자.

경사도 구하기¶

vs_filt를 미분하여 종가속도 long_accel_vs를 구한다.
측정된 신호 long_accel과 long_accel_vs의 차이 diff_long_accel을 구한다.
이 차이를 경사도로 볼 수 있을까?

In [ ]:

px.line(
    df,
    x=df.index,
    y='long_accel',
    title='Longitudinal Acceleration Over Time',
    labels={'long_accel': 'Longitudinal Acceleration (m/s²)', 'ts': 'Time'},
    width=1000,  
    height=600
)

발견 - long_accel 노이즈¶

long_accel에 노이즈가 많다. 필터링한다.

In [37]:

# long_accel에 노이즈가 많다. 필터링한다. 
b_la, a_la = butter(N=3, Wn=1.0 / (fs / 2), btype='low')
df['long_accel_filt'] = filtfilt(b_la, a_la, df['long_accel'].to_numpy())

# vs_filt를 미분하여 종가속도 long_accel_vs를 구한다.
df['long_accel_vs'] = df['vs_filt'].mul(1000 / 3600).diff() / dt

# 측정된 신호 long_accel과 long_accel_vs의 차이 diff_long_accel을 구한다. 
df['diff_long_accel'] = df['long_accel_filt'] - df['long_accel_vs']

# 이 차이를 경사도 지표로 볼 수 있을까?  
df['diff_long_accel'] = df['diff_long_accel'].fillna(df['diff_long_accel'].mean())  # 첫 번째 값은 diff 계산이 안되므로 두 번째 값으로 채운다.

# diff_long_accel에도 노이즈가 많다. 필터링한다.
b_la, a_la = butter(N=4, Wn=0.1 / (fs / 2), btype='low')
df['diff_long_accel_filt'] = filtfilt(b_la, a_la, df['diff_long_accel'].to_numpy())

In [ ]:

px.line(
    df,
    x=df.index,
    y=['long_accel', 'long_accel_filt', 'long_accel_vs'],
    title='Longitudinal Acceleration Over Time',
    labels={'long_accel_filt': 'Longitudinal Acceleration (m/s²)', 'long_accel': 'Longitudinal Acceleration (m/s²)', 'ts': 'Time'},
    width=1000,  
    height=600
)

발견 - long_accel_filt¶

그래프를 확대하면 아래와 같다.
필터를 적용한 long_accel_filt가 적당히 매끄러워 보인다.
이 신호를 사용하기로 한다.

In [39]:

def plot_diff_long_accel_and_altitude(df):

    # long_accel, long_accel_vs, diff_long_accel, altitude를 3 x 1 subplot으로 그려본다.
    fig = make_subplots(
        rows=3, cols=1, shared_xaxes=True,
        subplot_titles=["Longitudinal Acceleration: Measured vs Estimated", "Difference in Longitudinal Acceleration", "Altitude"]
    )
    fig.add_trace(
        go.Scatter(
            x=df.index,
            y=df["long_accel_filt"],
            mode="lines",
            name="long_accel_filt (measured)",
            line=dict(color="#d62728", width=2)
        ),
        row=1, col=1
    )   
    fig.add_trace(
        go.Scatter(
            x=df.index,
            y=df["long_accel_vs"],
            mode="lines",
            name="long_accel_vs (from vehicle speed)",
            line=dict(color="#1f77b4", width=2)
        ),
        row=1, col=1
    )
    fig.add_trace(
        go.Scatter(
            x=df.index,
            y=df["diff_long_accel_filt"],
            mode="lines",
            name="diff_long_accel_filt",
            line=dict(color="#2ca02c", width=2)
        ),
        row=2, col=1
    )

    fig.add_trace(
        go.Scatter(
            x=df.index,
            y=df["altitude"],
            mode="lines",
            name="altitude",
            line=dict(color="#888888", width=1.5, dash='dot')
        ),
        row=3, col=1
    )

    fig.update_yaxes(title_text="Longitudinal Acceleration (m/s²)", row=1, col=1)
    fig.update_yaxes(title_text="Difference in Longitudinal Acceleration (m/s²)", row=2, col=1)
    fig.update_yaxes(title_text="Altitude (m)", row=3, col=1)
    fig.update_layout(
        width=1000,
        height=600, 
        title_text="Longitudinal Acceleration Comparison",
        legend_title_text="Signals"
    )

    return fig

In [ ]:

plot_diff_long_accel_and_altitude(df).show()

발견 - 경사와 종가속도¶

산을 넘을 때, 즉, 경사가 있을 때, 차속에서 계산한 종가속도와 센서가 측정한 종가속도 차이가 두두러진다.

타이어 마모 인덱스에 경사도 반영하기¶

In [41]:

df['diff_long_accel_filt'].describe()

Out[41]:

count    28792.000000
mean        -0.100138
std          0.300798
min         -1.110021
25%         -0.204642
50%         -0.081113
75%         -0.022774
max          1.636077
Name: diff_long_accel_filt, dtype: float64

In [42]:

# 튜닝 파라미터
k_factor_slope_deadzone = 0.5  # 경사도 가중의 데드존 (경사도가 이 값 이하이면 가중치 0)
k_factor_slope_to_weight = 1

def wear_increment_from_slip_w_slope(r_slip_xx: pd.Series, r_slip_max_no_turning: float) -> pd.Series:
    '''
    slip_series: 슬립 비율 시리즈 (예: r_slip_fl)

    앞뒤 바퀴의 수직 하중 차이가 고려되야 한다. 
    동일한 슬립율이라도 수직 하중이 큰 바퀴에서의 마모 증가량이 더 클 것이다. 
    앞 바퀴 하중 : 뒷 바퀴 하중 = 6 : 4 로 한다. 
    즉, 앞바퀴는 슬립으로 인한 마모 증가량이 1.5배가 된다. (필요에 따라 조정 가능)

    경사가 심한 구간에서는 구동륜의 마모가 가속된다고 가정할 수 있다. 
    이 경우, 경사도에 따른 가중치를 추가할 수 있다.

    return: 슬립으로 인한 마모 증가량 시리즈 (0 이상)
    '''

    # 1) 절대값 사용: 양/음 슬립 모두 마모 증가
    s_abs = r_slip_xx.abs()

    # 2) 데드존: 미소 슬립 노이즈 제거
    s_eff = (s_abs - k_r_slip_deadzone).clip(lower=0.0)

    # 3) 선회 중 r_slip이 크게 계산된다. 
    # 선회 여부 시 r_slip_eff를 보정한다. 
    s_eff = s_eff.where(df['is_turning'] > 0, r_slip_max_no_turning * k_limit_factor_r_slip_in_turning)

    # 4) 수직 하중 가중 
    # 앞바퀴 1.5배, 뒷바퀴 1.0배: 베뉴의 경우, 앞바퀴 하중 : 뒷바퀴 하중 = 6 : 4 정도로 추정된다. (필요에 따라 조정 가능)
    if 'fl' in r_slip_xx.name:
        s_eff *= 1.5
    elif 'rl' in r_slip_xx.name:
        s_eff *= 1.0
    elif 'fr' in r_slip_xx.name:
        s_eff *= 1.5
    elif 'rr' in r_slip_xx.name:
        s_eff *= 1.0
    
    # 5) 경사도 가중 (경사도가 클수록 마모 증가)
    # 경사도는 diff_long_accel_filt로 대체한다. (필요에 따라 조정 가능)
    # 구동륜에만 적용한다. 베뉴는 전륜구동이므로, fl과 fr에 적용한다. (필요에 따라 조정 가능)


    if 'fl' in r_slip_xx.name or 'fr' in r_slip_xx.name:
        slope = df['diff_long_accel_filt']
        slope_mean = slope.mean()
        slope_std = slope.std()
        slope_abs = (slope - slope_mean).abs()
        slope_eff = (slope_abs - slope_std * k_factor_slope_deadzone).clip(lower=0.0)
        slope_weight = 1 + slope_eff * k_factor_slope_to_weight
        s_eff *= slope_weight

    # 6) 비선형 가중
    severity = s_eff.pow(k_slip_power)
    
    # 7) 시간 적분
    inc = severity * dt
    
    return inc.where(valid_speed, 0.0)

In [43]:

# 타이어별 누적 인덱스 계산


for wheel in ["fl", "fr", "rl", "rr"]:
    col_r_slip = f"r_slip_{wheel}"
    col_inc = f"wear_inc_{wheel}"
    col_idx = f"wear_idx_{wheel}"

    r_slip_max_no_turning = df.loc[df['is_turning'] == 0, col_r_slip].max()
    df[col_inc] = wear_increment_from_slip_w_slope(df[col_r_slip], r_slip_max_no_turning)
    df[col_idx] = df[col_inc].cumsum()

In [ ]:

plot_wear_index_with_altitude(df).show()

발견 - 경사의 타이어 마모 인덱스에 영향¶

아래는 경사를 고려하기 전 타이어 마모 인덱스 그래프이다.
그래프들을 비교하면 산을 넘을 때 타이어 마모 인덱스가 증가한 것을 확인할 수 있다.

주행 경로와 타이어 마모 인덱스를 지도에서 시각화¶

In [ ]:

# 경로와 fl 바퀴의 마모 인덱스를 지도에 시각화한다.
# 마모인덱스가 잘 보이도록 지도는 흑백(그레이스케일) 스타일을 사용한다.
# scatter_map을 사용한다. (scatter_mapbox 사용 안 함)
import plotly.express as px

# 지도 시각화를 위해 latitude, longitude, wear_idx_fl 컬럼을 사용한다.
wear_idx_fl_min = df['wear_idx_fl'].min()
wear_idx_fl_max = df['wear_idx_fl'].max()
wear_idx_range = wear_idx_fl_max - wear_idx_fl_min if wear_idx_fl_max > wear_idx_fl_min else 1.0
df['wear_idx_fl_normalized'] = (df['wear_idx_fl'] - wear_idx_fl_min) / wear_idx_range

# df['wear_color'] = wear_idx_fl_normalized.apply(
#     lambda x: f"rgb({int(255*x)}, {int(255*(1-x))}, 126)"
# )

fig = px.scatter_map(
    df,
    lat='latitude',
    lon='longitude',
    color='wear_idx_fl_normalized',
    color_continuous_scale=[
        (0.0, 'green'),
        (0.5, 'yellow'),
        (1.0, 'red')
    ],
    range_color=(0, 1),
    size_max=15,
    zoom=10,
    map_style='carto-positron', # 흑백 스타일
    title='Front Left Tire Wear Index Along the Route'
)

fig.update_layout(
    coloraxis_colorbar=dict(
        title='Normalized Wear Index',
        len=0.5
    ),
    width=900,
    height=900
)

fig.show()

결론¶

CAN 데이터와 GPS 데이터를 함께 이용하면 뭔가 유용한 계산을 할 수 있지 않을까 해서 타이어 마모 인덱스라는 것을 정의하고 계산해 봤다.
내가 정의한 타이어 마모 인덱스는 이대로는 현실적 유용성은 없다고 생각한다. 인텍스를 정의하고 계산식을 만드는 과정이 누군가에게 영감을 줄 수 있으면 좋겠다.

blf & dbc --> mdf or csv 개선 :: hsl's tsmaster 사용기

hsl's tsmaster 사용기 목차 :: hsl's tsmaster 사용기

blf & dbc --> mdf or csv 개선

hsl7 — Fri, 3 Apr 2026 22:29:37 +0900

시작하기 전에

blf는 CAN 프레임 단위로 타임스탬프와 함께 데이터를 저장한다.
mdf는 신호 별로 타임스탬프와 함께 데이터를 저장한다.
한 CAN 프레임에 10개 신호들이 있다고 가정하자. 이 10개 신호들을 저장할 때, 동일한 타임스탬프가 10번 저장된다. 타임스탬프를 1회 저장하고 10개 신호들이 공통으로 이 타임스탬프를 참조하도록 하면, 파일 저장 공간을 절약할 수 있다. 이런 CAN 프레임이 10개 있고, 각 프레임에 신호가 10개씩 있다면, 절약할 수 있는 파일 저장 공간이 상당할 것이다.
설마 내가 지구에 왔다갔거나 아직 있는 사람들 중에서 최초로 이런 생각을 한 사람은 아닐 것이다. 찾아보니 ASAM mdf v4 부터는 공통 타임스탬프(Common Time Base: CTB)가 적용되어 있다.
기존에 만든 blf & dbc --> mdf or csv 변환기는 공통 타임스탬프를 적용하지 않았다. 개선한다.

프레임 기반 blf 파일과 신호 기반 mdf 파일의 구조를 비교하면 위 그림과 같다.

blf와 mdf 포맷의 차이점은 아래와 같다.

Aspect	BLF	MDF4
Data organization	메시지(프레임) 단위 저장 여러 신호가 raw bytes로 혼재	신호(채널) 단위 저장 각 신호가 독립 컬럼으로 분리
Timestamp structure	단일 타임라인에 모든 ID가 시간순 혼재	채널별 독립 타임스탬프 배열 같은 메시지 내 신호는 동일 타임스탬프 공유
Signal decoding	읽기 시점에 DBC 파일 필요 (bit position, factor, offset 적용)	변환 시 이미 디코딩 완료 읽기에 DBC 불필요, 자체 완결
Stored values	Raw hex bytes (factor/offset 미적용, 단위 없음)	물리값 저장 (rpm, km/h, % 등) 단위·정밀도 메타데이터 내장
Multiplexing (MUX)	MUX selector byte가 같은 행 안에 혼재 (구분 불명확)	selector 값별로 독립 채널로 분리 저장 (Mux_A, Mux_B…)
Sample rate per signal	혼재 — ID마다 다른 주기가 단일 스트림에 섞임	채널마다 명확히 분리 주기·샘플 수가 채널별로 독립
File size & compression	상대적으로 소형 이벤트 기록 방식의 compact binary	상대적으로 대형 DZ/DL 블록으로 채널 단위 압축 지원
Common Timebase	개념 없음. 채널 간 공통 시간 기준 미정의	CTB(Common Timebase) 지원 채널 간 시간 동기화 메타데이터 포함
Standard & ecosystem	Vector 독점 포맷 CANalyzer/CANoe 중심 생태계	ASAM 국제 공개 표준 (MDF 4.x) 다양한 도구 호환

사용법

기존 blf & dbc --> mdf or csv 와 동일하다. (blf & dbc --> mdf or csv 변환 :: hsl's tsmaster 사용기)
변환 파일 형식을 MDF4 (.mf4)를 선택하면 CTB가 적용된다.

뷰어에서 .mf4 파일을 로드하여 그래프를 그릴 수 있다.

코드

코드 파일을 첨부한다.

blf_dbc_to_mdf_csv_mp.ctb.py

0.14MB

코드를 개선하는 차에 CLI 실행이 가능하도록 하였다. 가능한 커맨드 라인 옵션은 아래와 같다.

옵션	설명	기본값
-b, --blf	BLF 파일 경로 (필수)	-
-d, --dbc	DBC 파일 경로 (필수)	-
-o, --output	출력 파일 경로 (필수)	-
-f, --format	출력 형식 (mdf4/mdf3/csv)	mdf4
--resample-ms	리샘플 주기(ms). 미지정 시 비활성화	(비활성화)
--resample-method	리샘플 방법 (interp/ffill/mode)	ffill
--normalize-ts	타임스탬프 0초 시작	✓ 활성화
--no-normalize-ts	타임스탬프 정규화 비활성화	-
--workers	병렬 프로세스 수	CPU-1
--batch-size	배치 크기(프레임)	200000
--if-exist	기존 파일 처리 (overwrite/skip)	overwrite
-s, --signals	신호 선택 (all 또는 JSON 파일 경로)	all
--scan-limit-mb	BLF 스캔 크기	5.0

# 1. 기본 변환 (MDF4, 모든 신호, 정규화)
python blf_dbc_to_mdf_csv_mp.ctb.py \
  -b test.blf -d database.dbc -o output.mf4

# 2. 리샘플링 + CSV 출력 (50ms 주기, 선형 보간)
python blf_dbc_to_mdf_csv_mp.ctb.py \
  -b test.blf -d database.dbc -o output.csv \
  --format csv --resample-ms 50 --resample-method interp

# 3. 기존 파일 있으면 건너뛰기 + MDF3 + 여러 워커
python blf_dbc_to_mdf_csv_mp.ctb.py \
  -b test.blf -d database.dbc -o output.mdf \
  --format mdf3 --if-exist skip --workers 8 --batch-size 500000

# 4. 타임스탬프 정규화 안 함
python blf_dbc_to_mdf_csv_mp.ctb.py \
  -b test.blf -d database.dbc -o output.mf4 --no-normalize-ts

# 5. JSON 신호 선택 파일 사용
python blf_dbc_to_mdf_csv_mp.ctb.py \
  -b test.blf -d database.dbc -o output.mf4 \
  --signals my_signals.json

결론

기존 blf & dbc --> mdf 변환기를 개선하여 공통 타임스탬프를 사용하는 md4 형식 파일로 저장할 수 있도록 했다.
변환 기능을 툴 체인에 넣어 자동화 할 수 있도록 CLI로 사용할 수 있도록 하였다.
md4로 저장할 때 압축 옵션을 사용할 수 있다는 것을 알았다. 압축을 적용하도록 하였다. 50Mbyte 크기의 blf 파일을 변환했다. md4 파일은 45Mbyte이다. mdf 파일은 675Mbyte이다. mdf에 비해 90% 이상 파일 크기가 줄었다. CTB로 파일 크기가 어느 정도 줄었겠지만, 압축으로 파일 크기가 상당히 줄었을 것으로 짐작한다.

blf & dbc --> mdf 변환 :: hsl's tsmaster 사용기

blf & dbc --> mdf or csv 변환 :: hsl's tsmaster 사용기

hsl's tsmaster 사용기 목차 :: hsl's tsmaster 사용기

C 미니프로그램에서 CAN 신호를 다루기

hsl7 — Thu, 19 Mar 2026 16:08:45 +0900

시작하기 전에

C 미니프로그램에서 CAN 메시지 송수신하기 :: hsl's tsmaster 사용기에서 "메시지" 수준에서 데이터를 다뤘다. '"신호" 수준에서 데이터를 다룰 수 있는가?' 궁금했다. 해봤다. 된다. 이 방법을 설명한다.

개요

프로젝트 설계
dbc 임포트
미니프로그램
- On CAN Rx
- 코드에서 dbc의 메시지/신호 사용하는 방법
- 코드
나머지 설정
힌트를 얻은 곳
실행 결과

프로젝트 설계

C 미니프로그램에서 CAN 메시지 송수신하기 :: hsl's tsmaster 사용기와 동일한 하드웨어 설정이다.
메시지/신호들이 정의된 dbc를 임포트한다. 내가 작성해서 사용 중인 venue_esc.dbc를 사용한다.
대상 메시지와 신호를 선정한다. 나는 ESP 메시지의 ESP_counter 신호를 대상으로 정했다.
트랜스밋창에서 ESP 메시지를 전송한다.
미니프로그램에서 ESP 메시지를 수신하면 아래 동작을 하도록 한다.
- 메시지가 채널 2에서 수신된 경우 실행한다.
- 메시지의 데이터를 dbc에 정의된 구조에 따라 신호들로 파싱한다.
- ESP_counter 신호에 + 1한다.
- ESP 메시지를 복사하여 송신할 메시지를 만든다. 송신할 메시지의 데이터는 위에서 수정된 데이터이다.
- 송신할 메시지의 아이디를 변경한다. 그렇지 않으면 ESP 메시지와 동일한 메시지 아이디로 송신된다.
미니프로그램 작동을 Trace 창에서 확인한다.
- 송신과 수신 메시지를 구분하기 위해서
  - 채널 1번과 채널 2번용 트레이스창을 각각 생성한다.
  - 각 트레이스창에 채널 필터를 적용한다.

dbc 임포트

dbc 파일을 TSMaster 창에 드래그&드롭한다. CAN Database 창이 열린다. dbc가 Channel 1에 연결되어 있다.
venue_esc.dbc에는 ESP(0x220) 메시지가 있다. 그 안에는 4 bit 길이의 ESP_counter 신호가 있다.
이 신호를 대상으로 읽기/쓰기를 해본다.

미니프로그램

On CAN Rx

On CAN Rx 에서 마우스 우클릭으로 Add On Rx - CAN Message를 선택한 후, Id의 드롭다운리스트에서 0x220=ESP 선택한다. 나는 함수 이름에 넣을 문구로 ESP를 입력했다.

void on_can_rx_ ESP (const TCAN* ACAN) 함수의 뼈대가 만들어졌다.

코드에서 dbc의 메시지/신호 사용하는 방법

미니프로그램에서 ESP 메시지와 신호들을 사용하기 위해서, Properties 탭의 Database Symbols에서 "venue_esc.pdbc"를 체크하여 포함한다. (pdbc 파일은 dbc 파일을 TSMaster가 변환한 파일이다. TSMaster는 dbc 파일을 직접 사용하지 않고, pdbc 파일을 사용하는 것 같다.)

Functions 탭으로 가면 venue_esc.dbc에 정의된 메시지/신호들이 포함된 것을 볼 수 있다. 코드에서 메시지를 사용하고 싶으면, 메시지를 마우스 우클릭하고 Insert into script를 하면 된다.
TESP_1 (_1은 '채널 1'이라는 의미이다.) 이라는 타입으로 ESP_1 변수를 선언한다. ESP_1 변수를 사용하기 전에 ESP_1.init() 문으로 초기화를 해야 한다.
ESP_1.FCAN = *ACAN 라는 한 줄의 코드로 CAN 메시지를 ESP_1 메시지의 구조에 따라 파싱할 수 있다. ACAN 은 void on_can_rx_ESP (const TCAN* ACAN)의 인자이다. 즉, 수신된 메시지다.
*ACAN = ESP_1.FCAN 라는 한 줄의 코드로 ESP_1 변수를 CAN 메시지에 할당할 수 있다. ACAN 은 메시지를 전송하는 com.transmit_can_async(ACAN) 의 인자로 사용될 수 있다.

신호를 사용하고 싶으면, 신호를 마우스 우클릭하고 Insert into script를 하면 된다. 변수의 신호에 해당하는 부분은 "메시지.신호"로 형식으로 사용할 수 있다. ESP_1.ESP_counter는 ESP_1 메시지 형식의 변수에서 ESP_counter 부분이다.

코드

코드를 입력한다. 코드의 작용은 커멘트로 설명하였다.

// venue_esc.dbc에는ESP 메시지가 정의되어 있다.
// ESP 메시지에는 ESP_counter 신호가 있다.
// ESP 메시지를 수신하면, ESP_counter 신호에 + 1을 하고
// ESP 메시지의 아이디(= 0x220)에 + 0x100한 메시지에 (= 0x320)
// 변경된 데이터를 담아 송신한다.

// 수신 채널이 2번일 경우에만 실행한다.
if (ACAN->FIdxChn != CH2) return; 

// 수신한 ESP 메시지를 담을 변수 my_ESP_1을 선언한다.
// 변수 이름은 자유롭게 정하면 된다. 
// ESP 메시지는 TESP_1 형식의 변수로 선언된다. 
// TESP로 하면 될 것 같은데 _1이 붙어있다. _1은 
// 채널 1에 할당된 dbc의 정의에 따른다는 의미이다.
TESP_1 my_ESP_1;

// 메시지 송신에 사용할 변수를 선언한다. 
TCAN m_tx;

// my_ESP_1 변수를 사용하기 전에 초기화(init) 해야한다.
my_ESP_1.init(); 

// 수신한 ACAN 메시지를 my_ESP_1 메시지의 FCAN에 할당하여
// ESP 메시지의 구조에 따라 파싱한다. 
// 파싱이 코드 한 줄로 간단하다.
my_ESP_1.FCAN = *ACAN; 

// ESP_counter 신호에 + 1 한다.
my_ESP_1.ESP_counter = my_ESP_1.ESP_counter + 1;

// 송신에 사용할 m_tx에 my_ESP_1 메시지를 할당한다.
m_tx = my_ESP_1.FCAN;

// [중요] 바로 위에서 m_tx 메시지의 채널과 아이디가
// my_ESP_1 메시지의 채널과 아이디로 변경되었다.
// m_tx 메시지 채널과 아이디를 바꾸고자 한다면,
// 위 실행문 다음에 실행되도록 해야 한다.
m_tx.FIdxChn = 1; // 채널 2번
m_tx.FIdentifier = (ACAN->FIdentifier + 0x100);

// System Message 창에 출력한다. 
// log("0x%03x  0x%03x",  ACAN->FIdentifier, m_tx.FIdentifier);
// log("0x%02x  0x%02x",  ACAN->FData[7], m_tx.FData[7]);

// m_tx 메시지를 송신한다.
if (0 != com.transmit_can_async(&m_tx)){
    // 송신에 실패하면 System Messages 창에 ERROR를 출력한다.
    log("ERROR: Tx 0x%03x", m_tx.FIdentifier);
}

return;

나머지 설정

트랜스밋창

트랜스밋창을 연다.
dbc에서 메시지를 추가한다. 그렇게 하기 위해 트랜스밋창 상단의 첫번째 버튼을 클릭한다.

CAN Database 창이 열리면 ESP 메시지를 선택한다.

ESP 메시지를 선택하고, Signals 탭에 나열된 신호들의 값을 변경한다. 나는 아래 그림과 같이 변경하였다. 변경의 목적은 데이터가 모두 0x00으로 채워지지 않도록 하기 위해서다.

트레이스창들

C 미니프로그램에서 CAN 메시지 송수신하기 :: hsl's tsmaster 사용기의 방법과 동일하다.

힌트를 얻은 곳

위에서 설명한 Insert into script에서 변수 사용법의 힌트를 얻었다.

실행 결과

실행 결과는 아래 비디오와 같다.
미니프로그램을 실행한다.
Start 버튼을 클릭하여 버스를 연결한다.
트랜스밋창에서 ESP(0x220) 메시지를 전송한다.
채널 1을 표시하는 위쪽 트레이스창에서 ESP(0x220) 메시지가 송신(Tx)되는 것을 확인한다.
채널 2를 표시하는 아래쪽 트레이스창에서 ESP(0x220) 메시지가 수신(Rx)되는 것을 확인한다.
아래쪽 트레이스창에서 0x320 메시지가 송신되는 것을 확인한다.
위쪽 트레이스창에서 0x320 메시지가 수신되는 것을 확인한다.
0x320 메시지의 ESP_counter 부분이 업데이트되는 것을 확인한다.
https://www.youtube.com/watch?v=NLXnZ8gtDaY

결론

TSMaster의 C 미니프로램을 이용하여 메시지를 수신하고, 신호를 변경하고, 변경된 신호가 포함된 데이터를 새 메시지에 실어서 송신하는 예제를 작성하였다.
생각보다 쉽다.

C 미니프로그램에서 CAN 메시지 송수신하기

hsl7 — Thu, 19 Mar 2026 12:32:17 +0900

시작하기 전에

0x700 메시지를 수시하면 0x701, 0x702, 0x703, 0x704 메시지를 전송하는 기능이 필요하다. TSMaster의 미니프로그램을 이용하면 이 기능을 구현할 수 있다. 미니프로그램의 언어로 Python 혹은 C를 사용할 수 있다. 나는 C를 모른다. 하지만 C로 도전한다.

개요

프로젝트 설계
미니프로그램
나머지 설정
힌트를 얻은 곳
실행 결과

프로젝트 설계

2 채널 CAN 인터페이스 하드웨어를 사용한다. 채널 1과 채널 2를 직접 연결하여 버스를 구성한다.

채널 1에서 0x700 메시지를 1000msec 주기로 전송한다. (채널 2에서 수신한다.) 트랜스밋창에서 0x700 메시지 송신을 설정한다.
미니프로그램은 0x700 메시지를 수신하면 (On CAN Rx)
- 메시지가 채널 2에서 수신된 경우 실행한다.
- 채널 2에서 0x701, 0x702, 0x703, 0x704 메시지를 송신한다.
- 각 메시지의 첫 바이트를 카운터하여 메시지가 업데이트되어 송신되는 것을 확인할 수 있도록 한다.
미니프로그램 작동을 Trace 창에서 확인한다.
- 송신과 수신 메시지를 구분하기 위해서
  - 채널 1번과 채널 2번용 트레이스창을 각각 생성한다.
  - 각 트레이스창에 채널 필터를 적용한다.

미니프로그램

메인 메뉴/ Design/ C Mini Program 버튼을 클릭하여 Add C Code Editor를 한다.

Symbols 탭의 이벤트 목록에서 "On CAN Rx" 항목을 마우스 우클릭으로 선택한다. "Add On Rx - CAN Message"를 선택한다. (CAN-FD의 경우 Add On Rx - CAN FD Message를)

id에 700을 입력한다. 0x700 메시지를 수신할 때 실행할 함수를 정의할 것이니까. Name에 함수 이름에 사용한 문구를 입력한다. 나는 m700으로 하였다. 0x700 메시지(m)를 수신할 때 실행할 함수니까.

함수의 뼈대가 만들어 진다. 함수 원형이 아래와 같이 생성된다. m700는 함수 이름에 사용하기 위해 입력한 문구이다.

void on_can_rx_m700(const TCAN* ACN)

코드를 입력한다. 코드의 작용은 커멘트로 설명하였다.

// 0x700 message를 수신하면 
// 0x701, 0x702, 0x703, 0x704 메시지를 전송한다.
// 송신 메시지의 첫 바이트를 카운터로 정의한다. 송신할 때마다 
// 데이터가 변경되는 것을 확인하기 이한 목적이다. 

// 수신 채널이 2번일 경우에만 실행한다.
if (ACAN->FIdxChn != CH2) return; 


// 메시지 송신에 사용할 변수를 선언한다.
TCAN m_tx;   

// 송신 메시지의 아이디들
static u16 m_tx_ids[4] = {0x701, 0x702, 0x703, 0x704};  

// 메시지를 전송할 때마다 카운터 바이트를 변경하기 위해
static u8 m_tx_counters[4] = {0x01, 0x02, 0x03, 0x04}; 

// for 루프를 위한 인덱스
u8 i;

for (i=0; i<4; i++) {
    m_tx = {1,0x1,8,0,m_tx_ids[i],0,{m_tx_counters[i], 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0}};
    // 데이터의 맨 앞에 1이 채널 2를 의미한다. 채널 0은 채널 1이다.
    m_tx_counters[i] += 1;

    if (0 != com.transmit_can_async(&m_tx)){
      log("ERROR: Tx 0x%03x", m_tx.FIdentifier);
    }
}

return;

나머지 설정

트랜스밋창

트랜스밋창을 생성한다. (아래 그림에서 "[1] CAN / CAN FD Transmit"는 창이 이미 존재하기 때문에 표시된다.)

메시지를 추가한다. 트랜스밋창 상단의 두번째 버튼을 클릭하면 임의의 메시지를 생성할 수 있다.

메시지를 정의한다. Trigger 셀을 클릭하여 Period 을 선택한다. Period에 주기를 1000 msec로 하였다. Id는 700으로, Chn(채널)은 1로 하였다. D0 ... D7은 임의의 데이터를 넣었다.

트레이스창들

트레이스창을 두 개 생성한다. (아래 그림에서 "[1] CAN / CAN FD Trace", "[2] CAN / CAN FD Trace [#2]"는 창들이 이미 존재하기 때문에 표시된다.)

두 창들에 각각 채널 1, 채널 2의 메시지들만 표시되도록 필터를 설정한다. 필터를 설정하기 위해서 Measurement Setup 창을 연다.

필터를 적용할 CAN / CAN FD Trace 창을 마우스 우클릭으로 선택한다. 메뉴에서 Insert Filter를 선택한다. 필터가 추가된다.

Measurement Filter를 더블클릭한다. Pass를 선택한다. CAN 1(채널 1)을 선택한다. Add를 선택하여 Add Any Frame을 선택한다. 채널 1의 모든 프레임이 통과되어 트레이스창에 표시된다.

같은 방법으로 다른 트레이스창 앞에 Measurement Filter를 추가하고, 채널 2의 메시지들만 표시되도록 설정한다.

힌트를 얻은 곳

C에서 메시지를 다루는 방법은 트랜스밋창에서 힌트를 얻었다.
트랜스밋창에서 메시지를 마우스 우클릭으로 선택하고, Copy as C Script를 선택하면, 해당 메시지를 전송하는 C 코드를 알 수 있다.

실행 결과

실행 결과는 아래 비디오와 같다.
미니프로그램을 실행한다.
Start 버튼을 클릭하여 버스를 연결한다.
트랜스밋창에서 0x700 메시지를 전송한다.
채널 1을 표시하는 위쪽 트레이스창에서 0x700 메시지가 송신(Tx)되는 것을 확인한다.
채널 2를 표시하는 아래쪽 트레이스창에서 0x700 메시지가 수신(Rx)되는 것을 확인한다.
아래쪽 트레이스창에서 0x701, 0x702, 0x702, 0x703 메시지들이 송신되는 것을 확인한다.
위쪽 트레이스창에서 0x701, 0x702, 0x702, 0x703 메시지들이 수신되는 것을 확인한다.
0x701, 0x702, 0x702, 0x703의 카운터들이 업데이트되는 것을 확인한다.

https://www.youtube.com/watch?v=-qR8ElcMC_Y

결론

TSMaster의 C 미니프로램을 이용하여 메시지를 수신하고 메시지들을 송신하는 예제를 작성하였다.
생각보다 쉽다.

dbc 병합

hsl7 — Mon, 16 Mar 2026 10:53:07 +0900

시작하기 전에

포르쉐 타이칸 CAN 데이터에서 요-레이트 신호 찾기 :: hsl's tsmaster 사용기, 포르쉐 타이칸 CAN 데이터에서 횡가속도 신호 찾기 :: hsl's tsmaster 사용기 에서 opendbc/opendbc/dbc at master · commaai/opendbc에서 다운로드 받은 dbc 파일들을 사용했다고 이야기 했다. dbc 파일들이 5개 있었다.

opendbc에서 다운로드 받은 VW의 dbc 파일들

여러 메시지/신호들이 다른 이름으로 여러 dbc 파일들에 중복되어 있었다. TSMaster에 dbc 파일들을 임포트하니 중복된 메시지/신호들이 마지막에 임포트된 dbc 파일의 정의로 대체되었다. 내가 원하는 메시지/신호 정의를 사용할 수 없었다. dbc 파일들에서 메시지/신호들을 선택하여 내게 필요한 dbc를 만들 필요가 생겼다.

나는 Vector사의 프리웨어인 CANdb++ 에디터(CAN dbc 편집 :: hsl's tsmaster 사용기)를 사용한다. 좋은 툴이다. 복수의 dbc 파일들에서 메시지/신호들을 합치는 작업(dbc 병합)에는 다소 불편하다. 바이브 코딩으로 dbc 병합용 툴을 만들었다.

dbc merger 실행 화면

dbc merger의 설치 방법과 사용법을 설명한다.

설치

app_dbc_merger_qt.zip

0.14MB

ZIP 파일을 압축 해제합니다.
"app_dbc_merger_qt" 폴더를 포함한 "상위" 경로에서 터미널을 엽니다.
(선택) 가상환경을 생성합니다.
의존성 패키지를 설치합니다.

REM python 가상 환경을 만듭니다. 옵션입니다.
python -m venv .venv

REM 가상 환경을 활성화 합니다. 
.\.venv\Scripts\Activate.ps1

REM dbc merger 앱을 실행하기 위해서 필요한 패키지/모듈들을 설치합니다.
pip install -r .\app_dbc_merger_qt\requirements.txt

실행

상위 폴더에서 아래 명령으로 실행합니다.

python -m app_dbc_merger_qt.app

메인 화면

기본 사용 순서

왼쪽 패널에서 DBC1 파일을 로드합니다.
오른쪽 패널에서 DBC2 파일을 로드합니다.
병합에 포함할 메시지/신호를 선택합니다.
"Copy" 또는 "Copy All" 버튼으로 중앙 DBC3로 복사합니다.
중앙 DBC3 트리에서 체크 상태와 Source를 확인합니다.
파일 이름과 인코딩을 설정합니다.
"Save DBC" 버튼으로 저장합니다.

참고 사항

앱 실행 후 GUI가 뜰 때까지 조금 시간이 걸립니다.
마지막에 사용한 DBC1/DBC2/DBC3 경로는 `dbc_merger_last_paths.json`에 저장됩니다.
DBC3 트리는 메시지/신호 단위 체크박스로 포함 여부를 제어할 수 있습니다.
Help 메뉴에서 About, License, Third-Party Licenses를 확인할 수 있습니다.

문제 해결

DBC 로드 실패 시 파일 인코딩 또는 DBC 파일 유효성(CANdb++ 에디터에서 열어보십시오.)을 확인하세요.
병합 실패 시 하단 로그 패널의 충돌 메시지를 확인하세요.

YouTube: Panel에서 LED와 Switch 사용하기

hsl7 — Fri, 13 Mar 2026 12:45:19 +0900

Panel에서 LED와 Switch 사용하기

YouTube: https://www.youtube.com/watch?v=HbgT_ASejj4

설명 내용

Panel에 LED와 Switch를 추가하고, CAN 신호와 연결한다.
Switch를 조작하여 CAN 신호가 변경되도록 한다. CAN 신호의 변경에 따라 LED 상태도 변한다.
CAN 메시지의 신호를 변경하여 LED와 Switch의 상태를 변경한다.

원본

https://www.youtube.com/watch?v=iR6bF7aOqPI&t=9s 비디오를 편집하고 자막을 추가하였다.

YouTube: CAN, LIN 메시지 송수신

hsl7 — Thu, 12 Mar 2026 18:39:58 +0900

CAN, LIN 메시지 송수신

YouTube: https://www.youtube.com/watch?v=FJaGl8kGZLY

설명 내용

CAN, LIN 하드웨어 설정
CAN 메시지 전송
- 사용자 정의 신호를 정의하는 방법
LIN 메시지 전송
- 마스터 노드와 슬레이브 노드 설정 방법

내가 배운 것

사용자 정의 신호를 정의할 때, 먼저 Export를 한 후 엑스포트된 파일에 (시간, 값) 쌍들을 입력하고 저장하고, 이 파일을 Import 해야 한다.
마스터 노드와 슬레이브 노드를 변경할 때, Master Node 체크 박스를 먼저 uncheck 한 후 다시 check 해야한다. 아마 기존 설정을 삭제하고 새 설정을 저장하는 조작인 것 같다.

hsl's tsmaster 사용기 목차 :: hsl's tsmaster 사용기

blf & dbc --> mdf or csv 변환

hsl7 — Tue, 10 Mar 2026 12:18:03 +0900

시작하기 전에

blf & dbc --> mdf 변환 :: hsl's tsmaster 사용기에서 blf 파일에서 dbc 파일에 정의된 신호들을 선택하여 mdf 파일을 생성하는 프로그램을 개발의 요점들을 설명하였다.

디렉토리를 선택하면, 그 디렉토리에 있는 모든 blf 파일들을 표시하여 사용자가 선택할 수 있도록 하고, 선택된 파일들을 변환하여 csv 파일들을 생성하는 기능을 추가하였다.

사용법

파일 입력

blf 파일을 파싱할 dbc 파일을 선택한다.
단일 파일을 변환할 것인지 디렉토리를 변환할 것인지 선택한다.
파일 혹은 디렉토리를 선택한다.
디렉토리를 선택한 경우, 파일 목록에서 변환할 파일들을 선택한다.
파싱 버튼을 클릭한다.
- blf 파일에서 일정 크기를 읽는다. 일정 크기는 설정 탭의 "BLF 파싱 크기"에서 설정할 수 있다.
- 프로그램은 blf 파일에 어떤 메시지들이 있는 지 확인한다. 이 정보는 신호 선택 탭에서 이용된다.

신호 선택

dbc 파일에서 읽은 메시지/신호들이 트리 구조를 표시된다.
blf 파싱 중에 찾지 못한 메시지는 선택 불가 상태로 표시된다.
변환할 신호들을 선택한다.
"선택 저장", "선택 로드" 버튼으로 선택 상태를 저장하고 다시 불러올 수 있다.

변환

리샘플링 여부를 선택할 수 있다.
리샘플링을 선택하는 경우,
- 주기를 정할 수 있다.
- 리샘플링 방법을 선택할 수 있다. (직전값, 선형 보간, 최빈값)
타임스탬프 정규화를 선택할 수 있다. 선택하는 경우 첫 메시지의 타임스탬프를 0으로 하고, 나머지 메시지들의 타임스탬프를 이에 따라 변경한다.
변환 파일 형식을 선택할 수 있다.
- csv로 저장하려면 반드시 리샘플링을 선택해야 한다. csv에 신호별로 타임스탬프를 저장한다면, 데이터를 사용하기에 상당히 불편하기 때문이다.
출력 파일/디렉토리 경로 이름을 정할 수 있다.
변환 실행을 클릭하면 변환이 시작된다. 변환 중 프로그레스바와 변환 결과 요약이 표시된다.

미리보기

변환이 완료되면 미리보기 탭으로 이동한다.
마지막으로 변환된 파일의 알파벳 순으로 가장 먼저 오는 신호가 그래프로 표시된다.

Shift 키나 Ctrl 키를 누른 상태로 신호들을 선택하면 여러 신호들을 볼 수 있다.

개별 그래프를 체크하면, 신호들마다 축을 분리해서 볼 수 있다.

"파일 열기" 버튼을 클릭하여 다른 csv, mdf 파일을 열어 그래프로 볼 수 있다.

코드

아래 파이썬 코드와 requirements.txt 파일을 드라이브의 같은 디렉토리에 저장한다.

blf_dbc_to_mdf_csv_mp.py

0.11MB

requirements.txt

0.00MB

이 디렉토리에서 커맨드 창을 연다. (파일 탐색기의 경로가 표시되는 곳에 cmd 라고 입력하고 엔터하면 현재 경로에서 커맨드 창이 열린다.)
아래 명령어로 프로그램 실행에 필요한 패키지들을 설치한다.

pin install -r requirements.txt

아래 명령어로 프로그램을 실행한다.

python blf_dbc_to_mdf_csv_mp.py

결론

기존 blf & dbc --> mdf 변환기를 개선하여 csv 형식 파일으로 저장할 수 있도록 했다.

hsl's tsmaster 사용기 목차 :: hsl's tsmaster 사용기

FRD: blf & dbc --> mdf

hsl7 — Mon, 9 Mar 2026 10:09:35 +0900

나는 클로드를 이용하여 코딩할 때, 구현하고자 하는 기능을 (10줄 이내로) 간략하게 기술한다. 이를 FRD(Functional Requirement Document)라고 부른다. 클로드에게 FRD 검토와 피드백을 요청한다. 클로드의 피드백들 중에 내 마음에 드는 것을 선택하고 서브 기능에 관해 내 생각을 이야기하고 피드백을 요청한다. 이런 작업을 반복한다. 중간중간에 코드 작성을 요청하고 실행해 본다. 버그나 사용 방법 개선에 관해 클로드와 대화한다. 어느 정도 진척이 이뤄지면 클로드에게 FRD 업데이트를 요청한다.

BLF + DBC → MDF 변환 도구 기능 요구 조건 (FRD)

문서 버전: 0.7 <-- 버전이 0.7인 것으로 미루어 프로젝트 중에 클로드에게 6번 FRD 정리를 요청했나보다. 첫 버전은 내가 작성한 것이다.
작성일: 2026-03-08
파일명: blf_dbc_to_mdf_mp.py (PySide6 데스크톱 앱, 멀티프로세싱 버전)

변경 이력

버전	날짜	내용
0.1	2026-03-06	초안 (Streamlit 기반)
0.2	2026-03-06	프레임워크 변경: Streamlit → PySide6. FR-01 파일 입력 방식 변경 (text_input → 파일 다이얼로그). Streamlit 특화 표현 전반 수정.
0.3	2026-03-07	FR-02에 파싱 트리거 버튼 추가(FR-02-8). FR-05-2 리샘플링 주기 단위 ms 고정. FR-06-2 변환 버튼 비활성화 조건 확장. FR-06-7 취소 버튼 추가. FR-07-2 차트 라이브러리 pyqtgraph 확정. OI-02 단일 채널 처리 방식 확정. OI-03 JSON 저장 범위 확정. 의존 라이브러리 목록 갱신.
0.4	2026-03-07	UI 레이아웃을 4개 탭 구조로 변경 (파일 입력 / 신호 선택 / 변환 옵션 및 실행 / 미리보기). FR-08 탭 전환 규칙 추가.
0.5	2026-03-07	탭 5 [설정] 추가. FR-09 다국어 지원(한국어 / English / 中文) 추가. NFR-07 i18n 문자열 관리 추가. FR-08-1 탭 수 4 → 5 변경.
0.6	2026-03-07	FR-01-6 파일별 디렉터리 독립 기억으로 확장. FR-02-9 신호 선택 탭 트리 수준 버튼 추가. FR-03-5 BLF 파싱 크기 제한 추가. FR-09-6 설정 탭에 파싱 크기 항목 추가. FR-06-2 변환 버튼 재활성화 버그 수정 내용 반영. 설정 탭 UI 레이아웃 업데이트.
0.7	2026-03-08	파일명 변경: `blf_dbc_to_mdf.py` → `blf_dbc_to_mdf_mp.py`. FR-06-4 진행 상태 표시 개선 (0% → 현재/전체 MB + 경과 시간). FR-06-8 신규: 변환 완료 효과음. FR-07 미리보기 탭 전면 개편: 수평 스플리터(4:1) 레이아웃, MDF 열기 버튼, 다중 신호 선택, 개별 그래프 체크박스. FR-02-9 신호 선택 툴바 버튼 순서 명시. FR-09-7/FR-09-8 신규: 병렬 프로세스 수·배치 크기 설정. FR-10 신규: 멀티프로세싱 변환 (ProcessPoolExecutor, 프레임 배치 분할). NFR-08 신규: 의존 라이브러리 multiprocessing 추가.

1. 개요

BLF(Binary Logging File) 형식의 CAN 데이터 로그와 DBC(Database CAN) 형식의 CAN 매트릭스를 입력으로 받아,
사용자가 선택한 신호들을 MDF4(.mf4) 형식으로 변환·저장하는 PySide6 데스크톱 애플리케이션.

1.1 배경

BLF는 Vector 장비 등에서 생성되는 CAN 로그 포맷이다.
DBC는 CAN 버스의 메시지·신호 정의 파일이다.
MDF4는 자동차 산업 표준 계측 데이터 포맷(ASAM MDF)으로, 채널마다 독립적인 타임스탬프를 지원하여 리샘플링 없이도 원본 데이터를 보존할 수 있다.

1.2 처리 흐름

BLF 파일 ──┐
            ├─→ [파싱] 버튼 → DBC 파싱 + BLF 스캔(앞 N MB) → 신호 선택 → [변환 실행] → (옵션: 리샘플링/정규화) → MDF4 저장
DBC 파일 ──┘

탭 흐름: [파일 입력] → [신호 선택] → [변환 옵션 및 실행] → [미리보기]

2. 기능 요구 조건

FR-01. 파일 경로 입력

ID	요구 조건
FR-01-1	BLF 파일 선택 버튼을 클릭하면 `QFileDialog`가 열리고, `.blf` 확장자 필터가 적용되어야 한다. 선택된 경로는 `QLineEdit`에 표시된다.
FR-01-2	DBC 파일 선택 버튼을 클릭하면 `QFileDialog`가 열리고, `.dbc` 확장자 필터가 적용되어야 한다. 선택된 경로는 `QLineEdit`에 표시된다.
FR-01-3	`QLineEdit`에 경로를 직접 타이핑하거나 붙여넣기(Ctrl+V)할 수도 있어야 한다. 경로가 변경될 때마다 파일 존재 여부를 즉시 검증하고, 존재하지 않으면 오류 아이콘 또는 메시지를 표시해야 한다.
FR-01-4	파일 확장자가 올바른지 검증해야 한다 (BLF: `.blf`, DBC: `.dbc`).
FR-01-5	파일 크기 정보를 경로 표시 아래에 표시해야 한다.
FR-01-6	BLF, DBC, JSON 파일 다이얼로그는 각각 독립적으로 마지막 디렉터리를 기억하여 다음 실행 시 같은 디렉터리에서 시작해야 한다 (`QSettings` 키: `last_dir_blf`, `last_dir_dbc`, `last_dir_json`).

FR-02. DBC 파싱 및 신호 목록 표시

ID	요구 조건
FR-02-1	DBC 파일이 유효한 경우 DBC 내의 모든 메시지와 신호를 파싱하여 표시해야 한다.
FR-02-2	메시지 목록은 메시지 ID, 메시지 이름, 신호 수를 포함해야 한다.
FR-02-3	메시지-신호 계층 구조를 `QTreeWidget`으로 표시해야 한다. 메시지는 최상위 항목, 신호는 자식 항목이다.
FR-02-4	각 신호 항목에는 신호명, 단위(unit), 최솟값/최댓값(DBC 정의 기준)을 표시해야 한다.
FR-02-5	각 신호 항목에 개별 체크박스(`Qt.ItemIsUserCheckable`)가 있어야 하며, 체크된 신호만 MDF로 추출되어야 한다.
FR-02-6	각 메시지 항목에도 체크박스가 있어야 하며, 메시지 체크박스를 조작하면 하위 신호 전체가 선택/해제되어야 한다.
FR-02-7	전체 메시지에 대한 전체 선택 / 전체 해제 버튼이 있어야 한다.
FR-02-8	DBC 파싱과 BLF 스캔은 [파싱] 버튼을 클릭했을 때 시작된다 (파일 선택 시 자동 시작하지 않는다). [파싱] 버튼은 BLF와 DBC 파일이 모두 유효하게 선택된 경우에만 활성화된다.
FR-02-9	신호 선택 탭 툴바의 버튼 배치 순서는 다음과 같다: [전체 선택] → [전체 해제] → [메시지 수준] → [신호 수준] → (여백) → [선택 저장] → [선택 로드] → (stretch) → BLF 발견 메시지 요약 → 선택된 신호 수. [메시지 수준] 버튼은 트리의 모든 메시지 항목을 접어(`collapseAll`) 메시지 목록만 보이게 하고, [신호 수준] 버튼은 모든 메시지 항목을 펼쳐(`expandAll`) 신호 목록까지 보이게 한다.

FR-03. BLF 분석 — 실제 존재 메시지 검증

ID	요구 조건
FR-03-1	BLF 파일을 스캔하여 실제로 존재하는 CAN 메시지 ID 목록을 추출해야 한다.
FR-03-2	DBC에 정의되어 있지만 BLF에 존재하지 않는 메시지의 항목은 체크박스를 비활성화(`setDisabled(True)`)하고 시각적으로 구분(회색 표시 등)해야 한다.
FR-03-3	BLF 스캔은 UI가 멈추지 않도록 별도 워커 스레드(`QThread`)에서 실행되어야 한다. 스캔 중 진행 상태를 상태 표시줄과 `QProgressBar`로 표시해야 한다. 스캔 중 [취소] 버튼을 클릭하면 스캔을 중단하고 트리를 초기 상태로 되돌려야 한다.
FR-03-4	BLF에 존재하는 메시지 수와 DBC 전체 메시지 수를 비교하는 요약 정보를 표시해야 한다.
FR-03-5	BLF 스캔은 파일 전체가 아닌 앞부분 N MB만 읽어 수행한다 (기본값: 5 MB). 스캔 크기는 [설정] 탭에서 MB 단위로 지정할 수 있으며 (FR-09-6), 파싱 단계에만 적용된다. 변환 실행 시에는 BLF 파일 전체를 읽는다.

FR-04. 신호 선택 저장 및 로드

ID	요구 조건
FR-04-1	현재 신호 선택 상태를 JSON 파일로 저장하는 버튼이 있어야 한다.
FR-04-2	저장 파일명은 자동으로 DBC 파일명 기반으로 생성되어야 한다 (예: `venue_esc_selection.json`).
FR-04-3	저장 경로는 `QFileDialog`를 통해 사용자가 변경할 수 있어야 한다.
FR-04-4	저장 파일이 존재하면 앱 시작 시 자동으로 로드하여 신호 선택 상태를 복원해야 한다.
FR-04-5	저장 파일 로드 버튼이 있고, `QFileDialog`를 통해 경로를 직접 지정할 수 있어야 한다.
FR-04-6	로드 시 현재 DBC에 없는 신호가 저장 파일에 있으면 경고 메시지를 표시하고 해당 신호는 무시해야 한다.
FR-04-7	저장 파일에는 DBC 파일 경로, BLF 파일 경로, 저장 시각, 선택된 신호 목록이 포함되어야 한다. 변환 설정(리샘플링 여부, 주기 등)은 저장하지 않는다.

FR-05. 변환 옵션 설정

ID	요구 조건
FR-05-1	리샘플링 여부를 `QCheckBox`로 선택할 수 있어야 한다.
FR-05-2	리샘플링을 선택한 경우 리샘플링 주기를 `QLineEdit`으로 입력할 수 있어야 한다. 입력값은 숫자(정수 또는 소수)이며 단위는 ms로 고정한다 (기본값: `20`). 리샘플링을 선택하지 않으면 입력 필드는 비활성화된다.
FR-05-3	타임스탬프 정규화 여부를 `QCheckBox`로 선택할 수 있어야 한다 (0초 시작 여부).
FR-05-4	리샘플링을 선택하지 않은 경우(MDF 기본 사용 방식), 각 신호가 독립적인 타임스탬프를 갖도록 저장해야 한다.
FR-05-5	출력 MDF 파일 경로를 `QFileDialog`로 사용자가 지정할 수 있어야 한다.
FR-05-6	출력 파일명은 BLF 파일명을 기반으로 자동 생성되어야 한다 (예: `xxx_resampled_20ms.mf4` 또는 `xxx_raw.mf4`).
FR-05-7	MDF 버전을 `QComboBox`로 선택할 수 있어야 한다 (MDF4 `.mf4` 기본, MDF3 `.mdf` 옵션).

FR-06. 변환 실행 및 진행 상태 표시

ID	요구 조건
FR-06-1	[변환 실행] 버튼(`QPushButton`)이 있어야 한다.
FR-06-2	다음 조건 중 하나라도 해당하면 [변환 실행] 버튼이 비활성화되어야 한다: (1) BLF 또는 DBC 파일이 선택되지 않은 경우, (2) 파싱이 완료되지 않은 경우, (3) 선택된 신호가 없는 경우, (4) 변환이 실행 중인 경우. 변환이 완료되면 버튼은 즉시 다시 활성화되어야 한다.
FR-06-3	변환은 UI가 멈추지 않도록 별도 워커 스레드(`QThread`)에서 실행되어야 한다.
FR-06-4	변환 중 단계별 진행 상태를 `QProgressBar`와 상태 레이블로 표시해야 한다 (BLF 파싱 → NaN 처리 → (리샘플링) → MDF 저장). 상태 레이블의 진행 상세 정보는 `(현재 처리 MB / 전체 MB, 경과 시간 초)` 형식으로 표시한다 (예: `변환 중... BLF 파싱 (12.3 MB / 45.6 MB, 8 sec)`).
FR-06-5	변환 완료 후 결과 요약을 표시해야 한다: 총 신호 수, 총 데이터 포인트 수, 시간 범위, 저장 경로.
FR-06-6	변환 중 오류 발생 시 `QMessageBox`로 오류 메시지를 명확하게 표시하고 앱이 중단되지 않아야 한다.
FR-06-7	변환 실행 중 [취소] 버튼을 클릭하면 변환을 중단하고 미완성 출력 파일을 삭제해야 한다. [취소] 버튼은 변환 실행 중에만 활성화된다.
FR-06-8	변환 완료 시 효과음을 재생한다. Windows에서는 `winsound.Beep(1000, 300)`을 사용하고, 그 외 플랫폼 또는 실패 시 `QApplication.beep()`으로 폴백한다. 다른 작업을 하다가도 완료 여부를 인지할 수 있도록 한다.

FR-07. 결과 미리보기

ID	요구 조건
FR-07-1	미리보기 탭은 `QSplitter(Horizontal)`로 좌우 분리되며 비율은 4:1 (좌: 신호 선택 + 차트, 우: 테이블)이다.
FR-07-2	좌측 패널 상단에 [MDF 열기] 버튼과 파일 경로 표시 `QLineEdit`(읽기 전용)이 있다. 변환 완료 시 출력 파일 경로가 자동으로 채워지며, [MDF 열기] 버튼을 클릭하면 `QFileDialog`로 임의의 `.mf4`/`.mdf` 파일을 열어 미리볼 수 있다.
FR-07-3	파일 경로 아래에 신호 선택 `QListWidget`이 있다. 표시 방향은 수평 흐름(`LeftToRight`)이며 체크박스 형태로 복수 신호를 선택할 수 있다(`ExtendedSelection`). 최대 높이는 140 px로 제한하여 차트 영역을 최대화한다.
FR-07-4	신호 선택 영역 우측에 [개별 그래프] 체크박스(`QCheckBox`)가 있다. 체크 시 선택된 신호들이 각각 별도 서브플롯으로 표시되고, 미체크 시 하나의 플롯에 겹쳐 표시된다.
FR-07-5	차트 라이브러리는 `pyqtgraph`를 사용한다. 차트 배경은 흰색이다.
FR-07-6	우측 패널에는 `QTableWidget` (컬럼: 타임스탬프(s), 값)이 있으며, 현재 선택된 신호(단일) 기준으로 첫 N 행을 표시한다.

FR-08. 탭 구조 및 전환 규칙

ID	요구 조건
FR-08-1	앱은 `QTabWidget`으로 구성된 5개 탭을 가진다: [파일 입력], [신호 선택], [변환 옵션 및 실행], [미리보기], [설정].
FR-08-2	파싱이 완료되면 자동으로 [신호 선택] 탭으로 전환한다.
FR-08-3	변환이 완료되면 자동으로 [미리보기] 탭으로 전환한다.
FR-08-4	탭은 사용자가 언제든지 자유롭게 클릭하여 이동할 수 있다.

FR-09. 설정 탭

ID	요구 조건
FR-09-1	[설정] 탭에 언어 선택 `QComboBox`가 있어야 한다. 선택 가능한 언어는 한국어, English, 中文 세 가지이다.
FR-09-2	언어를 변경하면 앱을 재시작하지 않고 즉시 모든 UI 텍스트(탭 이름, 버튼, 레이블, 메시지, 상태 표시줄 등)가 선택한 언어로 갱신되어야 한다.
FR-09-3	모든 UI 문자열은 언어 키 딕셔너리(`STRINGS`)로 중앙 관리하며, 하드코딩 문자열을 UI 위젯에 직접 사용하지 않아야 한다.
FR-09-4	선택된 언어는 `QSettings`에 저장되어 다음 실행 시 자동으로 복원되어야 한다.
FR-09-5	앱 최초 실행 시 기본 언어는 한국어이다.
FR-09-6	[설정] 탭에 BLF 파싱 크기 제한 입력 필드(`QLineEdit`)가 있어야 한다. 단위는 MB이며 기본값은 5이다. 입력된 값은 `QSettings`에 저장되어 다음 실행 시 자동으로 복원된다. 유효하지 않은 값(숫자가 아닌 경우)이 입력된 경우 기본값(5 MB)을 사용한다.
FR-09-7	[설정] 탭에 병렬 프로세스 수 입력 필드(`QLineEdit`)가 있어야 한다. 기본값은 `cpu_count - 1` (최소 1)이다. 입력된 값은 `QSettings`에 저장·복원된다. 유효하지 않은 값이 입력된 경우 기본값을 사용한다.
FR-09-8	[설정] 탭에 배치 크기 (프레임) 입력 필드(`QLineEdit`)가 있어야 한다. BLF를 멀티프로세싱으로 변환할 때 한 번에 처리할 프레임 수를 지정한다. 기본값은 200,000 프레임이다. 입력된 값은 `QSettings`에 저장·복원된다. 유효하지 않은 값이 입력된 경우 기본값을 사용한다.

FR-10. 멀티프로세싱 변환

ID	요구 조건
FR-10-1	변환 실행 시 BLF 파일을 배치 크기(FR-09-8) 프레임 단위 청크로 순차 분할하고, `ProcessPoolExecutor`를 사용하여 각 청크를 병렬로 디코딩·변환한다.
FR-10-2	병렬 프로세스 수는 FR-09-7에서 설정한 값을 사용한다.
FR-10-3	각 청크의 변환 결과를 수집하여 신호별로 시간순으로 합산(concatenate)한다. 청크 경계에서 신호 불연속이 발생하지 않도록 타임스탬프 기준으로 정렬하여 합친다.
FR-10-4	멀티프로세싱 진행 상태는 완료된 청크 수 및 처리된 데이터 크기로 FR-06-4의 형식에 따라 표시한다.
FR-10-5	멀티프로세싱은 워커 프로세스 간 통신 오버헤드를 최소화하기 위해 각 청크를 독립적으로 직렬화하여 서브프로세스에 전달한다. 서브프로세스에서는 `can.io.BLFReader`와 `cantools`를 사용하지 않고, 이미 파싱된 메시지 바이트를 받아 디코딩만 수행한다.

3. 비기능 요구 조건

ID	요구 조건
NFR-01	BLF 파일 파싱 시 `can.io.BLFReader`와 `cantools`를 사용한다.
NFR-02	MDF 저장 시 `asammdf` 라이브러리를 사용한다.
NFR-03	앱 종료 시 창 크기·위치, 마지막으로 사용한 디렉터리, BLF 파싱 크기 제한 값 등을 `QSettings`에 저장하고, 다음 실행 시 복원해야 한다.
NFR-04	대용량 BLF 파일(수백 MB)을 처리할 수 있어야 한다. BLF 스캔 및 변환은 워커 스레드에서 실행되어 UI가 응답 불가 상태가 되지 않아야 한다.
NFR-05	BLF 파싱 중 알 수 없는 메시지는 건너뛰고 처리를 계속해야 한다 (DBC 미등록 메시지).
NFR-06	신호 선택 저장 파일은 사람이 읽을 수 있는 JSON 형식이어야 한다.
NFR-07	UI 문자열은 `STRINGS` 딕셔너리(`{ "ko": {...}, "en": {...}, "zh": {...} }`)로 관리한다. 언어 변경 시 모든 위젯에 대해 `retranslate_ui()` 메서드를 호출하여 문자열을 갱신한다.
NFR-08	멀티프로세싱 사용 시 Windows에서 `if __name__ == "__main__":` 가드와 `multiprocessing.freeze_support()`를 메인 진입점에 호출하여 서브프로세스 스폰 문제를 방지한다.

4. UI 레이아웃 (탭 구조)

공통 헤더: 앱 제목 + 탭 바 (QTabWidget)

탭 1: 파일 입력

┌─────────────────────────────────────────────────────────────────────┐
│  BLF + DBC → MDF 변환 도구                                           │
├───────────┬──────────┬──────────────────┬───────────┬──────────────┤
│ [파일 입력]│[신호 선택]│ [변환 옵션/실행] │ [미리보기] │  [설정]      │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  BLF 파일                                                           │
│  [경로 표시_____________________________________________]  [선택...] │
│  크기: 128.4 MB                                                     │
│                                                                     │
│  DBC 파일                                                           │
│  [경로 표시_____________________________________________]  [선택...] │
│  크기: 24.1 KB                                                      │
│                                                                     │
│                        [▶ 파싱]                                     │
│                                                                     │
│  상태: BLF 스캔 중... (DBC: 20개 메시지 / BLF 스캔 40%)             │
│  진행: [████████░░░░░░░░░░░░░░] 40%        [■ 취소]                 │
│                                                                     │
├─────────────────────────────────────────────────────────────────────┤
│  상태 표시줄                                                         │
└─────────────────────────────────────────────────────────────────────┘

탭 2: 신호 선택

┌─────────────────────────────────────────────────────────────────────┐
│  BLF + DBC → MDF 변환 도구                                           │
├───────────┬──────────┬──────────────────┬───────────┬──────────────┤
│ [파일 입력]│[신호 선택]│ [변환 옵션/실행] │ [미리보기] │  [설정]      │
├─────────────────────────────────────────────────────────────────────┤
│ [전체 선택] [전체 해제] [메시지 수준] [신호 수준]  [선택 저장] [선택 로드]  BLF: 12/20 메시지 발견  선택된 신호: 3개 │
├──────────────────────────┬────────┬──────────┬──────────────────────┤
│  메시지 / 신호            │  단위  │  최솟값  │  최댓값              │
├──────────────────────────┴────────┴──────────┴──────────────────────┤
│  ☑ MSG_001 (0x123)   3개 신호                                       │
│    ├ ☑ WHL_SPD_FL          km/h       0.0        300.0             │
│    ├ ☑ WHL_SPD_FR          km/h       0.0        300.0             │
│    └ ☐ WHL_SPD_RL          km/h       0.0        300.0             │
│  ☑ MSG_002 (0x200)   2개 신호                                       │
│    ├ ☑ YAW_RATE            deg/s   -300.0        300.0             │
│    └ ☐ LAT_ACCEL           m/s²     -20.0         20.0             │
│  ☐ MSG_003 (0x300)   ← 회색 (BLF에 없음)                           │
│    ├ ☐ SIG_A               -          0.0          1.0             │
│    └ ☐ SIG_B               -          0.0        255.0             │
│  ...                                                                │
│  (QTreeWidget, 화면 전체 높이 활용)                                  │
├─────────────────────────────────────────────────────────────────────┤
│  상태 표시줄                                                         │
└─────────────────────────────────────────────────────────────────────┘

탭 3: 변환 옵션 및 실행

┌─────────────────────────────────────────────────────────────────────┐
│  BLF + DBC → MDF 변환 도구                                           │
├───────────┬──────────┬──────────────────┬───────────┬──────────────┤
│ [파일 입력]│[신호 선택]│ [변환 옵션/실행] │ [미리보기] │  [설정]      │
├─────────────────────────────────────────────────────────────────────┤
│  변환 옵션                                                           │
│  ☑ 리샘플링     주기: [20___] ms                                    │
│  ☑ 타임스탬프 정규화 (0초 시작)                                      │
│  MDF 버전: [MDF4 (.mf4)  ▼]                                        │
│                                                                     │
│  출력 파일                                                           │
│  [경로 표시_____________________________________________]  [선택...] │
│                                                                     │
│  ─────────────────────────────────────────────────────────────────  │
│  [▶ 변환 실행]   [■ 취소]                                            │
│  상태: MDF 저장 중...                                                │
│  진행: [████████████░░░░░░░░] 60%   BLF 파싱 → NaN 처리 → MDF 저장  │
│        변환 중... BLF 파싱 (12.3 MB / 45.6 MB, 8 sec)               │
│                                                                     │
│  ─────────────────────────────────────────────────────────────────  │
│  결과 요약                                                           │
│  신호 수: 3          원본 프레임: 117,853       저장 행 수: 16,837   │
│  시간 범위: 0.0 ~ 336.7 초                                           │
│  저장 경로: C:/output/xxx_resampled_20ms.mf4                        │
│                                                                     │
├─────────────────────────────────────────────────────────────────────┤
│  상태 표시줄                                                         │
└─────────────────────────────────────────────────────────────────────┘

탭 4: 미리보기

┌─────────────────────────────────────────────────────────────────────┐
│  BLF + DBC → MDF 변환 도구                                           │
├───────────┬──────────┬──────────────────┬───────────┬──────────────┤
│ [파일 입력]│[신호 선택]│ [변환 옵션/실행] │ [미리보기] │  [설정]      │
├──────────────────────────────────────────────┬──────────────────────┤
│  파일: [경로_______________________________]  │  timestamp (s)  값   │
│  [MDF 열기]                                   │  0.000000       0.0  │
│                                               │  0.020000       12.5 │
│  신호  ☑개별 그래프                            │  0.040000       12.3 │
│  ┌─────────────────────────────────────────┐  │  ...                 │
│  │☑ WHL_SPD_FL  ☑ WHL_SPD_FR  ☐ YAW_RATE│  │  (QTableWidget,      │
│  │☐ LAT_ACCEL  ...                        │  │   2 컬럼,            │
│  └─────────────────────────────────────────┘  │   선택 신호 기준)    │
│  (QListWidget, 수평 흐름, 최대 140px 높이)      │                     │
│                                               │                     │
│  ┌─────────────────────────────────────────┐  │                     │
│  │                                         │  │                     │
│  │        pyqtgraph 차트 영역              │  │                     │
│  │        (흰 배경, 서브플롯 또는 단일)     │  │                     │
│  │                                         │  │                     │
│  └─────────────────────────────────────────┘  │                     │
│      ← 좌측 패널 (4) →                         │ ← 우측 패널 (1) →  │
├──────────────────────────────────────────────┴──────────────────────┤
│  상태 표시줄                                                         │
└─────────────────────────────────────────────────────────────────────┘

탭 5: 설정

┌─────────────────────────────────────────────────────────────────────┐
│  BLF + DBC → MDF 변환 도구                                           │
├───────────┬──────────┬──────────────────┬───────────┬──────────────┤
│ [파일 입력]│[신호 선택]│ [변환 옵션/실행] │ [미리보기] │  [설정]      │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  언어 / Language / 语言                                              │
│  [한국어  ▼]                                                        │
│   ├ 한국어                                                           │
│   ├ English                                                         │
│   └ 中文                                                            │
│                                                                     │
│  BLF 파싱 크기   [5___] MB                                          │
│  (파싱 단계에서 BLF 파일의 앞부분만 읽는 크기. 기본값: 5 MB)          │
│                                                                     │
│  병렬 프로세스 수   [7__]                                            │
│  (멀티프로세싱 변환에 사용할 워커 수. 기본: cpu_count - 1)            │
│                                                                     │
│  배치 크기 (프레임)   [200000____]                                   │
│  (한 번에 처리할 BLF 프레임 수. 기본: 200,000)                       │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

5. 의존 라이브러리

라이브러리	용도	설치
`PySide6`	데스크톱 GUI 프레임워크	`pip install PySide6`
`cantools`	DBC 파싱	`pip install cantools`
`python-can`	BLF 파일 읽기	`pip install python-can`
`asammdf`	MDF4 파일 저장/읽기	`pip install asammdf`
`pandas`	데이터 처리	`pip install pandas`
`numpy`	수치 연산	`pip install numpy`
`pyqtgraph`	결과 미리보기 차트	`pip install pyqtgraph`
`multiprocessing`	멀티프로세싱 변환 (Python 표준 라이브러리)	별도 설치 불필요

6. 미결 사항 (Open Issues)

ID	내용
OI-01	복수의 DBC 파일 지원 여부 (멀티 버스 환경)
OI-02	BLF에 복수의 CAN 채널이 있는 경우 채널 필터링 여부
OI-03	변환 설정(리샘플링 여부, 주기, 정규화 여부, MDF 버전)도 신호 선택 JSON과 함께 저장/로드할지 여부
OI-04	변환 완료 후 MDF 파일 다운로드 버튼 제공 여부 (로컬 앱이라면 불필요)

7. 미결 사항에 대한 결정

아래는 클로드가 오픈 이슈라고 문의한 것에 대해 내가 답을 한 것이다.
OI-01: MVP 개발 단계에서는 단수 DBC 파일 지원만 고려한다.
OI-02: BLF에 복수의 CAN 채널이 있을 경우, 동일 신호명이 여러 채널에 존재하면 신호이름_채널번호 형식으로 구분한다. 단일 채널만 존재하는 경우에는 접미사를 붙이지 않는다.
OI-03: JSON 저장 파일에는 선택된 신호 목록만 포함한다. 변환 설정(리샘플링 여부, 주기, 정규화 여부, MDF 버전)은 저장하지 않는다.
OI-04: 다운로드 버튼은 필요하지 않다. 로컬 앱으로 개발한다.

blf & dbc --> mdf 변환

hsl7 — Sun, 8 Mar 2026 15:04:10 +0900

시작하기 전에

일이라는 것이 결정들의 연속이다. 엔지니어링도 그렇다. 측정과 연산 기술의 발전으로 감/경험에 기반한 결정들이 데이터 기반 결정들로 대체되고 있다. 최근에 데이터 기반 결정이 적용되는 영역이 빠르게 넓어지고 있다고 느낀다. CAN 데이터를 mdf 파일로 저장하는 방법 문의를 점점 더 많이 받는다.

blf 파일과 dbc 파일을 입력으로 받아 mdf 파일을 생성하는 간단한 프로그램을 클로드와 만들었다. 그 방법을 설명한다.

blf+dbc --> mdf 변환기 GUI

개요

blf vs. mdf
메시지 파싱하기
blf에서 메시지 읽기
mdf 파일로 저장하기
코드
프로그램
결론

blf vs. mdf

CAN 데이터는 주로 blf 파일로 저장된다. blf는 메시지 기반이다. 프레임들은 수신된 순서대로 타임스탬프와 함께 파일에 저장된다. 특정 신호의 시간에 따른 변화를 보기에 불편하다. 아래 그림은 blf 파일에 CAN 프레임들이 저장된 상태를 시각화한 것이다. 빈 칸은 진짜 빈 칸일 수도 다른 신호일 수도 있다.

blf 파일에 CAN 프레임은 수신 순서대로 저장된다.

데이터가 아래 그림처럼 저장되어 있다면 데이터 처리에 좋을 것이다. 나는 이런 형태를 신호 기반이라고 칭했다. 행과 열로 구성된 엑셀 표 형식이다. 파이썬 numpy의 2-D 어레이나 pandas의 데이터프레임이 대표적이다.

pandas의 데이터프레임 형식이다. 데이터처리가 쉽다.

나는 이전 포스트들에서 blf를 데이터프레임으로 변환하는 방법을 설명하였었다.
mdf 파일은 신호 기반이라고 할 수 있다. mdf는 신호별로 타임스탬프를 별도로 저장한다. 위 그림의 blf 파일을 mdf 파일로 저장한 경우는 아래 그림처럼 표현할 수 있다. (개념만 표현한 것이다. 타임스탬프가 같은 경우, 저장 공간의 낭비를 줄이기 위한 방법이 적용되어 있다.)

mdf는 신호와 신호의 타임스탬프를 개별적으로 저장한다.

기회가 있을 때 설명을 하자면, 내가 blf를 데이터프레임으로 바꾸는 방법은 아래와 같다.

blf를 데이터프레임으로 변환하는 방법

dbc의 메시지/신호 정의를 이용하여 메시지 기반의 blf 데이터를 신호 기반으로 변환(파싱)한다.
변환된 데이터에는 빈 칸이 많이 있다. "결측치"이다. 이 결측치를 채운다. 빈 칸 바로 위의 측정값으로 채운다.
필요한 주기로 다시 샘플링(resample) 한다. 샘플링 구간의 대표값을 구간의 시작값/마지막값/평균값/중간값 등으로 할 수 있다.

메시지 파싱하기

CAN 메시지의 데이터를 신호로 파싱하기 위해서는
- dbc를 읽어 메시지/신호 정의를 파악해야 한다.
- 메시지/신호의 정의에 따라 데이터를 파싱해야 한다.
cantools 모듈을 사용했다. (cantools/cantools: CAN bus tools.)

import cantools    # cantools를 import 한다.

# dbc 파일 읽기
db = cantools.database.load_file(dbc_path)

# CAN 메시지의 데이터를 신호별로 읽기
# 한 개 CAN 메시지에 대해 아래 작업을 한다.
decoded = db.decode_message(mid, data)	# mid: message id, data: data
for sig_name, value in decoded.items():
    try:
        fval = float(value)			# 일반 신호를 읽는다.
    except (TypeError, ValueError):
        fval = float(value.value)	# ValueTable이 있는 경우, 값을 읽는다.
    results.append((mid, sig_name, ts, ch, fval))	# 메시지를 처리하여 신호 단위로 모은다.

blf 에서 메시지 읽기

blf 파일에서 CAN 프레임을 하나씩 읽어가며 파싱을 해야 한다. 그러기 위해 python-can 모듈을 사용했다. ( hardbyte/python-can: The can package provides controller area network support for Python developers)

import can # python-can을 import 한다.

# blf 파일에서 메시지 읽기
with can.BLFReader(path_to_blf_file) as reader:    # blf 파일을 연다.
    for msg in reader:              # 메시지를 하나씩 읽는다.
        mid = msg.arbitration_id    # ID 확인 방법
        ch = msg.channel            # 채널 확인 방법
        ts = msg.timestamp          # 타임스탬프 확인 방법
        data = msg.data             # 데이터를 bytearray로 확인 방법

여기 mid와 data를 db.decode_message(mid, data) 함수에 넣어서 최종적으로 (신호, 값) 쌍들로 파싱한다.
이를 처리하여 신호별로 (타임스탬프, 값) 쌍의 어레이를 만들 수 있다.

mdf로 저장하기

mdf는 ASAM(Association for Standardization of Automotation and Measuring Systems, https://www.asam.net/)이라는 조직에서 만든 표준이다.
(타임스탬프, 값) 쌍으로 구성된 어레이의 묶음을 mdf 파일로 저장한다. 이를 위해서 asammdf 모듈을 사용했다. ( Welcome to asammdf’s documentation! — asammdf 8.7.2 documentation)

from asammdf import MDF                    # mdf 파일을 다루기 위해 asammdf 모듈에서 MDF를 import 한다.
from asammdf import Signal as MdfSignal    # 신호 수준 처리를 위해 asammdf 모듈에서 Singla을 import 한다.

mdf = MDF(version=mdf_version) # mdf 파일을 연다.


# Build unit lookup: sig_name → unit
mdf_signals = []
for fname, (ts, vs) in final_signals.items():
    # fname format: "MSG_NAME.SIG_NAME" or "MSG_NAME.SIG_NAME_chN"
    raw_sig_name = fname.split(".")[-1]
    # Strip _chN suffix to find unit
    base_sig_name = raw_sig_name
    if "_ch" in raw_sig_name:
        base_sig_name = raw_sig_name.rsplit("_ch", 1)[0]
    unit = sig_unit.get(base_sig_name, "")

    mdf_signals.append(
        MdfSignal(		
            samples=vs,
            timestamps=ts,
            name=fname.replace(".", "__"),
            unit=unit,
        ) # 신호값(vs), 타임스탬프(ts), 신호 이름, 신호 단위로 mdf 신호를 생성한다.
    ) # Mdf 신호들을 묶어서 mdf_signals라는 리스트를 만든다. 

mdf.append(mdf_signals)    # mdf 파일에 mdf_signals의 데이터를 추가한다.
mdf.save(output_path, overwrite=True)   # mdf 파일에 저장한다.
mdf.close()    # mdf 파일을 닫는다.

코드

코드와 파이썬 모듈 설치를 위한 requirements.txt 파일은 첨부와 같다. 두 파일들을 같은 디렉토리에 저장한다.

파일들을 저장한 디렉토리에서 커맨트라인 창을 연다.
아래 명령어로 프로그램 실행에 필요한 파이썬 모듈들을 설치한다.

pip install -r requirements.txt

아래 명령으로 프로그램을 실행한다.

python blf_dbc_to_mdf_mp.py

프로그램 이름 마지막의 mp는 multiprocessing을 의미한다. 변환 속도를 높이기 위해 blf 파일을 쪼개서 각각 변환한 후에 다시 합치는 방식을 적용했다. 각각을 변환할 때 멀티프로세싱을 적용했다. 클로드가 없었다면 여러 시간/날 걸렸을 일이다. 멀티프로세싱 적용 가능성과 기대 효과를 문의하고, 구현해 달라고 요청하는 것으로 멀티프로세싱 기능을 추가했다.
클로드와 코딩을 하면서 작성한 FRD: FRD: blf & dbc --> mdf :: hsl's tsmaster 사용기

프로그램

파일 입력

blf 파일과 dbc 파일을 선택할 수 있따. '선택...' 버튼을 클릭하면 익숙한 파일 열기 대화창이 뜬다.
blf와 dbc를 선택한 후에 '파싱' 버튼을 누르면
- blf 파일에 포함된 메시지 아이디들을 추출한다.
- dbc 파일에 포함된 메시지/신호 정의를 로드한다.

신호 선택

mdf 파일로 추출할 신호들을 선택한다. blf에 있는 신호들만 선택 가능하다. 선택을 json 파일로 저장하여 재사용 할 수 있다.

변환 옵션 및 실행

blf를 mdf로 변환 한다.
- 리샘플링 주기와 방법을 설정할 수 있다.
- 첫 메시지의 타임스탬프를 0s이 되도록(타임스탬프 정규화) 할 수 있다.
- mdf 버전을 선택할 수 있다.
mdf 파일 경로와 이름을 지정할 수 있다.

미리보기

(변환 결과로 생성된) mdf 파일을 볼 수 있다.
관심이 있는 신호들을 그래프로 볼 수 있다.

결론

메시지 기반 blf 파일에서 신호 기반 mdf 파일 생성하는 프로그램을 만들었다.
blf에 정의된 메시지/신호를 알기 위해서 dbc 파일이 함께 필요하다.
cantools 모듈을 사용하면 몇 줄의 코드로 dbc에서 메시지/신호 정의를 알 수 있고, CAN 메시지를 신호들로 파싱할 수 있다.
python-can 모듈을 사용하면 blf 파일에서 CAN 메시지를 하나씩 읽어서 처리할 수 있다.
asammdf 모듈을 사용하면 신호별로 마련한 (타임스탬프, 값) 에레이들을 묶어서 mdf 파일로 저장할 수 있다.

blf와 dbc를 읽어서 csv로 저장하는 기능을 추가하였다.

blf & dbc --> mdf or csv 변환 :: hsl's tsmaster 사용기

hsl's tsmaster 사용기 목차 :: hsl's tsmaster 사용기