1. 압력 센서 온도 보정의 원리와 중요성(Importance and Principles of Pressure Sensor Temperature Compensation)
압력 센서 온도 보정은 센서의 정확한 데이터를 얻기 위해 필수적인 기술입니다. 압력 센서는 자동차, 산업 제어, 의료 기기 등 다양한 분야에서 사용되지만, 온도 변화에 따라 출력값(ADC, LSB 단위)이 비선형적으로 변동합니다. 이는 센서의 재료 특성(예: 피에조 저항 효과)이나 전자 회로의 온도 의존성 때문입니다.(Temperature compensation for pressure sensors is an essential technique to obtain accurate data. Pressure sensors are used in various fields such as automotive, industrial control, and medical devices, but their output values (ADC, in LSB units) vary non-linearly with temperature changes due to material properties (e.g., piezoresistive effects) or temperature-dependent electronics.)
keywords: 압력_센서 ,온도_보정 딥러닝, AI_기반, 임베디드_시스템 ,데이터_분석 ,신경망 센서_보정,pressure_sensor ,temperature_compensation ,deep_learning ,AI_based embedded_system, data_analysis ,neural_network, sensor_compensation
1.1. 압력 센서 온도 보정의 필요성
- 문제점: 압력 센서의 ADC 출력은 온도 변화에 따라 달라집니다. 예를 들어, 동일한 압력(50 kPa)에서 -45°C와 125°C에서의 ADC 값이 크게 다릅니다.
- 목표: 온도와 압력 데이터를 활용해 ADC 값을 목표 값(0 kPa → 0 LSB, 50 kPa → 8192 LSB, 100 kPa → 16384 LSB)으로 보정하여 정확한 압력 측정을 보장합니다.
- 방법: 신경망과 딥러닝 기술을 사용하여 온도와 ADC 값 간의 비선형 관계를 학습합니다. 선형 회귀로는 복잡한 패턴을 충분히 모델링하기 어려우므로 AI 기반 접근이 효과적입니다.
1.2. 딥러닝으로 압력 센서 온도 보정 구현
딥러닝 기반 신경망은 온도와 원본 ADC 값을 입력으로 받아 목표 ADC 값을 예측합니다. 주요 원리는 다음과 같습니다:
- 비선형 매핑: 신경망의 ReLU 활성화 함수를 통해 온도와 ADC 값 간의 복잡한 관계를 학습.
- 정규화: 입력(온도, ADC)과 출력(목표 ADC)을 정규화하여 학습 안정성과 속도를 개선.
- 학습: 평균 제곱 오차(MSE)를 최소화하도록 가중치를 최적화하여 정확한 ADC 보정.
- 임베디드 시스템 배포: 학습된 가중치와 편향을 추출하여 마이크로컨트롤러와 같은 임베디드 시스템에 적용 가능.
1.3. 다른 센서로의 확장 가능성
이 알고리즘은 압력 센서뿐만 아니라 온도 보정이 필요한 다른 센서에도 적용 가능합니다. 예를 들어:
- 온도 센서:
- 온도 센서의 출력은 환경 온도나 전자 회로의 비선형성에 따라 왜곡될 수 있습니다. 신경망을 통해 이러한 왜곡을 보정 가능.
- 가속도 센서:
- 자동차나 드론에서 사용되는 가속도 센서는 온도 변화에 따라 출력이 변동할 수 있으며, 이 알고리즘으로 보정 가능.
- 기타 센서:
- 습도 센서, 광 센서 등 온도 의존성을 가진 센서에 대해 입력 데이터(예: 온도, 원본 출력)와 목표 출력을 학습하여 보정 가능.
- 적용 방법: 센서별로 적절한 데이터(입력: 온도 및 원본 출력, 출력: 목표 값)를 수집하고, 동일한 신경망 구조와 학습 과정을 적용하면 됩니다.
2. 데이터 수집과 AI 기반 온도 보정 과정
2.1. 압력 센서 데이터 수집
압력 센서 데이터 수집은 온도 보정의 첫 단계입니다. 데이터는 다음과 같은 방식으로 수집되었습니다:
- 측정 환경:
- 압력 조건: 0 kPa, 50 kPa, 100 kPa의 3가지 압력 값을 설정. 이는 압력 센서의 작동 범위(0~100 kPa)를 대표하는 값들입니다.
- 온도 조건: -45°C에서 125°C까지 10°C 간격으로 설정. 이 범위는 자동차나 산업 환경에서 압력 센서가 노출될 수 있는 극단적인 온도를 포함합니다.
- ADC 값: 압력 센서의 출력은 아날로그-디지털 변환기(ADC)를 통해 LSB(Least Significant Bit) 단위로 측정. 예: 950~11620 LSB.
- 데이터 구성: 각 데이터 포인트는 (압력(kPa), 온도(°C), ADC 값(LSB)) 형식으로 구성.
- 데이터 특징: 총 54개 데이터 포인트(3 압력 × 18 온도). 온도에 따라 ADC 값이 변동하며, 목표 ADC 값(0, 8192, 16384 LSB)과 오차가 존재.
- 수집 방법: 제어된 환경(예: 온도 챔버)에서 압력과 온도를 고정하고 센서 출력을 기록. 이는 실제 센서의 비선형 온도 특성을 반영합니다.
- 목적: 이 데이터를 활용해 AI 기반 신경망 모델로 온도 영향을 보정.
2.2. 신경망을 활용한 온도 보정 워크플로
AI 기반 온도 보정 과정은 다음과 같이 진행됩니다:
- 데이터 준비: 원본 데이터를 입력(온도, 원본 ADC)과 출력(목표 ADC)으로 분리하고 정규화.
- 신경망 설계: 입력층(2개 노드: 온도, ADC), 은닉층(16개 노드, ReLU), 출력층(1개 노드)으로 구성된 피드포워드 신경망.
- 학습: 미니 배치 학습과 Adam 옵티마이저를 사용해 MSE 손실 최소화.
- 예측: 학습된 모델로 보정된 ADC 값 예측.
- 가중치 추출: 학습된 가중치를 C 코드 형식으로 출력해 임베디드 시스템에 배포.
- 결과 시각화: 원본 ADC와 보정된 ADC를 비교하고 학습 손실을 시각화.
3. 구현된 알고리즘 단계별 설명 및 코드
아래는 AI 기반 압력 센서 온도 보정 알고리즘의 주요 단계를 설명하며, 각 단계에 해당하는 코드를 포함합니다.
3.1. 데이터 준비: 압력 센서 데이터 전처리
- 설명:
- 압력 센서 데이터를 입력(온도, 원본 ADC)과 출력(목표 ADC)으로 분리.
- 입력 데이터는 온도와 원본 ADC 값을 결합하여 (54, 2) 배열로 구성.
- 출력 데이터는 압력에 따라 목표 ADC 값(0, 8192, 16384 LSB) 설정.
- 데이터를 정규화(평균 0, 표준편차 1)하여 학습 안정성 확보.
- PyTorch 텐서로 변환하여 딥러닝 학습에 사용.
- 의미: 데이터 전처리와 정규화를 통해 신경망 학습의 효율성과 안정성을 높입니다.
- 코드:
# 원본 측정 데이터: (압력(kPa), 온도(°C), ADC 값(LSB)) # 데이터는 제어된 환경(온도 챔버)에서 압력(0, 50, 100 kPa)과 온도(-45°C~125°C, 10°C 간격)로 측정 measurements = [ (0, -45, 950), (50, -45, 5900), (100, -45, 10800), ... (0, 125, 1059), (50, 125, 6212), (100, 125, 11620) ] # 상수 정의: 목표 ADC 값 (압력에 따른 선형 매핑) TARGET_MIN = 0 # 0 kPa -> 0 LSB TARGET_CENTER = 8192 # 50 kPa -> 8192 LSB TARGET_MAX = 16384 # 100 kPa -> 16384 LSB TEMP_RANGE = range(-45, 126, 10) # 온도 범위: -45°C ~ 125°C, 10°C 간격 # 데이터 분리: 압력, 온도, 원본 ADC 값 추출 pressures = np.array([m[0] for m in measurements]) # 압력(kPa) temps = np.array([m[1] for m in measurements]) # 온도(°C) raw_adc = np.array([m[2] for m in measurements]) # 원본 ADC 값(LSB) # 목표 ADC 값 설정: 압력에 따라 선형 매핑 target_adc = np.array([TARGET_MIN if p == 0 else TARGET_CENTER if p == 50 else TARGET_MAX for p in pressures]) # 입력과 출력 데이터 구성 # 입력: 온도와 원본 ADC 값을 결합하여 (54, 2) 배열 생성 # 출력: 목표 ADC 값으로 (54,) 배열 생성 X = np.column_stack((temps, raw_adc)) y = target_adc # 데이터 정규화: 평균 0, 표준편차 1로 변환 X_mean = np.mean(X, axis=0) # 입력 데이터의 평균 (온도, ADC) X_std = np.std(X, axis=0) # 입력 데이터의 표준편차 X_normalized = (X - X_mean) / X_std # 정규화된 입력 y_mean = np.mean(y) # 출력 데이터의 평균 y_std = np.std(y) # 출력 데이터의 표준편차 y_normalized = (y - y_mean) / y_std # 정규화된 출력 # PyTorch 텐서로 변환: 신경망 학습을 위해 데이터 형식 변환 X_normalized = torch.tensor(X_normalized, dtype=torch.float32) y_normalized = torch.tensor(y_normalized, dtype=torch.float32).reshape(-1, 1)
3.2. 신경망 모델 설계: 딥러닝 구조 정의
- 설명:
- 피드포워드 신경망 설계: 입력층(2개 노드: 온도, ADC), 은닉층(16개 노드, ReLU 활성화), 출력층(1개 노드).
- 손실 함수로 평균 제곱 오차(MSE) 사용.
- Adam 옵티마이저(학습률 0.001)로 가중치 최적화.
- 의미: 간단한 신경망 구조로 온도와 ADC 간 비선형 관계를 효과적으로 학습.
- 코드:
# 신경망 모델 정의 class NeuralNetwork(nn.Module): def __init__(self): super(NeuralNetwork, self).__init__() self.hidden = nn.Linear(2, 16) # 입력층(2: 온도, ADC) -> 은닉층(16) self.relu = nn.ReLU() # 비선형 활성화 함수 (ReLU) self.output = nn.Linear(16, 1) # 은닉층(16) -> 출력층(1: 보정된 ADC) def forward(self, x): x = self.relu(self.hidden(x)) # 은닉층 통과 후 ReLU 적용 x = self.output(x) # 출력층 통과 return x # 모델, 손실 함수, 옵티마이저 초기화 model = NeuralNetwork() # 신경망 객체 생성 criterion = nn.MSELoss() # 평균 제곱 오차 손실 함수 optimizer = optim.Adam(model.parameters(), lr=0.001) # Adam 옵티마이저, 학습률 0.001
3.3. 학습: 신경망 훈련
- 설명:
- 1000번의 에포크 동안 미니 배치 학습(배치 크기 16) 수행.
- 데이터 무작위 섞기를 통해 일반화 성능 개선.
- 순전파로 예측값 계산, MSE 손실 계산, 역전파로 가중치 업데이트.
- 에포크별 평균 손실 기록 및 100번째 에포크마다 출력.
- 의미: 딥러닝 학습을 통해 데이터의 패턴을 학습하고 보정 성능 최적화.
- 코드:
# 학습 설정 num_epochs = 1000 # 학습 반복 횟수 batch_size = 16 # 미니 배치 크기 num_batches = len(X_normalized) // batch_size # 배치 수 계산 # 학습 루프 history = {'loss': []} # 손실 기록을 위한 딕셔너리 model.train() # 모델을 학습 모드로 설정 for epoch in range(num_epochs): epoch_loss = 0.0 # 에포크별 손실 초기화 indices = torch.randperm(len(X_normalized)) # 데이터 무작위 섞기 for i in range(0, len(X_normalized), batch_size): batch_indices = indices[i:i + batch_size] # 배치 인덱스 추출 X_batch = X_normalized[batch_indices] # 배치 입력 데이터 y_batch = y_normalized[batch_indices] # 배치 출력 데이터 # 순전파: 예측값 계산 outputs = model(X_batch) loss = criterion(outputs, y_batch) # MSE 손실 계산 # 역전파 및 최적화 optimizer.zero_grad() # 기울기 초기화 loss.backward() # 기울기 계산 optimizer.step() # 가중치 업데이트 epoch_loss += loss.item() * len(X_batch) # 배치 손실 누적 epoch_loss /= len(X_normalized) # 에포크 평균 손실 계산 history['loss'].append(epoch_loss) # 손실 기록 if (epoch + 1) % 100 == 0: # 100번째 에포크마다 손실 출력 print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {epoch_loss:.6f}')
3.4. 예측: 보정된 ADC 값 생성
- 설명:
- 모델을 평가 모드로 전환하고 기울기 계산 비활성화.
- 정규화된 입력 데이터를 모델에 통과시켜 예측값 생성.
- 예측값을 역정규화하여 실제 ADC 값으로 변환.
- 의미: 학습된 신경망으로 온도 보정된 ADC 값을 예측.
- 코드:
# 예측: 보정된 ADC 값 생성 model.eval() # 모델을 평가 모드로 전환 with torch.no_grad(): # 기울기 계산 비활성화 y_pred_normalized = model(X_normalized) # 정규화된 예측값 corrected_adc = y_pred_normalized.numpy() * y_std + y_mean # 역정규화
3.5. 가중치 및 편향 추출: 임베디드 시스템 배포
- 설명:
- 학습된 가중치(w1, w2)와 편향(b1, b2) 추출.
- 정규화 파라미터와 함께 C 코드 형식으로 출력.
- 의미: 임베디드 시스템에서 신경망 계산을 수행할 수 있도록 준비.
- 코드:
# 가중치 및 편향 추출: 임베디드 시스템 배포용 state_dict = model.state_dict() w1 = state_dict['hidden.weight'].numpy() # 은닉층 가중치 (16, 2) b1 = state_dict['hidden.bias'].numpy() # 은닉층 편향 (16,) w2 = state_dict['output.weight'].numpy() # 출력층 가중치 (1, 16) b2 = state_dict['output.bias'].numpy() # 출력층 편향 (1,) # C 코드 형식으로 가중치와 편향 출력 print("=== 추출된 가중치와 편향 ===") print(f"float w1[2][16] = {w1.T.tolist()};") # 전치하여 C 배열 형식으로 print(f"float b1[16] = {b1.tolist()};") print(f"float w2[16] = {w2.flatten().tolist()};") print(f"float b2 = {b2[0]};") print(f"float X_mean[2] = {X_mean.tolist()};") print(f"float X_std[2] = {X_std.tolist()};") print(f"float y_mean = {y_mean};") print(f"float y_std = {y_std};")
3.6. 결과 시각화: 데이터 분석 및 성능 평가
- 설명:
- 학습 손실 플롯: 에포크에 따른 MSE 손실을 시각화하여 학습 수렴 확인. 파일로 저장(training_loss.png).
- 보정 결과 플롯: 온도별 원본 ADC와 보정된 ADC 비교. 목표 선(0 kPa → 0 LSB, 100 kPa → 16384 LSB)을 추가. 온도별 색상 구분, 원본 데이터는 점선과 'x' 마커, 보정된 데이터는 실선과 'o' 마커로 표시. 파일로 저장(pressure_vs_adc.png).
- 의미: 데이터 분석을 통해 학습 과정과 온도 보정 성능을 직관적으로 평가.
- 코드:
# 보정 결과 플롯 함수 def plot_results(pressures, temps, raw_adc, corrected_adc): temp_groups = {t: [] for t in range(-45, 126, 10)} # 온도별 데이터 그룹화 for p, t, raw, corr in zip(pressures, temps, raw_adc, corrected_adc.flatten()): temp_groups[t].append((p, raw, corr)) # 압력, 원본 ADC, 보정 ADC 저장 plt.figure(figsize=(14, 10)) # 플롯 크기 설정 colors = plt.cm.jet(np.linspace(0, 1, len(temp_groups))) # 온도별 색상 생성 for i, (temp, data) in enumerate(temp_groups.items()): p_vals = [d[0] for d in data] # 압력 값 raw_vals = [d[1] for d in data] # 원본 ADC 값 corr_vals = [d[2] for d in data] # 보정된 ADC 값 plt.plot(p_vals, raw_vals, color=colors[i], linestyle='--', marker='x', label=f'Raw at {temp}°C') plt.plot(p_vals, corr_vals, color=colors[i], linestyle='-', marker='o', label=f'Corrected at {temp}°C') plt.plot([0, 100], [0, 16384], 'k-', label='Target Line') # 목표 선 plt.xlabel('Pressure (kPa)') # x축 레이블 plt.ylabel('ADC Value (LSB)') # y축 레이블 plt.title('Pressure vs ADC: Corrected with Neural Network (-45°C to 125°C)') # 제목 plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', ncol=2) # 범례 plt.grid(True) # 그리드 추가 plt.tight_layout() # 레이아웃 조정 plt.savefig('pressure_vs_adc.png') # 플롯 저장 plt.show() # 학습 손실 플롯 plt.figure(figsize=(8, 6)) # 플롯 크기 설정 plt.plot(history['loss'], label='Training Loss') # 손실 그래프 plt.xlabel('Epoch') # x축 레이블 plt.ylabel('Mean Squared Error') # y축 레이블 plt.title('Training Loss Over Time') # 제목 plt.legend() # 범례 plt.grid(True) # 그리드 추가 plt.savefig('training_loss.png') # 플롯 저장 plt.show() # 플롯 호출 plot_results(pressures, temps, raw_adc, corrected_adc)
4. 전체 코드
# 필요한 라이브러리 임포트
import numpy as np # 배열 연산 및 데이터 처리
import torch # PyTorch를 사용한 신경망 구현
import torch.nn as nn # 신경망 모듈
import torch.optim as optim # 최적화 알고리즘
import matplotlib.pyplot as plt # 시각화
# 원본 측정 데이터: (압력(kPa), 온도(°C), ADC 값(LSB))
# 데이터는 제어된 환경(온도 챔버)에서 압력(0, 50, 100 kPa)과 온도(-45°C~125°C, 10°C 간격)로 측정
measurements = [
(0, -45, 950), (50, -45, 5900), (100, -45, 10800),
(0, -35, 960), (50, -35, 5950), (100, -35, 10900),
(0, -25, 975), (50, -25, 6000), (100, -25, 10950),
(0, -15, 990), (50, -15, 6050), (100, -15, 11000),
(0, -5, 1000), (50, -5, 6100), (100, -5, 11050),
(0, 5, 1010), (50, 5, 6120), (100, 5, 11150),
(0, 15, 1018), (50, 15, 6135), (100, 15, 11200),
(0, 25, 1024), (50, 25, 6144), (100, 25, 11264),
(0, 35, 1030), (50, 35, 6160), (100, 35, 11300),
(0, 45, 1038), (50, 45, 6180), (100, 45, 11380),
(0, 55, 1043), (50, 55, 6190), (100, 55, 11430),
(0, 65, 1047), (50, 65, 6195), (100, 65, 11460),
(0, 75, 1049), (50, 75, 6198), (100, 75, 11480),
(0, 85, 1051), (50, 85, 6202), (100, 85, 11520),
(0, 95, 1053), (50, 95, 6205), (100, 95, 11550),
(0, 105, 1055), (50, 105, 6208), (100, 105, 11580),
(0, 115, 1057), (50, 115, 6210), (100, 115, 11600),
(0, 125, 1059), (50, 125, 6212), (100, 125, 11620)
]
# 상수 정의: 목표 ADC 값 (압력에 따른 선형 매핑)
TARGET_MIN = 0 # 0 kPa -> 0 LSB
TARGET_CENTER = 8192 # 50 kPa -> 8192 LSB
TARGET_MAX = 16384 # 100 kPa -> 16384 LSB
TEMP_RANGE = range(-45, 126, 10) # 온도 범위: -45°C ~ 125°C, 10°C 간격
# 데이터 분리: 압력, 온도, 원본 ADC 값 추출
pressures = np.array([m[0] for m in measurements]) # 압력(kPa)
temps = np.array([m[1] for m in measurements]) # 온도(°C)
raw_adc = np.array([m[2] for m in measurements]) # 원본 ADC 값(LSB)
# 목표 ADC 값 설정: 압력에 따라 선형 매핑
target_adc = np.array([TARGET_MIN if p == 0 else TARGET_CENTER if p == 50 else TARGET_MAX for p in pressures])
# 입력과 출력 데이터 구성
# 입력: 온도와 원본 ADC 값을 결합하여 (54, 2) 배열 생성
# 출력: 목표 ADC 값으로 (54,) 배열 생성
X = np.column_stack((temps, raw_adc))
y = target_adc
# 데이터 정규화: 평균 0, 표준편차 1로 변환
X_mean = np.mean(X, axis=0) # 입력 데이터의 평균 (온도, ADC)
X_std = np.std(X, axis=0) # 입력 데이터의 표준편차
X_normalized = (X - X_mean) / X_std # 정규화된 입력
y_mean = np.mean(y) # 출력 데이터의 평균
y_std = np.std(y) # 출력 데이터의 표준편차
y_normalized = (y - y_mean) / y_std # 정규화된 출력
# PyTorch 텐서로 변환: 신경망 학습을 위해 데이터 형식 변환
X_normalized = torch.tensor(X_normalized, dtype=torch.float32)
y_normalized = torch.tensor(y_normalized, dtype=torch.float32).reshape(-1, 1)
# 신경망 모델 정의
class NeuralNetwork(nn.Module):
def __init__(self):
super(NeuralNetwork, self).__init__()
self.hidden = nn.Linear(2, 16) # 입력층(2: 온도, ADC) -> 은닉층(16)
self.relu = nn.ReLU() # 비선형 활성화 함수 (ReLU)
self.output = nn.Linear(16, 1) # 은닉층(16) -> 출력층(1: 보정된 ADC)
def forward(self, x):
x = self.relu(self.hidden(x)) # 은닉층 통과 후 ReLU 적용
x = self.output(x) # 출력층 통과
return x
# 모델, 손실 함수, 옵티마이저 초기화
model = NeuralNetwork() # 신경망 객체 생성
criterion = nn.MSELoss() # 평균 제곱 오차 손실 함수
optimizer = optim.Adam(model.parameters(), lr=0.001) # Adam 옵티마이저, 학습률 0.001
# 학습 설정
num_epochs = 1000 # 학습 반복 횟수
batch_size = 16 # 미니 배치 크기
num_batches = len(X_normalized) // batch_size # 배치 수 계산
# 학습 루프
history = {'loss': []} # 손실 기록을 위한 딕셔너리
model.train() # 모델을 학습 모드로 설정
for epoch in range(num_epochs):
epoch_loss = 0.0 # 에포크별 손실 초기화
indices = torch.randperm(len(X_normalized)) # 데이터 무작위 섞기
for i in range(0, len(X_normalized), batch_size):
batch_indices = indices[i:i + batch_size] # 배치 인덱스 추출
X_batch = X_normalized[batch_indices] # 배치 입력 데이터
y_batch = y_normalized[batch_indices] # 배치 출력 데이터
# 순전파: 예측값 계산
outputs = model(X_batch)
loss = criterion(outputs, y_batch) # MSE 손실 계산
# 역전파 및 최적화
optimizer.zero_grad() # 기울기 초기화
loss.backward() # 기울기 계산
optimizer.step() # 가중치 업데이트
epoch_loss += loss.item() * len(X_batch) # 배치 손실 누적
epoch_loss /= len(X_normalized) # 에포크 평균 손실 계산
history['loss'].append(epoch_loss) # 손실 기록
if (epoch + 1) % 100 == 0: # 100번째 에포크마다 손실 출력
print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {epoch_loss:.6f}')
# 예측: 보정된 ADC 값 생성
model.eval() # 모델을 평가 모드로 전환
with torch.no_grad(): # 기울기 계산 비활성화
y_pred_normalized = model(X_normalized) # 정규화된 예측값
corrected_adc = y_pred_normalized.numpy() * y_std + y_mean # 역정규화
# 가중치 및 편향 추출: 임베디드 시스템 배포용
state_dict = model.state_dict()
w1 = state_dict['hidden.weight'].numpy() # 은닉층 가중치 (16, 2)
b1 = state_dict['hidden.bias'].numpy() # 은닉층 편향 (16,)
w2 = state_dict['output.weight'].numpy() # 출력층 가중치 (1, 16)
b2 = state_dict['output.bias'].numpy() # 출력층 편향 (1,)
# C 코드 형식으로 가중치와 편향 출력
print("=== 추출된 가중치와 편향 ===")
print(f"float w1[2][16] = {w1.T.tolist()};") # 전치하여 C 배열 형식으로
print(f"float b1[16] = {b1.tolist()};")
print(f"float w2[16] = {w2.flatten().tolist()};")
print(f"float b2 = {b2[0]};")
print(f"float X_mean[2] = {X_mean.tolist()};")
print(f"float X_std[2] = {X_std.tolist()};")
print(f"float y_mean = {y_mean};")
print(f"float y_std = {y_std};")
# 보정 결과 플롯 함수
def plot_results(pressures, temps, raw_adc, corrected_adc):
temp_groups = {t: [] for t in range(-45, 126, 10)} # 온도별 데이터 그룹화
for p, t, raw, corr in zip(pressures, temps, raw_adc, corrected_adc.flatten()):
temp_groups[t].append((p, raw, corr)) # 압력, 원본 ADC, 보정 ADC 저장
plt.figure(figsize=(14, 10)) # 플롯 크기 설정
colors = plt.cm.jet(np.linspace(0, 1, len(temp_groups))) # 온도별 색상 생성
for i, (temp, data) in enumerate(temp_groups.items()):
p_vals = [d[0] for d in data] # 압력 값
raw_vals = [d[1] for d in data] # 원본 ADC 값
corr_vals = [d[2] for d in data] # 보정된 ADC 값
plt.plot(p_vals, raw_vals, color=colors[i], linestyle='--', marker='x', label=f'Raw at {temp}°C')
plt.plot(p_vals, corr_vals, color=colors[i], linestyle='-', marker='o', label=f'Corrected at {temp}°C')
plt.plot([0, 100], [0, 16384], 'k-', label='Target Line') # 목표 선
plt.xlabel('Pressure (kPa)') # x축 레이블
plt.ylabel('ADC Value (LSB)') # y축 레이블
plt.title('Pressure vs ADC: Corrected with Neural Network (-45°C to 125°C)') # 제목
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', ncol=2) # 범례
plt.grid(True) # 그리드 추가
plt.tight_layout() # 레이아웃 조정
plt.savefig('pressure_vs_adc.png') # 플롯 저장
plt.show()
# 학습 손실 플롯
plt.figure(figsize=(8, 6)) # 플롯 크기 설정
plt.plot(history['loss'], label='Training Loss') # 손실 그래프
plt.xlabel('Epoch') # x축 레이블
plt.ylabel('Mean Squared Error') # y축 레이블
plt.title('Training Loss Over Time') # 제목
plt.legend() # 범례
plt.grid(True) # 그리드 추가
plt.savefig('training_loss.png') # 플롯 저장
plt.show()
# 플롯 호출
plot_results(pressures, temps, raw_adc, corrected_adc)
5. 임베디드 시스템에서 가중치 적용 방법
임베디드 시스템에서 추출된 가중치와 편향을 활용하여 온도 보정을 구현하는 방법은 다음과 같습니다:
- 가중치와 편향 사용: Python 코드에서 출력된 w1, b1, w2, b2와 정규화 파라미터(X_mean, X_std, y_mean, y_std)를 C 배열로 정의.
- 신경망 계산 구현: 신경망의 순전파(forward pass)를 C 코드로 작성. 입력(온도, 원본 ADC)을 정규화하고, 은닉층과 출력층을 계산한 뒤 역정규화하여 보정된 ADC 값을 얻음.
- C 코드 예시:
#include <stdio.h> #include <math.h> // 추출된 가중치와 편향 (실제 값은 Python 출력에서 대체) float w1[2][16] = { /* w1.T 값 */ }; float b1[16] = { /* b1 값 */ }; float w2[16] = { /* w2.flatten() 값 */ }; float b2 = /* b2 값 */; float X_mean[2] = { /* X_mean 값 */ }; float X_std[2] = { /* X_std 값 */ }; float y_mean = /* y_mean 값 */; float y_std = /* y_std 값 */; // ReLU 활성화 함수 float relu(float x) { return x > 0 ? x : 0; } // 신경망 순전파 계산 float predict(float temp, float raw_adc) { // 입력 정규화 float input[2] = { temp, raw_adc }; float normalized_input[2]; for (int i = 0; i < 2; i++) { normalized_input[i] = (input[i] - X_mean[i]) / X_std[i]; } // 은닉층 계산 float hidden[16]; for (int i = 0; i < 16; i++) { hidden[i] = b1[i]; for (int j = 0; j < 2; j++) { hidden[i] += w1[j][i] * normalized_input[j]; } hidden[i] = relu(hidden[i]); // ReLU 적용 } // 출력층 계산 float output = b2; for (int i = 0; i < 16; i++) { output += w2[i] * hidden[i]; } // 역정규화 return output * y_std + y_mean; } int main() { float temp = 25.0; // 입력 온도 (°C) float raw_adc = 6144.0; // 입력 원본 ADC 값 (LSB) float corrected_adc = predict(temp, raw_adc); // 보정된 ADC 값 printf("Corrected ADC: %.2f LSB\n", corrected_adc); return 0; } - 구현 단계:
- 가중치 삽입: Python에서 출력된 w1, b1, w2, b2, X_mean, X_std, y_mean, y_std 값을 C 코드의 배열에 복사.
- 입력 처리: 실시간으로 센서에서 온도와 원본 ADC 값을 읽음.
- 정규화: 입력 값을 X_mean과 X_std를 사용하여 정규화.
- 신경망 계산: 은닉층(행렬 곱 + ReLU)과 출력층(행렬 곱)을 계산.
- 역정규화: 출력 값을 y_mean과 y_std를 사용하여 실제 ADC 값으로 변환.
- 결과 사용: 보정된 ADC 값을 시스템(예: 압력 계산, 데이터 로깅)에 활용.
- 임베디드 환경 고려사항:
- 메모리 최적화: 가중치 배열을 const로 선언하여 ROM에 저장.
- 연산 효율: 부동소수점 연산이 지원되지 않는 마이크로컨트롤러의 경우 고정소수점 연산으로 변환 가능.
- 실시간성: 계산을 최소화하기 위해 ReLU와 행렬 곱을 최적화(예: 루프 언롤링).
6. 결론
AI 기반 압력 센서 온도 보정은 신경망을 활용해 ADC 값의 온도 변동을 효과적으로 보정합니다. 간단한 신경망 구조(2-16-1)와 54개 데이터 포인트만으로도 목표 ADC 값에 근접한 결과를 얻으며, 학습된 가중치는 임베디드 시스템에 배포 가능합니다. 데이터 분석과 시각화로 보정 성능을 직관적으로 확인할 수 있습니다. 이 알고리즘은 압력 센서뿐만 아니라 온도 센서, 가속도 센서 등 온도 보정이 필요한 다양한 센서에 적용 가능합니다. 더 많은 데이터와 하이퍼파라미터 튜닝으로 성능을 더욱 향상시킬 수 있으며, 임베디드 시스템에서의 효율적인 구현으로 실시간 센서 보정이 가능합니다.(AI-based pressure sensor temperature compensation effectively corrects ADC value variations due to temperature using neural networks. A simple neural network structure (2-16-1) with 54 data points achieves results close to target ADC values, and trained weights can be deployed to embedded systems. Data analysis and visualization provide intuitive evaluation of compensation performance. This algorithm is applicable not only to pressure sensors but also to temperature sensors, accelerometers, and other sensors requiring temperature compensation. Performance can be further improved with more data and hyperparameter tuning, and efficient implementation in embedded systems enables real-time sensor compensation.)