간단한 FFT 분석 코드 예시 (Python)

import numpy as np
import matplotlib.pyplot as plt
from scipy.fft import fft, fftfreq

# 가상의 진동 데이터 생성 (실제로는 센서에서 수집)
sample_rate = 1000  # 1kHz 샘플링
duration = 5  # 5초 데이터
t = np.linspace(0, duration, sample_rate * duration, endpoint=False)

# 3Hz와 10Hz 성분이 있는 신호 (건물 진동 시뮬레이션)
signal = 0.5 * np.sin(2 * np.pi * 3 * t) + 0.3 * np.sin(2 * np.pi * 10 * t)
# 노이즈 추가
signal += 0.1 * np.random.randn(len(t))

# FFT 계산
yf = fft(signal)
xf = fftfreq(len(signal), 1 / sample_rate)
N = len(signal) // 2

# 주파수 스펙트럼 시각화
plt.figure(figsize=(10, 6))
plt.plot(xf[:N], 2.0/N * np.abs(yf[:N]))
plt.grid()
plt.xlabel('주파수 (Hz)')
plt.ylabel('진폭')
plt.title('진동 신호의 주파수 스펙트럼')
plt.xlim(0, 20)  # 0~20Hz 범위만 표시
plt.show()
            

이 코드는 두 개의 주파수(3Hz, 10Hz)를 가진 가상의 진동 신호를 생성하고, FFT를 사용해 주파수 스펙트럼을 분석하는 예시야. 실제 건물 진동 분석에서는 이보다 훨씬 복잡한 신호와 분석 방법이 사용되지만, 기본 원리는 동일해! 📊

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_ADXL345_U.h>

// 센서 객체 생성
Adafruit_ADXL345_U accel = Adafruit_ADXL345_U(12345);

void setup() {
  Serial.begin(9600);
  
  // 센서 초기화
  if(!accel.begin()) {
    Serial.println("ADXL345 센서를 찾을 수 없습니다!");
    while(1);
  }
  
  // 측정 범위 설정 (±2g, ±4g, ±8g, ±16g)
  accel.setRange(ADXL345_RANGE_16_G);
  
  Serial.println("진동 감지 시스템이 시작되었습니다!");
  Serial.println("시간(ms), X(m/s²), Y(m/s²), Z(m/s²), 진동 크기");
}

void loop() {
  // 센서에서 데이터 읽기
  sensors_event_t event; 
  accel.getEvent(&event);
  
  // 3축 가속도 계산
  float x = event.acceleration.x;
  float y = event.acceleration.y;
  float z = event.acceleration.z;
  
  // 진동 크기 계산 (벡터 크기)
  float magnitude = sqrt(x*x + y*y + z*z);
  
  // 데이터 출력
  Serial.print(millis());
  Serial.print(", ");
  Serial.print(x);
  Serial.print(", ");
  Serial.print(y);
  Serial.print(", ");
  Serial.print(z);
  Serial.print(", ");
  Serial.println(magnitude);
  
  // 진동 감지 (임계값 설정)
  float threshold = 10.5; // 9.8(중력) + 0.7(여유)
  if (magnitude > threshold) {
    Serial.println("주의: 강한 진동이 감지되었습니다!");
  }
  
  delay(100); // 10Hz 샘플링 속도
}
            

이 코드는 3축 가속도 데이터를 수집하고, 진동의 크기를 계산해. 설정한 임계값보다 큰 진동이 감지되면 경고 메시지를 출력하지. 실제 사용 시에는 임계값을 환경에 맞게 조정해야 해! 📝

Python으로 시리얼 데이터 시각화하기

import serial
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.animation import FuncAnimation

# 시리얼 포트 설정 (Windows에서는 'COM3' 같은 형식, Mac/Linux에서는 '/dev/ttyUSB0' 같은 형식)
ser = serial.Serial('COM3', 9600)

# 데이터 저장용 리스트
times = []
x_vals = []
y_vals = []
z_vals = []
mag_vals = []

# 그래프 설정
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))
line1, = ax1.plot([], [], 'r-', label='X')
line2, = ax1.plot([], [], 'g-', label='Y')
line3, = ax1.plot([], [], 'b-', label='Z')
line4, = ax2.plot([], [], 'k-', label='Magnitude')

ax1.set_title('3축 가속도')
ax1.set_ylabel('가속도 (m/s²)')
ax1.legend()

ax2.set_title('진동 크기')
ax2.set_xlabel('시간 (s)')
ax2.set_ylabel('크기 (m/s²)')
ax2.legend()

# 최대 표시할 데이터 포인트 수
max_points = 100

def init():
    ax1.set_ylim(-20, 20)
    ax2.set_ylim(0, 20)
    return line1, line2, line3, line4

def update(frame):
    if ser.in_waiting:
        try:
            # 시리얼 데이터 읽기
            data = ser.readline().decode('utf-8').strip()
            values = data.split(',')
            
            if len(values) == 5:  # 시간, X, Y, Z, 크기
                time_ms = float(values[0]) / 1000  # 초 단위로 변환
                x = float(values[1])
                y = float(values[2])
                z = float(values[3])
                mag = float(values[4])
                
                times.append(time_ms)
                x_vals.append(x)
                y_vals.append(y)
                z_vals.append(z)
                mag_vals.append(mag)
                
                # 최대 데이터 포인트 수 유지
                if len(times) > max_points:
                    times.pop(0)
                    x_vals.pop(0)
                    y_vals.pop(0)
                    z_vals.pop(0)
                    mag_vals.pop(0)
                
                # 그래프 데이터 업데이트
                line1.set_data(times, x_vals)
                line2.set_data(times, y_vals)
                line3.set_data(times, z_vals)
                line4.set_data(times, mag_vals)
                
                # x축 범위 자동 조정
                ax1.set_xlim(min(times), max(times))
                ax2.set_xlim(min(times), max(times))
        except:
            pass
    
    return line1, line2, line3, line4

# 애니메이션 시작
ani = FuncAnimation(fig, update, init_func=init, interval=100, blit=True)
plt.tight_layout()
plt.show()

# 종료 시 시리얼 포트 닫기
ser.close()
            

이 파이썬 코드는 아두이노에서 전송하는 진동 데이터를 실시간으로 그래프로 시각화해. 상단 그래프는 X, Y, Z 축의 가속도를, 하단 그래프는 전체 진동 크기를 보여주지! 📈