使用SimPy进行工厂生产线离散事件模拟教程_石家庄创泽智能科技有限公司

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

使用SimPy进行工厂生产线离散事件模拟教程

2025-11-04

浏览次数：次

返回列表

使用SimPy进行工厂生产线离散事件模拟教程

本文将深入探讨如何使用python的simpy库构建一个离散事件模拟模型，以模拟工厂生产线的复杂流程。我们将详细介绍资源管理、零件生成、多阶段加工以及如何通过simpy的`priorityresource`和事件机制来精确控制生产流程和资源分配，旨在提供一个清晰、专业的simpy应用指南。

引言：SimPy与离散事件模拟

离散事件模拟（Discrete Event Simulation, DES）是一种强大的建模工具，用于分析复杂系统随时间变化的动态行为。在制造业中，DES常用于优化生产线布局、评估资源利用率、识别瓶颈以及预测系统性能。SimPy是一个基于Python的DES框架，它通过提供进程（processes）和资源（resources）等核心概念，使得构建这类模拟模型变得直观和高效。

在工厂生产线的场景中，零件（实体）在不同的工位（资源）之间移动，并经历一系列加工步骤（事件）。这些工位可能包括操作员、机器人、夹具等，它们通常数量有限，需要被零件请求和释放。SimPy能够模拟这些实体与资源的交互，以及加工过程所需的时间，从而揭示生产线的整体运作效率。

核心组件：全局常量与工厂模型初始化

在构建SimPy模型时，首先定义一些全局常量和模拟环境是良好的实践。

1. 定义全局常量

我们通常会将模拟中不变的参数（如加工时间、资源数量）集中管理，以提高代码的可读性和可维护性。

import simpy
import itertools

class g: # 全局常量类
    t_sim = 600 # 模拟最大时长，例如600秒 (原问题为一天，这里为演示缩短)

    operator_qty = 2 # 操作员数量

    sWeld_t = 2.75 # 点焊时间（秒/次）
    Adh_t = 1/60 # 涂胶时间（秒/毫米）
    ArcStud_t = 5.5 # 拉弧焊时间（秒/次）
    ProjStud_t = 10 # 凸焊时间（秒/次）

g 类封装了所有与模拟过程相关的固定参数，例如模拟总时长t_sim、操作员数量operator_qty，以及各种加工步骤的单位时间。

2. 初始化工厂单元模型

cell_model 类代表了整个工厂单元，负责创建SimPy环境、定义所有可用资源，并启动零件生成器。

class cell_model: # 代表整个工厂单元
    def __init__(self): # 单元的初始条件
        self.env = simpy.Environment() # 创建SimPy环境
        self.part_counter = 0 # 零件计数器

        # 声明所有资源，使用PriorityResource以支持优先级调度
        # 操作员资源，可被多个进程共享
        self.OP = simpy.PriorityResource(self.env, capacity=g.operator_qty)

        # 机器人资源，每个机器人一次只能处理一个零件
        self.R1 = simpy.PriorityResource(self.env, capacity=1)
        self.R2 = simpy.PriorityResource(self.env, capacity=1)
        self.R3 = simpy.PriorityResource(self.env, capacity=1)
        self.R4 = simpy.PriorityResource(self.env, capacity=1)

        # 夹具资源，每个夹具一次只能放置一个零件
        self.Fix01 = simpy.PriorityResource(self.env, capacity=1)
        self.Fix02 = simpy.PriorityResource(self.env, capacity=1)
        self.Fix101 = simpy.PriorityResource(self.env, capacity=1)

        # 启动零件生成器进程
        self.env.process(self.part_generator())

在 __init__ 方法中：

VALL-E

VALL-E是一种用于文本到语音生成 (TTS) 的语言建模方法

134 查看详情 VALL-E

self.env = simpy.Environment()：这是SimPy模拟的核心，所有事件都在此环境中调度。
self.part_counter = 0：用于追踪生成的零件数量。
simpy.PriorityResource(self.env, capacity=X)：定义了各种类型的资源。capacity 参数指定了该资源可以同时处理的实体数量。PriorityResource 允许我们为请求设置优先级，通常较低的数字代表较高的优先级。在本例中，零件ID p_Id 被用作优先级，确保零件按进入顺序处理。
self.env.process(self.part_generator())：将 part_generator 方法注册为一个SimPy进程，使其在模拟开始时运行。

生产流程建模：make_part函数详解

