---

name: smed-analyzer description: 用于通过单分钟快速换模方法分析并减少换模时间的专业技能。 allowed-tools: Bash(*) 读取 写入 编辑 全局搜索 查找 Web获取 metadata: author: babysitter-sdk version: “1.0.0” category: 精益生产 backlog-id: SK-IE-011

smed-analyzer

您是 smed-analyzer - 一个专门用于使用单分钟快速换模（SMED）方法分析和减少换模时间的专业技能。

概述

此技能支持AI驱动的SMED分析，包括：

• 换模视频分析
• 内部与外部活动分离
• 活动计时与排序
• 转换机会识别
• 并行工作分配
• 快速释放机制建议
• 前后对比报告
• 标准换模文档

前提条件

• 视频录制能力
• 秒表或计时软件
• 了解换模流程

功能

1. 换模活动记录

from dataclasses import dataclass
from enum import Enum
from typing import List, Optional
import datetime

class ActivityType(Enum):
    INTERNAL = "internal"  # 机器必须停止
    EXTERNAL = "external"  # 可在运行时完成

@dataclass
class ChangeoverActivity:
    id: int
    description: str
    start_time: float  # 从换模开始的秒数
    end_time: float
    activity_type: ActivityType
    operator: str
    tools_required: List[str]
    notes: Optional[str] = None

    @property
    def duration(self):
        return self.end_time - self.start_time

class ChangeoverAnalysis:
    """
    记录和分析换模活动
    """
    def __init__(self, machine_name: str, from_product: str, to_product: str):
        self.machine_name = machine_name
        self.from_product = from_product
        self.to_product = to_product
        self.activities: List[ChangeoverActivity] = []
        self.timestamp = datetime.datetime.now()

    def add_activity(self, description, start, end, activity_type,
                    operator, tools=None, notes=None):
        activity = ChangeoverActivity(
            id=len(self.activities) + 1,
            description=description,
            start_time=start,
            end_time=end,
            activity_type=activity_type,
            operator=operator,
            tools_required=tools or [],
            notes=notes
        )
        self.activities.append(activity)
        return activity

    def summary(self):
        internal = [a for a in self.activities if a.activity_type == ActivityType.INTERNAL]
        external = [a for a in self.activities if a.activity_type == ActivityType.EXTERNAL]

        return {
            "total_changeover_time": max(a.end_time for a in self.activities),
            "internal_time": sum(a.duration for a in internal),
            "external_time": sum(a.duration for a in external),
            "num_activities": len(self.activities),
            "num_internal": len(internal),
            "num_external": len(external)
        }

2. 内部/外部分离分析

def analyze_internal_external(activities):
    """
    识别可从内部转换为外部的活动
    """
    conversion_opportunities = []

    for activity in activities:
        if activity.activity_type == ActivityType.INTERNAL:
            # 检查转换潜力
            potential = assess_conversion_potential(activity)
            if potential['can_convert']:
                conversion_opportunities.append({
                    "activity_id": activity.id,
                    "description": activity.description,
                    "current_duration": activity.duration,
                    "conversion_method": potential['method'],
                    "estimated_savings": potential['savings'],
                    "investment_required": potential['investment']
                })

    return conversion_opportunities

def assess_conversion_potential(activity):
    """
    评估内部活动是否可以变为外部
    """
    # 指示转换潜力的关键词
    prep_keywords = ['get', 'find', 'look for', 'search', 'locate', 'bring']
    adjustment_keywords = ['adjust', 'set', 'calibrate', 'tune']
    removal_keywords = ['remove', 'take off', 'disconnect']

    desc_lower = activity.description.lower()

    # 准备活动通常可以在外部完成
    if any(kw in desc_lower for kw in prep_keywords):
        return {
            'can_convert': True,
            'method': '在停止机器前预先准备工具和材料',
            'savings': activity.duration * 0.9,  # 减少90%
            'investment': '低 - 组织和准备区域'
        }

    # 通过预设可以消除调整
    if any(kw in desc_lower for kw in adjustment_keywords):
        return {
            'can_convert': True,
            'method': '使用预设工具或夹具进行即时设置',
            'savings': activity.duration * 0.7,
            'investment': '中 - 预设工具投资'
        }

    return {'can_convert': False}

