csma/ca python仿真程序

CSMA/CA是一种网络协议，用于在共享介质上进行数据通信，以避免冲突。以下是一个基于Python的CSMA/CA仿真程序，你可以根据需要进行修改和优化。

import random

# 定义网络参数
CWmin = 4
CWmax = 1024
slot_time = 0.000009
SIFS_time = 0.000016
DIFS_time = 0.000028
ACK_time = 0.000016
frame_size = 1000
simulation_time = 0.1

# 定义节点类
class Node:
    def __init__(self, id, state):
        self.id = id
        self.state = state
        self.cw = CWmin
        self.backoff_time = 0
        self.curr_frame = None
        self.waiting_for_ACK = False
        self.collisions = 0

    # 定义等待ACK函数
    def wait_for_ACK(self):
        self.waiting_for_ACK = True
        self.backoff_time = 0
        self.curr_frame = None

    # 定义生成随机时间函数
    def generate_random_time(self):
        return random.randint(0, self.cw) * slot_time

    # 定义发送函数
    def send(self, frame):
        if self.state == "IDLE":
            self.curr_frame = frame
            self.state = "BACKOFF"
            self.backoff_time = self.generate_random_time()

    # 定义退避函数
    def backoff(self):
        if self.state == "BACKOFF":
            if self.backoff_time > 0:
                self.backoff_time -= slot_time
            else:
                self.state = "TRANSMIT"
                self.waiting_for_ACK = False

    # 定义传输函数
    def transmit(self):
        if self.state == "TRANSMIT":
            collision = False
            for node in nodes:
                if node.id != self.id and node.state == "TRANSMIT":
                    collision = True
                    break
            if collision:
                self.state = "COLLISION"
                self.backoff_time = self.generate_random_time()
                self.cw = min(self.cw * 2, CWmax)
                self.collisions += 1
            else:
                self.state = "WAIT_FOR_ACK"
                self.waiting_for_ACK = True
                self.backoff_time = SIFS_time + ACK_time
                self.cw = CWmin
                self.curr_frame = None

    # 定义冲突处理函数
    def handle_collision(self):
        if self.state == "COLLISION":
            self.cw = min(self.cw * 2, CWmax)
            self.backoff_time = self.generate_random_time()
            self.collisions += 1
            self.state = "BACKOFF"

    # 定义等待ACK处理函数
    def handle_waiting_for_ACK(self):
        if self.state == "WAIT_FOR_ACK":
            if self.waiting_for_ACK:
                self.backoff_time -= slot_time
                if self.backoff_time <= 0:
                    self.state = "BACKOFF"
                    self.backoff_time = self.generate_random_time()
                    self.cw = min(self.cw * 2, CWmax)
                    self.collisions += 1

    # 定义主函数
    def run(self):
        if self.curr_frame is not None:
            print(f"Node {self.id} is transmitting frame {self.curr_frame}")
        if self.waiting_for_ACK:
            print(f"Node {self.id} is waiting for ACK for frame {self.curr_frame}")
        if self.collisions > 0:
            print(f"Node {self.id} has experienced {self.collisions} collisions")
        if self.state == "BACKOFF":
            self.backoff()
        elif self.state == "TRANSMIT":
            self.transmit()
        elif self.state == "COLLISION":
            self.handle_collision()
        elif self.state == "WAIT_FOR_ACK":
            self.handle_waiting_for_ACK()

# 定义主程序
if __name__ == "__main__":
    # 创建节点
    nodes = [Node(1, "IDLE"), Node(2, "IDLE"), Node(3, "IDLE")]

    # 定义仿真时间
    t = 0
    while t <= simulation_time:
        # 生成新帧
        if t % frame_size == 0:
            frame = t // frame_size
            print(f"New frame {frame} is generated")
            # 随机选择一个节点发送帧
            node_id = random.randint(1, len(nodes))
            nodes[node_id - 1].send(frame)

        # 运行所有节点
        for node in nodes:
            node.run()

        # 更新仿真时间
        t += slot_time

    # 输出每个节点的信息
    for node in nodes:
        print(f"Node {node.id} has experienced {node.collisions} collisions")

这个程序模拟了三个节点在共享介质上进行数据通信的过程。你可以根据需要进行修改和优化，例如增加节点数量，调整参数，改变传输协议等。