산학 1단계 · 가상 환자 스트림 생성기

import wfdb            # PhysioNet 파일을 여는 파이썬 도구

# LTSTDB의 s20011 기록에서 처음 2500개(10초)만 읽기
record = wfdb.rdrecord("s20011", pn_dir="ltstdb", sampto=2500)   # 읽은 결과를 record에 담음
# rdrecord : read record. 기록 하나를 읽는 명령
# "s20011" : 읽을 기록(사람) 이름
# pn_dir="ltstdb" : PhysioNet의 LTSTDB 폴더에서 바로 읽어옴 (다운로드 불필요)
# sampto : 몇 번째 샘플까지 읽을지. 하루치를 다 읽으면 무거워서 2500개 = 10초만
#          (실제 재생하는 B·C는 FS * 60 = 15000개 = 1분)

print("샘플링 레이트:", record.fs)                # fs : 1초에 몇 번 측정했는지 (250)
print("채널 수:", record.n_sig)                   # n_sig : 리드 수 (s20011은 2)
print("채널 이름:", record.sig_name)              # sig_name : 리드 이름
print("데이터 모양:", record.p_signal.shape)      # shape : 표의 크기 (2500, 2) = 2500줄 × 2리드
print("처음 5개 값:")
print(record.p_signal[:5])                        # p_signal : 측정값 표. [:5] = 앞 5줄만
# s20011은 2리드라서 3단계에서 3리드 데이터로 바꿈

import time            # 시간 재기·기다리기용 기본 도구
import wfdb            # PhysioNet 파일을 여는 파이썬 도구

FS = 250               # 초당 샘플 수 (250Hz)
CHUNK = 25             # 한 번에 보내는 개수 (250 × 0.1초 = 25)
INTERVAL = CHUNK / FS  # 상자 보내는 간격 (25 / 250 = 0.1초)

# 1분 분량 읽어두고 반복 재생
record = wfdb.rdrecord("s20011", pn_dir="ltstdb", sampto=FS * 60)   # 250 × 60 = 15000개 = 1분
signal = record.p_signal   # 읽은 측정값 표만 꺼내 둠

def send(patient_id, chunk):   # 보내는 함수 자리. 3단계에서 TCP 전송으로 채움
    pass                       # pass : 아무것도 안 함. 자리만 만들어 둘 때 씀

pos = 0                        # 지금 몇 번째 샘플까지 보냈는지. 처음부터 시작
start = time.perf_counter()    # 시작 시각 기록
# time.perf_counter() : 시간 재는 용도의 정밀한 시계
next_tick = start              # 첫 박자를 시작 시각으로 맞춤

while time.perf_counter() - start < 10:   # 시작하고 10초 동안 반복
    chunk = signal[pos:pos + CHUNK]       # pos번째부터 25개 잘라내기
    send(0, chunk)                        # 환자 0번으로 보내기 (지금은 아무 일 안 함)
    pos = (pos + CHUNK) % len(signal)     # 다음 25개로 이동
    # % : 나머지. 1분 끝에 닿으면 0으로 돌아가 처음부터 다시 재생

    next_tick += INTERVAL                 # 다음 보낼 시각을 0.1초 뒤로 정함
    time.sleep(max(0, next_tick - time.perf_counter()))   # 그 시각까지 남은 만큼만 잠
    # max(0, ...) : 이미 늦어서 음수면 0초 (음수로는 못 잠)
    # next_tick 방식 : sleep(0.1)만 하면 보내는 시간만큼 계속 밀림 (2ms씩 100번 = 0.2초)
    #                 다음 시각을 정해두면 한 번 늦어도 다음 박자는 제자리

import sys             # 실행 인자 읽는 기본 도구
import random          # 난수 뽑는 기본 도구
import time
import wfdb

FS = 250               # (B와 같음)
CHUNK = 25
INTERVAL = CHUNK / FS
record = wfdb.rdrecord("s20011", pn_dir="ltstdb", sampto=FS * 60)
signal = record.p_signal

def send(patient_id, chunk):
    pass

N = int(sys.argv[1]) if len(sys.argv) > 1 else 6   # 환자 수. 실행할 때 붙인 숫자, 없으면 6명
# sys.argv : 실행 명령을 칸별로 담은 목록. python stream_multi.py 20 → ["stream_multi.py", "20"]
# sys.argv[1] : 두 번째 칸 = "20" (0번 칸은 파일 이름)
# int() : 글자 "20"을 숫자 20으로 바꿈
# len(sys.argv) > 1 : 숫자를 붙였는지 확인 (안 붙이면 칸이 1개뿐)
# A if 조건 else B : 조건이 맞으면 A, 아니면 B
DURATION = 10                                     # 측정 시간(초)

# 환자마다 시작 위치를 다르게
positions = [random.randrange(0, len(signal), CHUNK) for _ in range(N)]
# random.randrange(시작, 끝, 간격) : 0~15000 사이에서 25 간격으로 난수 하나 (0, 25, 50 ...)
#                                   25 간격이라 상자 경계에 딱 맞음
# [ ... for _ in range(N)] : 앞의 것을 N번 해서 목록으로 만듦 → 환자 N명분 시작 위치
# _ : 반복 횟수만 필요하고 번호는 안 쓸 때 쓰는 이름

sent = 0               # 지금까지 만든 샘플 수. 마지막에 초당 개수 계산용
max_late = 0.0         # 최대 지각. 처음엔 0
start = time.perf_counter()
next_tick = start

while time.perf_counter() - start < DURATION:   # 10초 동안 반복
    for pid in range(N):                        # 환자 0번부터 N-1번까지 차례로
        p = positions[pid]                      # 이 환자가 지금 보낼 위치
        chunk = signal[p:p + CHUNK]             # 거기서 25개 잘라내기
        send(pid, chunk)                        # 환자 번호 붙여서 보내기 (지금은 빈 함수)
        sent += len(chunk)                      # 만든 개수에 25 더함
        # += : 원래 값에 더해서 다시 저장 (sent = sent + 25)
        positions[pid] = (p + CHUNK) % len(signal)   # 이 환자 다음 위치로. 끝이면 처음으로

    next_tick += INTERVAL                       # 다음 박자를 0.1초 뒤로 정함
    wait = next_tick - time.perf_counter()      # 다음 박자까지 남은 시간
    if wait < 0:                                # 음수 = 정해둔 시각이 이미 지남 = 지각
        max_late = max(max_late, -wait)         # 지금까지 지각 중 가장 큰 값만 남김
    time.sleep(max(0, wait))                    # 남은 만큼 잠. 지각했으면 안 자고 바로 다음

elapsed = time.perf_counter() - start           # 실제로 걸린 시간
print(f"환자 {N}명 | 목표 초당 {N * FS}개 | 실제 초당 {round(sent / elapsed)}개 | 최대 지각 {max_late * 1000:.1f}ms")
# f"...{값}..." : 글자 안에 {} 자리에 값을 넣어 출력
# N * FS : 목표 = 환자 수 × 250
# round(sent / elapsed) : 실제 초당 개수, 반올림
# max_late * 1000 : 초 → ms
# :.1f : 소수점 한 자리까지

next_tick = start
for _ in range(ticks):
    보내기()
    next_tick += 0.1                    # 다음에 보낼 시각을 정해두고
    time.sleep(next_tick - time.time())  # 그때까지만 기다림