1：配置修改

2：逻辑修正，涉及到执行判断，晚于当前也进行实现，解决 pandas 冲突问题

config.json

@@ -23,17 +23,17 @@
   "cip_times": {
     "RO1": {
       "actual_time": "2025-09-11 10:30:00",
-      "predicted_time": null
+      "predicted_time": ""
     },
     "RO2": {
       "actual_time": "2025-09-30 10:31:00",
-      "predicted_time": "2025-11-14 04:00:00"
+      "predicted_time": ""
     },
-    "RO3": {
+    "_RO3_disabled": {
       "actual_time": "2025-09-12 10:05:00",
       "predicted_time": null
     },
-    "RO4": {
+    "_RO4_disabled": {
       "actual_time": "2025-09-29 10:30:00",
       "predicted_time": null
     },

fouling_model_0922/data_mysql.py

@@ -120,7 +120,7 @@ def fill_missing_hourly_data(df, start_date, end_date):
         print("原始数据为空，无法进行数据补充")
         return df
     complete_time_range = pd.date_range(start=start_date.replace(minute=0, second=0, microsecond=0),
-                                        end=end_date.replace(minute=0, second=0, microsecond=0), freq='H', closed='left')
+                                        end=end_date.replace(minute=0, second=0, microsecond=0), freq='H', inclusive='left')
     print(f"期望时间范围: {start_date.strftime('%Y-%m-%d %H:%M')} 到 {end_date.strftime('%Y-%m-%d %H:%M')}")
     print(f"期望小时数: {len(complete_time_range)} 小时")
     print(f"实际数据行数: {len(df)} 行")
@@ -129,8 +129,6 @@ def fill_missing_hourly_data(df, start_date, end_date):
     existing_times = set(df['index'].dt.floor('H'))
     expected_times = set(complete_time_range)
     missing_times = expected_times - existing_times
-    print(len(expected_times))
-    print(len(existing_times))
 
     if missing_times:
         missing_count = len(missing_times)

main_simple.py

@@ -448,9 +448,8 @@ def analyze_ro_unit_cip_timing(strategy=1, start_date=None, unit_filter=None):
     
     try:
         # 获取预测数据
-        print("获取预测数据...")
         try:
-            all_data = Predictor().predict(start_date=start_date)  # 获取预测数据
+            all_data = Predictor().predict(start_date=start_date)
             if all_data.empty: 
                 logger.logger.error("预测数据为空")
                 return pd.DataFrame()
@@ -463,23 +462,11 @@ def analyze_ro_unit_cip_timing(strategy=1, start_date=None, unit_filter=None):
         
         # 获取预测数据的起始时间
         prediction_start_date = all_data.index[0].to_pydatetime()
-        print(f"预测数据起始时间: {prediction_start_date.strftime('%Y-%m-%d %H:%M:%S')}")
+        print(f"预测起始: {prediction_start_date.strftime('%Y-%m-%d %H:%M:%S')}")
 
         # 记录输入参数和预测数据
         logger.log_input_parameters(strategy, start_date, prediction_start_date)
         logger.log_prediction_data(all_data)
-
-        # 显示配置的CIP时间状态
-        if config and 'cip_times' in config:
-            print(f"\n当前配置的CIP时间状态:")
-            for unit_name, cip_data in config['cip_times'].items():
-                if not unit_name.startswith('_'):
-                    if isinstance(cip_data, dict):
-                        actual = cip_data.get('actual_time', 'N/A')
-                        predicted = cip_data.get('predicted_time', 'N/A')
-                        print(f"  {unit_name}: 实际={actual}, 预测={predicted}")
-                    else:
-                        print(f"  {unit_name}: {cip_data}")
         
         # 确定要分析的机组
         if unit_filter:
@@ -499,24 +486,14 @@ def analyze_ro_unit_cip_timing(strategy=1, start_date=None, unit_filter=None):
         # 初始化预测器
         predictor = OptimalCIPPredictor(window_days=7, min_continuous_rising=3, min_delay_days=30)
         
-        # 策略说明
-        strategy_names = {
-            1: "最早时机策略",
-            2: "最晚时机策略", 
-            3: "加权平均策略",
-            4: "污染严重程度策略"
-        }
-        print(f"\n使用策略: {strategy_names.get(strategy, '未知策略')}")
-        
         # 存储分析结果
         results = []
         
         # 遍历分析各机组
         for unit_id in unit_ids:
-            print(f"\n分析机组 RO{unit_id}")
-            
             # 获取该机组的预测天数
             predict_days = unit_days_dict[unit_id]
+            print(f"\n[RO{unit_id}] 预测天数: {predict_days}天")
             
             # 记录分析开始
             logger.log_unit_analysis_start(unit_id, predict_days)
@@ -524,17 +501,15 @@ def analyze_ro_unit_cip_timing(strategy=1, start_date=None, unit_filter=None):
             # 截取预测天数范围内的数据
             end_time = all_data.index[0] + timedelta(days=predict_days)
             truncated_data = all_data.loc[all_data.index <= end_time]
-            
+
             # 筛选该机组的压差列
             ro_name = f"RO{unit_id}"
             pressure_columns = [col for col in truncated_data.columns if ro_name in col and 'DPT' in col and 'pred' in col]
             
             if not pressure_columns:
-                print(f"警告: 未找到{ro_name}的压差列")
+                print(f"[RO{unit_id}] 警告: 未找到压差列")
                 continue
             
-            print(f"找到{ro_name}压差列: {len(pressure_columns)}个")
-            
             # 记录压差数据
             logger.log_unit_pressure_data(unit_id, truncated_data, pressure_columns)
             
@@ -563,12 +538,8 @@ def analyze_ro_unit_cip_timing(strategy=1, start_date=None, unit_filter=None):
                             'delay_days': analysis['delay_days'],
                             'k_value': analysis['best_k']
                         })