3. 并行工作分析

def analyze_parallel_opportunities(activities, available_operators):
    """
    识别可以并行完成的活动
    """
    # 按时间窗口分组活动
    timeline = []

    for activity in activities:
        timeline.append({
            'time': activity.start_time,
            'type': 'start',
            'activity': activity
        })
        timeline.append({
            'time': activity.end_time,
            'type': 'end',
            'activity': activity
        })

    timeline.sort(key=lambda x: x['time'])

    # 分析操作员利用率
    parallel_opportunities = []
    current_activities = []

    for event in timeline:
        if event['type'] == 'start':
            current_activities.append(event['activity'])
        else:
            current_activities.remove(event['activity'])

        # 检查操作员是否空闲
        active_operators = len(set(a.operator for a in current_activities))
        idle_operators = available_operators - active_operators

        if idle_operators > 0 and len(current_activities) > 0:
            parallel_opportunities.append({
                'time': event['time'],
                'idle_operators': idle_operators,
                'active_activities': [a.description for a in current_activities]
            })

    return parallel_opportunities

def optimize_parallel_work(activities, available_operators):
    """
    重新分配活动以实现并行执行
    """
    # 简单的贪心分配
    assignments = {i: [] for i in range(available_operators)}
    operator_end_times = [0] * available_operators

    # 按开始时间排序
    sorted_activities = sorted(activities, key=lambda a: a.start_time)

    for activity in sorted_activities:
        # 找到最早完成的操作员
        earliest_op = min(range(available_operators),
                         key=lambda i: operator_end_times[i])

        # 分配给此操作员
        new_start = max(activity.start_time, operator_end_times[earliest_op])
        new_end = new_start + activity.duration

        assignments[earliest_op].append({
            'activity': activity.description,
            'original_start': activity.start_time,
            'new_start': new_start,
            'end': new_end
        })

        operator_end_times[earliest_op] = new_end

    new_total_time = max(operator_end_times)
    original_total_time = max(a.end_time for a in activities)

    return {
        'assignments': assignments,
        'original_time': original_total_time,
        'optimized_time': new_total_time,
        'time_savings': original_total_time - new_total_time,
        'reduction_percent': (1 - new_total_time/original_total_time) * 100
    }

4. 快速释放机制建议

def suggest_quick_release_mechanisms(activities):
    """
    为更快换模提出工程改进建议
    """
    suggestions = []

    for activity in activities:
        desc_lower = activity.description.lower()

        # 紧固件改进
        if any(word in desc_lower for word in ['bolt', 'screw', 'nut', 'fasten']):
            suggestions.append({
                'activity': activity.description,
                'current_method': '螺纹紧固件',
                'improvement': '快速释放夹具、凸轮锁或四分之一转紧固件',
                'typical_reduction': '70-90%',
                'investment_level': '中'
            })

        # 工具更换
        if 'tool' in desc_lower and 'change' in desc_lower:
            suggestions.append({
                'activity': activity.description,
                'current_method': '手动工具更换',
                'improvement': '带预设工具的快速更换刀柄',
                'typical_reduction': '80-95%',
                'investment_level': '中-高'
            })

        # 定位/对齐
        if any(word in desc_lower for word in ['align', 'position', 'center']):
            suggestions.append({
                'activity': activity.description,
                'current_method': '手动对齐',
                'improvement': '定位销、导向装置或自定心夹具',
                'typical_reduction': '60-80%',
                'investment_level': '低-中'
            })

        # 设置/调整
        if any(word in desc_lower for word in ['adjust', 'set', 'calibrate']):
            suggestions.append({
                'activity': activity.description,
                'current_method': '试错调整',
                'improvement': '数字预设、刻度或挡块',
                'typical_reduction': '50-70%',
                'investment_level': '中'
            })

    return suggestions

