simulation.py

import config
from transmitter import Transmitter
from receiver import Receiver
from channel import ChannelEnvironment

class Simulation:
    def __init__(self, scenario="GOOD", duration_sec=600, rx_config=None):
        self.duration_us = duration_sec * 1000000
        self.current_time = 0
        self.scenario = scenario

        self.tx = Transmitter()
        self.rx = Receiver(overrides=rx_config)
        self.channel = ChannelEnvironment(scenario=scenario)

        # Stats
        self.tx_count = 0
        self.ack_count = 0
        self.recovery_events = 0 # transitions to scan
        self.total_downtime = 0 # time spent in SCANNING

    def run(self):
        last_rx_state = "SCANNING"

        while self.current_time < self.duration_us:
            # 1. Update Environment
            self.channel.update_time(self.current_time)

            # 2. Update RX state (timers)
            prev_rx_state = self.rx.state
            self.rx.step(self.current_time)
            if prev_rx_state == "SYNCED" and self.rx.state == "SCANNING":
                self.recovery_events += 1
            if self.rx.state == "SCANNING":
                self.total_downtime += config.TIME_STEP_US

            # 3. TX Step
            packet = self.tx.step(self.current_time)
            if packet:
                self.tx_count += 1

                # Try to deliver to RX
                # First, physical check: Are they on same channel?
                rx_channel = self.rx.get_listening_channel()

                delivered_packet = None
                if packet.channel == rx_channel:
                    if self.channel.can_deliver(packet):
                        delivered_packet = packet

                # RX processing
                if delivered_packet:
                    ack = self.rx.receive_packet(delivered_packet, self.current_time)
                    if ack:
                        # Reverse path: RX -> TX
                        # Note: TX in this sim is "independent" and doesn't process ACKs logic-wise,
                        # but we count them for stats.
                        # Check channel reverse path
                        if self.channel.can_deliver(ack):
                            self.ack_count += 1

            # Advance time
            self.current_time += config.TIME_STEP_US

        return self.get_results()

    def get_results(self):
        success_rate = (self.rx.total_received / self.tx_count) * 100 if self.tx_count > 0 else 0
        avg_recovery = (self.total_downtime / self.recovery_events / 1000) if self.recovery_events > 0 else 0 # ms

        return {
            "scenario": self.scenario,
            "tx_packets": self.tx_count,
            "rx_packets": self.rx.total_received,
            "success_rate": success_rate,
            "max_consecutive_loss": self.rx.max_consecutive_losses,
            "recovery_events": self.recovery_events,
            "avg_recovery_time_ms": avg_recovery
        }

if __name__ == "__main__":
    # Quick test run
    print("Running 10s test...")
    sim = Simulation(scenario="MEDIUM", duration_sec=10)
    res = sim.run()
    print(res)