PLC 프로그래밍 소프트웨어가 프로젝트 시운전을 더 빠르게 지원

온디맨드 에뮬레이션으로 검증을 간소화

공유 및 사용자 정의 라이브러리

안전 시스템을 자신 있게 구축하고 검증하십시오.

필수 안전 기능을 지원하는 코드를 생성합니다. 이 코드는 다음과 같은 포괄적인 안전 기능을 제공합니다. 1. **비상 정지 시스템** – 비상 정지 2. **안전 모니터링** – 실시간 모니터링 3. **안전 인터록** – 안전 조건 확인 4. **안전 구역** – 안전 구역 관리 5. **통합 안전 제어기** – 통합 제어 ```python import logging import time from enum import Enum from typing import Dict, List, Callable, Optional from dataclasses import dataclass from datetime import datetime import threading class SafetyLevel(Enum): """안전 수준 정의""" CRITICAL = 1 HIGH = 2 MEDIUM = 3 LOW = 4 class SafetyStatus(Enum): """안전 상태""" SAFE = "safe" WARNING = "warning" DANGER = "danger" EMERGENCY = "emergency" @dataclass class SafetyEvent: """안전 이벤트 데이터 클래스""" timestamp: datetime level: SafetyLevel status: SafetyStatus message: str source: str data: Dict = None class EmergencyStop: """비상 정지 시스템""" def __init__(self): self._is_active = False self._callbacks: List[Callable] = [] self._lock = threading.Lock() def activate(self, reason: str): """비상 정지 활성화""" with self._lock: if not self._is_active: self._is_active = True logging.critical(f"비상 정지 활성화: {reason}") self._execute_callbacks(reason) def deactivate(self): """비상 정지 해제""" with self._lock: self._is_active = False logging.info("비상 정지 해제됨") def is_active(self) -> bool: """비상 정지 상태 확인""" return self._is_active def register_callback(self, callback: Callable): """비상 정지 시 실행할 콜백 등록""" self._callbacks.append(callback) def _execute_callbacks(self, reason: str): """등록된 콜백 실행""" for callback in self._callbacks: try: callback(reason) except Exception as e: logging.error(f"비상 정지 콜백 실행 오류: {e}") class SafetyMonitor: """안전 모니터링 시스템""" def __init__(self): self._monitors: Dict[str, Callable] = {} self._thresholds: Dict[str, tuple] = {} self._event_history: List[SafetyEvent] = [] self._is_monitoring = False self._monitor_thread = None def add_monitor(self, name: str, check_function: Callable, threshold: tuple = None): """모니터링 항목 추가""" self._monitors[name] = check_function if threshold: self._thresholds[name] = threshold def start_monitoring(self, interval: float = 1.0): """모니터링 시작""" if not self._is_monitoring: self._is_monitoring = True self._monitor_thread = threading.Thread( target=self._monitoring_loop, args=(interval,), daemon=True ) self._monitor_thread.start() logging.info("안전 모니터링 시작됨") def stop_monitoring(self): """모니터링 중지""" self._is_monitoring = False if self._monitor_thread: self._monitor_thread.join() logging.info("안전 모니터링 중지됨") def _monitoring_loop(self, interval: float): """모니터링 루프""" while self._is_monitoring: for name, check_func in self._monitors.items(): try: result = check_func() self._evaluate_result(name, result) except Exception as e: logging.error(f"모니터 '{name}' 실행 오류: {e}") time.sleep(interval) def _evaluate_result(self, name: str, result): """모니터링 결과 평가""" if name in self._thresholds: warning_threshold, danger_threshold = self._thresholds[name] if result >= danger_threshold: self._log_event( name, SafetyLevel.CRITICAL, SafetyStatus.DANGER, f"{name} 위험 수준: {result}" ) elif result >= warning_threshold: self._log_event( name, SafetyLevel.HIGH, SafetyStatus.WARNING, f"{name} 경고 수준: {result}" ) def _log_event(self, source: str, level: SafetyLevel, status: SafetyStatus, message: str): """안전 이벤트 기록""" event = SafetyEvent( timestamp=datetime.now(), level=level, status=status, message=message, source=source ) self._event_history.append(event) logging.warning(f"안전 이벤트: {message}") def get_event_history(self, limit: int = 100) -> List[SafetyEvent]: """이벤트 히스토리 조회""" return self._event_history[-limit:] class SafetyInterlock: """안전 인터록 시스템""" def __init__(self): self._conditions: Dict[str, Callable] = {} self._dependencies: Dict[str, List[str]] = {} def add_condition(self, name: str, condition: Callable): """안전 조건 추가""" self._conditions[name] = condition def add_dependency(self, action: str, required_conditions: List[str]): """동작에 필요한 안전 조건 설정""" self._dependencies[action] = required_conditions def check_permission(self, action: str) -> tuple[bool, List[str]]: """동작 허가 여부 확인""" if action not in self._dependencies: return True, [] failed_conditions = [] for condition_name in self._dependencies[action]: if condition_name in self._conditions: try: if not self._conditions[condition_name](): failed_conditions.append(condition_name) except Exception as e: logging.error(f"조건 '{condition_name}' 확인 오류: {e}") failed_conditions.append(condition_name) return len(failed_conditions) == 0, failed_conditions class SafetyZone: """안전 구역 관리""" def __init__(self, name: str, boundaries: Dict): self.name = name self.boundaries = boundaries self._occupants: List[str] = [] def is_within_zone(self, position: Dict) -> bool: """위치가 안전 구역 내에 있는지 확인""" for axis, (min_val, max_val) in self.boundaries.items(): if axis not in position: return False if not (min_val <= position[axis] <= max_val): return False return True def add_occupant(self, occupant_id: str): """구역 내 점유자 추가""" if occupant_id not in self._occupants: self._occupants.append(occupant_id) def remove_occupant(self, occupant_id: str): """구역 내 점유자 제거""" if occupant_id in self._occupants: self._occupants.remove(occupant_id) def get_occupants(self) -> List[str]: """현재 점유자 목록""" return self._occupants.copy() def is_occupied(self) -> bool: """구역 점유 여부""" return len(self._occupants) > 0 class SafetyController: """통합 안전 제어 시스템""" def __init__(self): self.emergency_stop = EmergencyStop() self.monitor = SafetyMonitor() self.interlock = SafetyInterlock() self._safety_zones: Dict[str, SafetyZone] = {} self._safety_state = SafetyStatus.SAFE def add_safety_zone(self, zone: SafetyZone): """안전 구역 추가""" self._safety_zones[zone.name] = zone def check_zone_safety(self, zone_name: str, position: Dict) -> bool: """구역 안전성 확인""" if zone_name in self._safety_zones: return self._safety_zones[zone_name].is_within_zone(position) return False def execute_safe_action(self, action: str, execute_func: Callable) -> bool: """안전 확인 후 동작 실행""" # 비상 정지 확인 if self.emergency_stop.is_active(): logging.error(f"비상 정지 활성화로 '{action}' 실행 불가") return False # 인터록 확인 permitted, failed = self.interlock.check_permission(action) if not permitted: logging.error( f"안전 조건 미충족으로 '{action}' 실행 불가: {failed}" ) return False # 동작 실행 try: execute_func() return True except Exception as e: logging.error(f"동작 '{action}' 실행 중 오류: {e}") self.emergency_stop.activate(f"동작 실행 오류: {action}") return False def get_safety_status(self) -> Dict: """전체 안전 상태 조회""" return { 'emergency_stop': self.emergency_stop.is_active(), 'safety_state': self._safety_state.value, 'recent_events': self.monitor.get_event_history(10), 'zones': { name: zone.is_occupied() for name, zone in self._safety_zones.items() } } # 사용 예제 if __name__ == "__main__": logging.basicConfig(level=logging.INFO) # 안전 제어 시스템 초기화 safety = SafetyController() # 비상 정지 콜백 등록 def emergency_callback(reason): print(f"비상 정지 실행됨: {reason}") # 모든 시스템 정지 로직 safety.emergency_stop.register_callback(emergency_callback) # 모니터링 항목 추가 def check_temperature(): return 75 # 예제 온도 값 safety.monitor.add_monitor( "temperature", check_temperature, threshold=(80, 100) # 경고, 위험 임계값 ) # 안전 인터록 설정 def door_closed(): return True # 문 닫힘 상태 def power_on(): return True # 전원 켜짐 상태 safety.interlock.add_condition("door_closed", door_closed) safety.interlock.add_condition("power_on", power_on) safety.interlock.add_dependency("start_machine", ["door_closed", "power_on"]) # 안전 구역 설정 work_zone = SafetyZone( "work_area", {"x": (0, 100), "y": (0, 100), "z": (0, 50)} ) safety.add_safety_zone(work_zone) # 모니터링 시작 safety.monitor.start_monitoring(interval=2.0) # 안전 동작 실행 def machine_operation(): print("기계 작동 중...") success = safety.execute_safe_action("start_machine", machine_operation) print(f"동작 실행 결과: {success}") # 안전 상태 확인 status = safety.get_safety_status() print(f"\n안전 상태: {status}") time.sleep(5) safety.monitor.stop_monitoring() ```

질문만으로 코드 생성 및 트러블슈팅

통합 생성형 AI Copilot을 사용하여 프로젝트 요소를 설명

클라우드에서 엣지로 프로젝트를 배포

장치의 온라인 상태 확인

장치를 손쉽게 관리하고 구성

ControlLogix 5590 컨트롤러를 사용하여 프로젝트를 설계