5. 前后对比

def generate_comparison_report(before_analysis, after_analysis):
    """
    生成SMED前后对比报告
    """
    before_summary = before_analysis.summary()
    after_summary = after_analysis.summary()

    return {
        'changeover': {
            'machine': before_analysis.machine_name,
            'product_change': f"{before_analysis.from_product} -> {before_analysis.to_product}"
        },
        'time_comparison': {
            'before': {
                'total_minutes': before_summary['total_changeover_time'] / 60,
                'internal_minutes': before_summary['internal_time'] / 60,
                'external_minutes': before_summary['external_time'] / 60
            },
            'after': {
                'total_minutes': after_summary['total_changeover_time'] / 60,
                'internal_minutes': after_summary['internal_time'] / 60,
                'external_minutes': after_summary['external_time'] / 60
            }
        },
        'improvement': {
            'time_reduction_minutes': (before_summary['total_changeover_time'] -
                                       after_summary['total_changeover_time']) / 60,
            'percent_reduction': (1 - after_summary['total_changeover_time'] /
                                 before_summary['total_changeover_time']) * 100,
            'internal_reduction_percent': (1 - after_summary['internal_time'] /
                                          before_summary['internal_time']) * 100
        },
        'activities_comparison': {
            'before_count': before_summary['num_activities'],
            'after_count': after_summary['num_activities'],
            'eliminated': before_summary['num_activities'] - after_summary['num_activities']
        }
    }

6. 标准换模文档

def generate_standard_changeover(optimized_analysis):
    """
    创建换模标准工作文档
    """
    document = {
        'title': f"标准换模: {optimized_analysis.machine_name}",
        'revision': '1.0',
        'date': datetime.datetime.now().isoformat(),
        'target_time_minutes': optimized_analysis.summary()['total_changeover_time'] / 60,
        'preparation_phase': {
            'description': '在停止机器前要完成的活动',
            'activities': []
        },
        'changeover_phase': {
            'description': '机器停止时执行的活动',
            'activities': []
        },
        'startup_phase': {
            'description': '启动机器后要完成的活动',
            'activities': []
        }
    }

    for activity in optimized_analysis.activities:
        entry = {
            'step': activity.id,
            'description': activity.description,
            'time_seconds': activity.duration,
            'operator': activity.operator,
            'tools': activity.tools_required,
            'notes': activity.notes
        }

        if activity.activity_type == ActivityType.EXTERNAL:
            if activity.start_time < 0:  # 准备阶段
                document['preparation_phase']['activities'].append(entry)
            else:
                document['startup_phase']['activities'].append(entry)
        else:
            document['changeover_phase']['activities'].append(entry)

    return document

流程集成

此技能与以下流程集成：

• setup-time-reduction-smed.js
• kaizen-event-facilitation.js
• oee-improvement.js

输出格式

{
  "current_state": {
    "total_changeover_minutes": 45,
    "internal_minutes": 38,
    "external_minutes": 7
  },
  "opportunities": {
    "convert_to_external": 5,
    "parallel_execution": 3,
    "quick_release": 4,
    "eliminate": 2
  },
  "projected_future_state": {
    "total_changeover_minutes": 12,
    "reduction_percent": 73
  },
  "implementation_plan": {
    "phase_1": "将准备工作转换为外部",
    "phase_2": "实施并行工作",
    "phase_3": "安装快速释放机制"
  }
}

最佳实践

1. 视频记录换模过程 - 捕捉实际流程
2. 让操作员参与 - 他们了解细节
3. 先分离内部/外部活动 - 快速见效
4. 在优化前标准化 - 一致的基础
5. 测量前后效果 - 验证改进
6. 记录标准工作 - 保持成果

约束条件

• 不能为速度而牺牲安全
• 换模后验证质量
• 考虑操作员人体工程学
• 记录所有标准程序