-                        print(f"  {column}: {optimal_time} (第{analysis['delay_days']}天, k={analysis['best_k']:.6f})")
-                    else:
-                        print(f"  {column}: 未找到CIP时机 - {analysis.get('error', '未知原因')}")
                         
                 except Exception as e:
-                    print(f"  {column}: 分析失败 - {str(e)}")
                     logger.log_cip_analysis_result(unit_id, column, None, {"error": str(e)})
             
             # 根据策略选择最优CIP时机
@@ -579,19 +550,21 @@ def analyze_ro_unit_cip_timing(strategy=1, start_date=None, unit_filter=None):
                     'CIP时机': optimal_time,
                     '策略说明': strategy_desc
                 })
-                print(f"RO{unit_id}最优CIP时机: {optimal_time}")
-                print(f"策略: {strategy_desc}")
+                print(f"RO{unit_id} CIP时机: {optimal_time.strftime('%Y-%m-%d %H:%M:%S')}")
                 
                 logger.log_unit_strategy_result(unit_id, optimal_time, strategy_desc)
             else:
+                # 如果没找到最优CIP时机，使用预测天数的最后时间作为CIP时机
+                fallback_time = end_time
+                fallback_desc = f"使用预测终点时间 (第{predict_days}天)"
                 results.append({
                     '机组类型': f"RO{unit_id}",
-                    'CIP时机': None,
-                    '策略说明': "无有效CIP时机"
+                    'CIP时机': fallback_time,
+                    '策略说明': fallback_desc
                 })
-                print(f"RO{unit_id}: 未找到有效CIP时机")
+                print(f"RO{unit_id} CIP时机: {fallback_time.strftime('%Y-%m-%d %H:%M:%S')} (备用策略)")
                 