make_part 函数是模拟中最重要的部分，它描述了一个零件从进入生产线到完成所有工序的完整路径。每个零件都将作为独立的SimPy进程通过这个流程。

    def make_part(self, p_Id): # 描述单个零件在单元中的所有流程
        # 1. 操作员将零件带到工作台
        OP_req1 = self.OP.request(priority=p_Id) 
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 请求操作员")
        yield OP_req1 # 请求操作员并等待其可用
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 占用操作员")
        yield self.env.timeout(29) # 操作员移动零件、贴胶、放置到夹具01

        # 2. 请求夹具01
        Fix01_req = self.Fix01.request(priority=p_Id)
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 请求夹具01")
        yield Fix01_req # 等待夹具01可用
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 占用夹具01")
        yield self.env.timeout(27) # 操作员加载零件，退出

        # 3. 释放操作员
        self.OP.release(OP_req1) # 操作员完成任务，释放回资源池
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 释放操作员")
        yield self.env.timeout(0) # 短暂暂停

        # 4. 机器人R2进行点焊 (使用with语句自动释放)
        with self.R2.request(priority=p_Id) as R2_req:   
            print(f"零件 {p_Id} 在 {self.env.now:.2f} 请求机器人R2") 
            yield R2_req # 请求机器人R2
            print(f"零件 {p_Id} 在 {self.env.now:.2f} 占用机器人R2 (第一阶段)")
            yield self.env.timeout(g.sWeld_t * 11) # R2进行11次点焊
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 释放机器人R2 (with块自动释放)")

        # 5. 机器人R1移动零件并进行焊接
        R1_req = self.R1.request(priority=p_Id)
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 请求机器人R1")
        yield R1_req # 请求机器人R1
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 占用机器人R1")
        yield self.env.timeout(8) # R1将零件移出夹具01
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 离开夹具01")

        # 6. 释放夹具01
        self.Fix01.release(Fix01_req) # 夹具01清空，释放回资源池
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 释放夹具01")
        yield self.env.timeout(g.sWeld_t * 13) # R1进行13次点焊
        yield self.env.timeout(g.ArcStud_t * 5) # R1进行5次拉弧焊
        yield self.env.timeout(8) # R1移动到夹具101

        # 7. 请求夹具101
        Fix101_req = self.Fix101.request(priority=p_Id)
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 请求夹具101")
        yield Fix101_req # 请求夹具101
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 占用夹具101")
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 进入夹具101")

        # 8. 释放机器人R1
        self.R1.release(R1_req) # R1完成任务，释放回资源池
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 释放机器人R1")

        # 9. 机器人R4进行拉弧焊 (使用with语句自动释放)
        with self.R4.request(priority=p_Id) as R4_req:
            print(f"零件 {p_Id} 在 {self.env.now:.2f} 请求机器人R4")
            yield R4_req # 请求机器人R4
            print(f"零件 {p_Id} 在 {self.env.now:.2f} 占用机器人R4")
            yield self.env.timeout(g.ArcStud_t * 6) # R4进行6次拉弧焊
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 释放机器人R4")

        # 10. 机器人R3移动零件并进行焊接、涂胶
        R3_req = self.R3.request(priority=p_Id) 
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 请求机器人R3")
        yield R3_req # 请求机器人R3
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 占用机器人R3")
        yield self.env.timeout(8) # R3将零件移出夹具101
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 离开夹具101")

        # 11. 释放夹具101
        self.Fix101.release(Fix101_req) # 夹具101清空，释放回资源池
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 释放夹具101")
        yield self.env.timeout(g.ProjStud_t * 6) # R3进行6次凸焊
        yield self.env.timeout(225 * g.Adh_t) # 涂255mm胶
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 完成涂胶")
        yield self.env.timeout(8) # R3移动到夹具02

        # 12. 请求夹具02
        Fix02_req = self.Fix02.request(priority=p_Id)
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 请求夹具02")
        yield Fix02_req # 请求夹具02
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 占用夹具02")
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 进入夹具02")

        # 13. 释放机器人R3
        self.R3.release(R3_req) # R3完成任务，释放回资源池
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 释放机器人R3")

        # 14. 操作员进行第二阶段操作 (使用with语句自动释放)
        with self.OP.request(priority=p_Id) as OP_req2:
            print(f"零件 {p_Id} 在 {self.env.now:.2f} 请求操作员 (第二阶段)")
            yield OP_req2 # 请求操作员
            print(f"零件 {p_Id} 在 {self.env.now:.2f} 占用操作员 (第二阶段)")
            yield self.env.timeout(38) # 操作员进行第二阶段操作
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 释放操作员 (第二阶段)")

        # 15. 机器人R2再次进行焊接 (使用with语句自动释放)
        with self.R2.request(priority=p_Id) as R2_req2:
            print(f"零件 {p_Id} 在 {self.env.now:.2f} 请求机器人R2 (第二阶段)")
            yield R2_req2 # 请求机器人R2
            print(f"零件 {p_Id} 在 {self.env.now:.2f} 占用机器人R2 (第二阶段)")
            print(f"零件 {p_Id} 在 {self.env.now:.2f} 机器人R2移动到夹具02工作")
            yield self.env.timeout(g.sWeld_t * 35) # R2进行35次点焊
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 释放机器人R2 (第二阶段)")

        # 16. 操作员移除零件并完成流程 (使用with语句自动释放)
        with self.OP.request(priority=p_Id) as OP_req3:
            print(f"零件 {p_Id} 在 {self.env.now:.2f} 请求操作员 (第三阶段)")
            yield OP_req3 # 请求操作员
            print(f"零件 {p_Id} 在 {self.env.now:.2f} 占用操作员 (第三阶段)")
            yield self.env.timeout(2) # 操作员移除零件

            # 17. 释放夹具02
            self.Fix02.release(Fix02_req) # 夹具02清空，释放回资源池
            print(f"零件 {p_Id} 在 {self.env.now:.2f} 释放夹具02")
            print(f"零件 {p_Id} 在 {self.env.now:.2f} 离开生产线")
        print(f"零件 {p_Id} 在 {self.env.now:.2f} 释放操作员 (第三阶段)")