-                logger.log_unit_strategy_result(unit_id, None, "无有效CIP时机")
+                logger.log_unit_strategy_result(unit_id, fallback_time, fallback_desc)
     
         # 生成结果DataFrame
         result_df = pd.DataFrame(results)
@@ -603,9 +576,10 @@ def analyze_ro_unit_cip_timing(strategy=1, start_date=None, unit_filter=None):
         logger.create_analysis_plots(all_data, unit_days_dict)
         
         print("\n" + "="*50)
-        print("分析完成")
+        for _, row in result_df.iterrows():
+            if pd.notna(row['CIP时机']):
+                print(f"{row['机组类型']}: {row['CIP时机'].strftime('%Y-%m-%d %H:%M:%S')}")
         print("="*50)
-        print(result_df.to_string(index=False))
         
         return result_df
         
@@ -639,20 +613,14 @@ def main(strategy=3, start_date=None, unit_filter=None):
         result_df = main(start_date='2025-07-01 00:00:00')  # 指定时间
         result_df = main(strategy=1, unit_filter='RO1')  # 指定策略和机组
     """
-    print("RO膜污染监控与CIP预测")
-    print("=" * 50)
-    
     # 执行分析 
     result_df = analyze_ro_unit_cip_timing(strategy=strategy, start_date=start_date, unit_filter=unit_filter)
     
     # 发送回调
     if config and not result_df.empty:
-        print("\n发送决策结果...")
         callback_success = send_decision_to_callback(result_df)
-        if callback_success:
-            print("决策结果发送成功")
-        else:
-            print("决策结果发送失败")
+        if not callback_success:
+            print("⚠️ 回调发送失败")
 
     return result_df
 
@@ -698,37 +666,32 @@ def send_decision_to_callback(decision_data):
         else:
             callback_list = [decision_data]
         
+        # 关键检查：如果没有有效数据，不发送回调
+        if not callback_list:
+            return False
+        
         # 封装为API要求的格式
         payload = {
             "list": callback_list
         }
         
-        # 日志：显示待发送数据
-        log_type = callback_list[0]["type"] if callback_list else "UNKNOWN"
-        print(f"[{log_type}] 准备发送决策数据:")
-        print(f"{json.dumps(payload, indent=2, ensure_ascii=False)}")
-        
         # 发送HTTP请求（带重试机制）
         max_retries = 3
         retry_interval = 10
         
         for attempt in range(1, max_retries + 1):
             try:
-                print(f"[{log_type}] 第{attempt}/{max_retries}次尝试发送...")
                 response = requests.post(callback_url, headers=headers, json=payload, timeout=15)
                 response.raise_for_status()
-                
-                print(f"[{log_type}] 决策数据发送成功，服务器响应: {response.text}")
+                print(f"回调发送成功")
                 return True
                 
             except requests.exceptions.RequestException as e:
-                print(f"[{log_type}] 发送失败: {e}")
-                
                 if attempt < max_retries:
-                    print(f"[{log_type}] {retry_interval}秒后重试...")
                     time.sleep(retry_interval)
+                else:
+                    print(f"回调发送失败: {e}")
         
-        print(f"[{log_type}] 所有重试均失败")
         return False
         
     except Exception as e:

smart_monitor.py

@@ -4,12 +4,17 @@ CIP监控系统 - 配置文件监控模式
 
 功能：
 1. 监控config.json中actual_time字段的变化
-2. 检测到变化后，基于actual_time执行CIP预测
+2. 检测到变化且actual_time < 当前时间时，基于actual_time执行CIP预测
 3. 将预测结果保存到predicted_time（仅用于记录）
 4. 通过回调接口发送预测结果到决策系统
+5. 继续等待actual_time的下次更新
+
+触发条件（同时满足）：
+- actual_time 发生了变化
+- actual_time < 当前时间（已过期）
 
 工作流程：
-修改actual_time → 检测变化 → 执行预测 → 保存predicted_time → 发送回调 → 继续监控
+修改actual_time（且 < 当前时间）→ 检测变化 → 执行预测 → 保存predicted_time → 发送回调 → 继续监控actual_time
 """
 
 import os