关键概念与注意事项：

进程与事件: make_part 是一个生成器函数，当它被 self.env.process() 调用时，就成为了一个SimPy进程。yield 关键字是SimPy中调度事件的关键。yield resource.request() 会暂停当前进程，直到请求的资源可用；yield env.timeout(duration) 会暂停进程指定的时间。
资源请求与释放:
- 显式请求/释放: request = self.Resource.request(priority=p_Id) 和 yield request 用于请求资源，然后 self.Resource.release(request) 用于释放资源。这种方式提供了最大的灵活性，允许你在请求和释放之间执行其他操作，或者在流程中的不同点释放资源。
- with 语句: with self.Resource.request(priority=p_Id) as req: 是一种更简洁的资源管理方式。当进入 with 块时，资源被请求；当退出 with 块时（无论是正常退出还是异常），资源会自动被释放。这简化了代码，并减少了忘记释放资源的风险。
- 选择: 对于资源在长时间段内被占用，且期间可能涉及其他资源的请求和释放的情况（如操作员将零件带到夹具，然后操作员离开，但夹具仍被占用），应使用显式请求和释放。对于资源仅在特定操作期间被占用，操作完成后立即释放的情况（如机器人执行焊接），with 语句是更好的选择。原始代码中存在一些 with 语句过早释放资源的问题，修正后的代码区分了这两种情况。
优先级 (priority=p_Id): PriorityResource 允许在多个进程同时请求同一资源时，根据优先级进行调度。较低的优先级数字表示更高的优先级。在本例中，p_Id（零件ID）被用作优先级，确保先生成的零件（ID较小）有更高的优先级，从而实现先进先出（FIFO）的调度顺序。
机器人重复使用: 机器人R2在流程的早期和后期都被使用，这在SimPy中通过简单地再次请求该资源来实现。SimPy会自动处理资源的可用性和调度。
调试: 模拟过程中大量的 print 语句非常有助于追踪零件的实时状态、资源请求和释放时间点，这对于理解模拟行为和调试（例如，发现死锁）至关重要。

零件生成器与*运行

1. 零件生成器

part_generator 进程负责在模拟过程中不断创建新的零件。

    def part_generator(self):
        for p_Id in itertools.count(): # 无限生成零件ID
            yield self.env.timeout(1) # 每隔1秒生成一个新零件
            self.env.process(self.make_part(p_Id)) # 启动一个新零件的加工进程

itertools.count() 会生成一个无限递增的整数序列作为 p_Id。yield self.env.timeout(1) 表示每隔1个模拟时间单位（秒），就会生成一个新的零件。self.env.process(self.make_part(p_Id)) 则为每个新零件启动一个独立的 make_part 进程。

2. 运行模拟

run 方法是启动整个模拟的入口。

    def run(self, t_sim=g.t_sim): # 运行方法启动实体生成器并告诉Simpy运行环境
        self.env.run(until=t_sim) # 运行模拟直到指定时间

# 运行模拟
print("Simulation Starting...")
my_model = cell_model()
my_model.run()
print("Simulation Finished.")

my_model.run() 调用 self.env.run(until=t_sim)，这将启动SimPy环境，并执行所有已注册的进程，直到模拟时间达到 t_sim。

SimPy建模的最佳实践与常见问题

清晰的资源管理: 确保每个 request 都有对应的 release。使用 with 语句可以减少忘记释放资源的错误，但需要注意其作用域。当资源在 with 块之外仍需被占用时，应使用显式 request 和 release。
避免死锁: 死锁是离散事件模拟中常见的问题，通常发生在多个进程相互等待对方释放资源时。仔细规划资源的请求顺序，避免循环等待，是预防死锁的关键。例如，如果进程A持有资源X并等待资源Y，而进程B持有资源Y并等待资源X，则会发生死锁。
详细的日志输出: 在开发和调试阶段，利用 print 语句输出事件发生的时间、进程ID和资源状态，可以帮助理解模拟流程，快速定位问题。
模块化设计:

以上就是使用SimPy进行工厂生产线离散事件模拟教程的详细内容，更多请关注其它相关文章！

# 资源管理 # 合肥网站代码优化工作 # 微山seo优化代理 # 合肥seo搜索推广招聘 # 盐都关键词百度排名 # 免费网站建设方案报价 # 洛阳SEO矩阵运营培训 # 微信营销推广加人游戏 # 娄底网站建设最便宜 # 站外主要营销推广方式 # 中山网站建设分工 # 较低 # 更高 # python # 第三阶段 # 清空 # 完成任务 # 是一个 # 多个 # 是一种 # 死锁 # 作用域 # 常见问题 # 工具 # js