@@ -17,10 +22,34 @@ import json
 import time
 import threading
 import pandas as pd
+import logging
+from logging.handlers import RotatingFileHandler
 from datetime import datetime
 from main_simple import main as run_cip_analysis
 from main_simple import send_decision_to_callback
 
+# 日志系统配置
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+# 日志输出格式
+formatter = logging.Formatter(
+    '%(asctime)s - %(threadName)s - %(levelname)s - %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+
+# 文件日志处理器，单个文件最大5MB，保留3个备份
+file_handler = RotatingFileHandler('smart_monitor.log', maxBytes=5 * 1024 * 1024, backupCount=3, encoding='utf-8')
+file_handler.setFormatter(formatter)
+
+# 控制台日志处理器
+console_handler = logging.StreamHandler()
+console_handler.setFormatter(formatter)
+
+# 添加处理器
+logger.addHandler(file_handler)
+logger.addHandler(console_handler)
+
 class SmartCIPMonitor:
     """
     CIP监控器
@@ -59,11 +88,9 @@ class SmartCIPMonitor:
         # 格式：{'RO1': '2025-12-01 12:00:00', 'RO2': '...'}
         self.last_seen_actual_times = {}
         
-        print("初始化CIP监控系统...")
         if not self.load_config():
-            print("配置加载失败")
+            logger.error("配置文件加载失败")
         else:
-            print("配置加载成功")
             self.initialize_last_seen_times()
     
     def load_config(self):
@@ -78,7 +105,7 @@ class SmartCIPMonitor:
                 self.config = json.load(f)
             return True
         except Exception as e:
-            print(f"配置文件加载失败: {e}")
+            logger.error(f"配置文件加载失败: {e}")
             return False
     
     def save_config(self):
@@ -93,7 +120,7 @@ class SmartCIPMonitor:
                 json.dump(self.config, f, ensure_ascii=False, indent=2)
             return True
         except Exception as e:
-            print(f"配置文件保存失败: {e}")
+            logger.error(f"配置文件保存失败: {e}")
             return False
     
     def initialize_last_seen_times(self):
@@ -102,34 +129,68 @@ class SmartCIPMonitor:
         
         功能：
         读取config.json中各机组当前的actual_time作为监控基准
-        后续只有当actual_time与此基准不同时才触发预测
+        但是：只记录未来的时间，已过期的时间不记录，以便首次检查时能触发预测
         
         说明：
         - last_seen_actual_times用于防止重复处理相同的时间
         - 支持新旧配置格式兼容
+        - 已过期的时间(< 当前时间)不记录，确保首次检查时能被检测为"变化"
         """
         if not self.config or 'cip_times' not in self.config:
             return
         
+        current_time = datetime.now()
+        
         for unit_name in self.unit_names:
             if unit_name in self.config['cip_times']:
                 unit_data = self.config['cip_times'][unit_name]
+                actual_time_str = None
+                
                 if isinstance(unit_data, dict) and 'actual_time' in unit_data:
                     # 新格式：{'actual_time': '...', 'predicted_time': '...'}
-                    self.last_seen_actual_times[unit_name] = unit_data['actual_time']
+                    actual_time_str = unit_data['actual_time']
                 elif isinstance(unit_data, str):
                     # 兼容旧格式：直接是时间字符串
-                    self.last_seen_actual_times[unit_name] = unit_data
+                    actual_time_str = unit_data
+                
+                # 只记录未来的时间，已过期的时间不记录
+                if actual_time_str:
+                    actual_time_dt = self.parse_time_string(actual_time_str)
+                    if actual_time_dt and actual_time_dt >= current_time:
+                        # 未来时间：记录基准，避免触发预测
+                        self.last_seen_actual_times[unit_name] = actual_time_str
+                        logger.info(f"{unit_name}: 未来时间，不触发预测")
+                    elif actual_time_dt:
+                        # 已过期时间：不记录基准，让首次检查时能检测到变化
+                        logger.info(f"{unit_name}: 已过期，待触发预测")
+                    # 如果为None则不记录
+    
+    def parse_time_string(self, time_str):
+        """
+        解析时间字符串为datetime对象
+        
+        Args:
+            time_str: str，时间字符串，格式'YYYY-MM-DD HH:MM:SS'
+            
+        Returns:
+            datetime: 解析后的datetime对象，解析失败返回None
+        """
+        if not time_str or not isinstance(time_str, str):
+            return None
         
-        print(f"已初始化监控基准时间: {self.last_seen_actual_times}")
+        try:
+            return datetime.strptime(time_str, '%Y-%m-%d %H:%M:%S')
+        except Exception as e:
+            logger.warning(f"时间字符串解析失败: {time_str}, 错误: {e}")
+            return None
     
     def check_for_changes(self):
         """
-        检查actual_time是否有变化
+        检查actual_time是否有变化且小于当前时间
         
         功能：
         比对当前配置文件中的actual_time和上次记录的值
-        发现不同则判定为有变化，需要触发预测
+        发现不同且小于当前时间则判定为有变化，需要触发预测
         
         Returns:
             list: 有变化的机组列表，格式 [(unit_name, new_actual_time), ...]
@@ -137,9 +198,11 @@ class SmartCIPMonitor:
         
         说明：
         - 只有actual_time变化才会触发
+        - 必须满足 actual_time < 当前时间
         - predicted_time的变化不会触发
         """
         changes = []
+        current_time = datetime.now()
         
         if not self.config or 'cip_times' not in self.config:
             return changes
@@ -159,11 +222,23 @@ class SmartCIPMonitor:
                 # 检查是否有变化
                 if current_actual_time:
                     last_actual_time = self.last_seen_actual_times.get(unit_name)
+                    
+                    # 条件1：actual_time 发生了变化
                     if last_actual_time != current_actual_time:
-                        changes.append((unit_name, current_actual_time))
-                        print(f"\n检测到{unit_name}实际CIP时间变化:")
-                        print(f"  旧值: {last_actual_time}")
-                        print(f"  新值: {current_actual_time}")
+                        # 条件2：actual_time 小于当前时间
+                        actual_time_dt = self.parse_time_string(current_actual_time)
+                        
+                        if actual_time_dt is None:
+                            logger.warning(f"{unit_name} actual_time 格式无效: {current_actual_time}")
+                            continue
+                        
+                        if actual_time_dt < current_time:
+                            changes.append((unit_name, current_actual_time))
+                            logger.info(f"{unit_name}: 检测到变化，触发预测 ({current_actual_time})")
+                        else:
+                            logger.info(f"{unit_name}: 未来时间，不触发 ({current_actual_time})")
+                            # 更新监控基准，避免重复提示
+                            self.last_seen_actual_times[unit_name] = current_actual_time
         
         return changes
     
@@ -189,27 +264,24 @@ class SmartCIPMonitor:
         - 下次预测只由actual_time的变化触发
         """
         try:
-            print(f"\n{'='*50}")
-            print(f"开始预测 {unit_name}")
-            print(f"基于实际CIP时间: {start_date_str}")
-            print(f"{'='*50}")
+            logger.info(f"[{unit_name}] 开始预测 (基于 {start_date_str})")
             
             # 步骤1：调用预测逻辑
             result_df = run_cip_analysis(strategy=3, start_date=start_date_str, unit_filter=unit_name)
             
             if result_df.empty:
-                print(f"{unit_name} 预测失败: 无结果")
+                logger.warning(f"[{unit_name}] 预测失败: 无结果")
                 return False
             
             # 步骤2：提取该机组的结果
             unit_result = result_df[result_df['机组类型'] == unit_name]
             if unit_result.empty:
-                print(f"{unit_name} 预测失败: 结果中无此机组")
+                logger.warning(f"[{unit_name}] 预测失败: 结果中无此机组")
                 return False
             
             cip_time = unit_result.iloc[0]['CIP时机']
             if pd.isna(cip_time):
-                print(f"{unit_name} 预测失败: CIP时机为空")
+                logger.warning(f"[{unit_name}] 预测失败: CIP时机为空")
                 return False
             
             # 步骤3：保存预测时间到配置文件（仅用于记录）
@@ -234,29 +306,18 @@ class SmartCIPMonitor:
                     self.config['cip_times'][unit_name]['predicted_time'] = predicted_time_str
             
             if not self.save_config():
-                print(f"✗ {unit_name} 配置保存失败")
+                logger.error(f"[{unit_name}] 配置保存失败")
                 return False
             
-            print(f"✓ {unit_name} 预测成功")
-            print(f"  实际CIP时间: {start_date_str}")
-            print(f"  预测CIP时间: {predicted_time_str} (仅用于记录)")
+            logger.info(f"[{unit_name}] 预测成功 → {predicted_time_str}")
             
             # 步骤4：发送预测结果到回调接口
-            print(f"\n发送预测结果到回调接口...")
-            try:
-                if send_decision_to_callback(result_df):
-                    print(f"✓ {unit_name} 回调发送成功")
-                else:
-                    print(f"✗ {unit_name} 回调发送失败")
-            except Exception as callback_error:
-                print(f"✗ {unit_name} 回调发送异常: {callback_error}")
+            send_decision_to_callback(result_df)
             
             return True
                 
         except Exception as e:
-            print(f"✗ {unit_name} 预测失败: {e}")
-            import traceback
-            traceback.print_exc()
+            logger.error(f"[{unit_name}] 预测失败: {e}")
             return False
     
     def process_changes(self, changes):
@@ -272,23 +333,19 @@ class SmartCIPMonitor:
         
         处理流程：
         1. 执行预测：调用predict_and_update_unit
-        2. 更新监控基准：将新的actual_time记录到last_seen_actual_times
+        2. 更新监控基准：将新的actual_time记录到last_seen_actual_times（无论成功失败）
         3. 重新加载配置：确保获取最新数据
         4. 短暂延时：避免频繁操作
         """
         for unit_name, new_actual_time in changes:
-            print(f"\n{'='*60}")
-            print(f"处理 {unit_name} 的实际CIP时间变化")
-            print(f"{'='*60}")
-            
             # 执行预测
-            if self.predict_and_update_unit(unit_name, new_actual_time):
-                # 更新监控基准，防止重复处理
-                self.last_seen_actual_times[unit_name] = new_actual_time
-                print(f"\n✓ {unit_name} 处理完成，已更新监控基准")
-                print(f"  新的监控基准: {new_actual_time}")
-            else:
-                print(f"\n✗ {unit_name} 处理失败")
+            success = self.predict_and_update_unit(unit_name, new_actual_time)
+            
+            # ⚠️ 关键修复：无论预测成功还是失败，都要更新监控基准，避免无限循环
+            self.last_seen_actual_times[unit_name] = new_actual_time
+            
+            if not success:
+                logger.error(f"[{unit_name}] 处理失败，已记录时间避免重复")
             
             # 重新加载配置，确保有最新数据
             self.load_config()
@@ -300,8 +357,8 @@ class SmartCIPMonitor:
         
         功能：
         1. 定期重新加载config.json（每5秒）
-        2. 检查actual_time是否有变化
-        3. 发现变化后自动触发预测
+        2. 检查actual_time是否有变化且小于当前时间
+        3. 发现满足条件的变化后自动触发预测
         4. 发送预测结果到回调接口
         
         监控频率：
@@ -309,26 +366,23 @@ class SmartCIPMonitor:
         - 发现变化立即处理
         - 处理失败不影响后续监控
         
+        触发条件（同时满足）：
+        - actual_time 发生了变化
+        - actual_time < 当前时间（已过期）
+        
         说明：
         - 只监控actual_time字段的变化
         - predicted_time的变化不会触发任何操作
         - 相同的actual_time不会重复触发
+        - 未来时间的actual_time不会触发预测
         """
-        print("\n" + "="*60)
-        print("开始监控config.json的变化")
-        print("="*60)
-        print("监控说明:")
-        print("  - 监控字段: cip_times.*.actual_time")
-        print("  - 检查频率: 每5秒")
-        print("  - 触发条件: actual_time发生变化")
-        print("  - 自动操作: 执行预测 → 保存predicted_time → 发送回调")
-        print("="*60)
+        logger.info("监控启动 (每5秒检查一次，触发条件: actual_time变化且<当前时间)")
         
         while self.running:
             try:
                 # 步骤1：重新加载配置
                 if not self.load_config():
-                    print("✗ 配置加载失败，10秒后重试...")
+                    logger.error("配置加载失败，10秒后重试...")
                     time.sleep(10)
                     continue
                 
@@ -337,16 +391,13 @@ class SmartCIPMonitor:
                 
                 if changes:
                     # 发现变化，立即处理
-                    print(f"\n检测到 {len(changes)} 个机组的actual_time变化")
                     self.process_changes(changes)
                 
                 # 步骤3：等待一段时间后再次检查
                 time.sleep(5)  # 每5秒检查一次配置文件
                     
             except Exception as e:
-                print(f"\n✗ 监控循环出错: {e}")
-                import traceback
-                traceback.print_exc()
+                logger.error(f"监控循环出错: {e}", exc_info=True)
                 time.sleep(10)  # 出错后等待10秒再继续
     
     def start(self):
@@ -354,26 +405,15 @@ class SmartCIPMonitor:
         启动监控系统
         """
         if self.running:
-            print("监控系统已在运行")
+            logger.warning("监控系统已在运行")
             return
         
-        print("\n启动CIP监控系统")
-        print("="*60)
-        print("监控模式: 检测config.json中actual_time的变化")
-        print("工作流程:")
-        print("  1. 手动修改config.json中的actual_time")
-        print("  2. 系统自动检测到变化")
-        print("  3. 基于actual_time执行预测")
-        print("  4. 保存predicted_time（仅用于记录）")
-        print("  5. 继续监控下一次变化")
-        print("="*60)
+        logger.info("CIP监控系统启动（监控 config.json 中的 actual_time 变化）")
         
         # 启动监控线程
         self.running = True
         self.monitor_thread = threading.Thread(target=self.monitor_loop, daemon=True)
         self.monitor_thread.start()
-        
-        print("\n监控系统已启动，按Ctrl+C停止")
 
         try:
             while self.running:
@@ -385,13 +425,13 @@ class SmartCIPMonitor:
         """
         停止监控系统
         """
-        print("\n停止监控系统...")
+        logger.info("停止监控系统...")
         self.running = False
         
         if self.monitor_thread and self.monitor_thread.is_alive():
             self.monitor_thread.join(timeout=5)
         
-        print("监控系统已停止")
+        logger.info("监控系统已停止")
 
 def main():
     """
@@ -399,17 +439,12 @@ def main():
     
     功能：启动监控系统
     """
-    print("CIP监控系统 - 配置文件监控模式")
-    print("="*60)
-    
     monitor = SmartCIPMonitor()
     
     try:
         monitor.start()
     except Exception as e:
-        print(f"系统运行出错: {e}")
-        import traceback
-        traceback.print_exc()
+        logger.error(f"系统运行出错: {e}", exc_info=True)
     finally:
         if monitor.running:
             monitor.stop()