ক্যাপস্টোন — একটি সম্পূর্ণ এমবেডেড+IoT সিস্টেম সিমুলেট করা

import random

# ---- ADC কোয়ান্টাইজেশন (M5/L20-এর প্যাটার্ন) ----
ADC_BITS = 12
VREF = 3.3
adc_step = VREF / (2 ** ADC_BITS)

def voltage_to_code(v):
    code = round(v / adc_step)
    return max(0, min(code, 2 ** ADC_BITS - 1))

# ---- দুই-বিন্দু ক্যালিব্রেশন (M9/L37-এর প্যাটার্ন) ----
# শুকনো বাতাসে (0% আর্দ্রতা) ও পানিতে ডুবিয়ে (100% আর্দ্রতা) মাপা রেফারেন্স ভোল্টেজ
DRY_VOLTAGE = 2.80   # illustrative
WET_VOLTAGE = 1.20   # illustrative

dry_code = voltage_to_code(DRY_VOLTAGE)
wet_code = voltage_to_code(WET_VOLTAGE)

# moisture_pct = m * code + b -- (dry_code, 0%) ও (wet_code, 100%) বিন্দু দুটি দিয়ে সরলরেখা
calib_m = (100 - 0) / (wet_code - dry_code)
calib_b = 0 - calib_m * dry_code

def code_to_moisture_pct(code):
    return calib_m * code + calib_b

# ---- একটি "প্রকৃত কিন্তু বাস্তবে অজানা" মাটির আর্দ্রতা থেকে নয়েজি সেন্সর রিডিং সিমুলেট ----
true_moisture_pct = 38.0
true_voltage = DRY_VOLTAGE - (true_moisture_pct / 100) * (DRY_VOLTAGE - WET_VOLTAGE)

rng = random.Random(42)
noisy_voltage = rng.gauss(true_voltage, 0.03)   # সেন্সর + ADC নয়েজ, ফিক্সড সিড

raw_code = voltage_to_code(noisy_voltage)
measured_moisture_pct = code_to_moisture_pct(raw_code)

print(f"ADC স্টেপ সাইজ: {adc_step * 1000:.3f} mV ({ADC_BITS}-বিট, Vref={VREF}V)")
print(f"ক্যালিব্রেশন পয়েন্ট: শুকনো={dry_code} কোড (0%), ভেজা={wet_code} কোড (100%)")
print(f"নয়েজি সেন্সর ভোল্টেজ: {noisy_voltage:.3f}V -> raw ADC কোড: {raw_code}")
print(f"ক্যালিব্রেটেড আর্দ্রতা রিডিং: {measured_moisture_pct:.1f}%")

# ---- থ্রেশহোল্ড-ভিত্তিক সিদ্ধান্ত -- ধাপ ১-এর measured_moisture_pct ব্যবহার করে ----
MOISTURE_THRESHOLD_PCT = 40.0
moisture_deficit = max(0.0, MOISTURE_THRESHOLD_PCT - measured_moisture_pct)
pump_should_run = moisture_deficit > 0

SECONDS_PER_PERCENT_DEFICIT = 2.5   # illustrative -- যত বেশি শুকনো, পাম্প তত বেশিক্ষণ চলে
pump_duration_s = round(moisture_deficit * SECONDS_PER_PERCENT_DEFICIT, 1)

# ---- PWM ডিউটি সাইকেল (M5/L19-এর প্যাটার্ন) -- পাম্প ড্রাইভার ৯০% ডিউটিতে চালানো হচ্ছে ----
PUMP_PWM_PERIOD = 100     # রেজোলিউশন: ১০০ ধাপ = ১০০%
PUMP_PWM_DUTY_PCT = 90
pump_pwm_compare = round(PUMP_PWM_PERIOD * PUMP_PWM_DUTY_PCT / 100)

waveform = ['HIGH' if tick < pump_pwm_compare else 'LOW' for tick in range(PUMP_PWM_PERIOD)]
high_ticks = waveform.count('HIGH')
measured_duty_pct = 100 * high_ticks / PUMP_PWM_PERIOD

print(f"পরিমাপকৃত আর্দ্রতা: {measured_moisture_pct:.1f}%, থ্রেশহোল্ড: {MOISTURE_THRESHOLD_PCT}%")
print(f"ঘাটতি (deficit): {moisture_deficit:.2f}% -> পাম্প চালাতে হবে: {pump_should_run}")
print(f"পাম্পের সময়কাল: {pump_duration_s} সেকেন্ড")
print(f"PWM কম্পেয়ার রেজিস্টার: {pump_pwm_compare}/{PUMP_PWM_PERIOD} "
      f"-> সিমুলেটেড ওয়েভফর্মে HIGH টিক: {high_ticks}/{PUMP_PWM_PERIOD} "
      f"= {measured_duty_pct:.0f}% ডিউটি (প্রত্যাশিত {PUMP_PWM_DUTY_PCT}%-এর সাথে মিলছে)")

# ---- I2C start/address/ACK/data/stop সিকোয়েন্স (M6/L24-এর প্যাটার্ন) ----
class I2cBus:
    def __init__(self, devices):
        self.devices = devices   # {address: (name, read_fn)}

    def read_register(self, address, register):
        log = []
        log.append("START")
        addr_write_byte = (address << 1) | 0
        if address not in self.devices:
            log.append(f"ADDRESS 0x{address:02X}+W (0x{addr_write_byte:02X}) -> NACK (ডিভাইস নেই)")
            log.append("STOP (ট্রানজ্যাকশন বাতিল)")
            return None, log

        name, read_fn = self.devices[address]
        log.append(f"ADDRESS 0x{address:02X}+W (0x{addr_write_byte:02X}) -> ACK from {name}")
        log.append(f"DATA 0x{register:02X} (রেজিস্টার পয়েন্টার) -> ACK")
        log.append("REPEATED START")
        addr_read_byte = (address << 1) | 1
        log.append(f"ADDRESS 0x{address:02X}+R (0x{addr_read_byte:02X}) -> ACK from {name}")

        value = read_fn()
        msb = (value >> 8) & 0xFF
        lsb = value & 0xFF
        log.append(f"DATA 0x{msb:02X} (MSB) <- ACK (মাস্টার)")
        log.append(f"DATA 0x{lsb:02X} (LSB) <- NACK (মাস্টার, শেষ বাইট)")
        log.append("STOP")
        return value, log


# একটি সিমুলেটেড I2C ADC ব্রেকআউট (ঠিকানা 0x48-এ) -- ধাপ ১-এর raw_code-ই "রিড" হয়
devices = {0x48: ("soil_moisture_adc", lambda: raw_code)}
bus = I2cBus(devices)

i2c_value, i2c_log = bus.read_register(0x48, 0x00)
print("I2C ট্রানজ্যাকশন (সফল, ডিভাইস আছে):")
for line in i2c_log:
    print(" ", line)
print(f"\nI2C-এর মাধ্যমে পড়া মান: {i2c_value} -- ধাপ ১-এর raw_code ({raw_code})-এর সাথে মিলছে: {i2c_value == raw_code}")

# তুলনার জন্য: একটি ঠিকানায় কোনো ডিভাইস নেই -> NACK
_, nack_log = bus.read_register(0x50, 0x00)
print("\nI2C ট্রানজ্যাকশন (ব্যর্থ, ডিভাইস নেই ঠিকানা 0x50-এ):")
for line in nack_log:
    print(" ", line)

# ---- ছোট প্রায়োরিটি-ভিত্তিক RTOS শিডিউলার (M7/L29-এর প্যাটার্ন) ----
class Task:
    def __init__(self, name, priority, period, work_ticks):
        self.name = name
        self.priority = priority     # ছোট সংখ্যা = উচ্চ প্রায়োরিটি
        self.period = period          # কত টিক পরপর নতুন কাজ আসে
        self.work_ticks = work_ticks  # প্রতিবার কতটা কাজ (টিক) লাগে
        self.remaining = 0

    def release(self, tick):
        if tick % self.period == 0:
            self.remaining += self.work_ticks


tasks = [
    Task("sensor_read", priority=1, period=5, work_ticks=1),       # সর্বোচ্চ প্রায়োরিটি
    Task("pump_control", priority=2, period=5, work_ticks=1),
    Task("network_publish", priority=3, period=10, work_ticks=2),  # সবচেয়ে কম প্রায়োরিটি, বেশি কাজ
]

TOTAL_TICKS = 20
schedule_trace = []
for tick in range(TOTAL_TICKS):
    for t in tasks:
        t.release(tick)
    ready_tasks = [t for t in tasks if t.remaining > 0]
    if ready_tasks:
        ready_tasks.sort(key=lambda t: t.priority)
        running = ready_tasks[0]
        running.remaining -= 1
        schedule_trace.append((tick, running.name))
    else:
        schedule_trace.append((tick, "idle"))

for tick, name in schedule_trace:
    print(f"tick {tick:2d}: {name}")

task_run_counts = {}
for _, name in schedule_trace:
    task_run_counts[name] = task_run_counts.get(name, 0) + 1
print(f"\n{TOTAL_TICKS} টিকে মোট রান-কাউন্ট: {task_run_counts}")

# ---- ইন-মেমরি MQTT ব্রোকার, সত্যিকারের ওয়াইল্ডকার্ড ম্যাচিংসহ (M11/L46-এর প্যাটার্ন) ----
class MqttBroker:
    def __init__(self):
        self.subscriptions = []   # [(client, topic_filter), ...]

    def subscribe(self, client, topic_filter):
        self.subscriptions.append((client, topic_filter))

    @staticmethod
    def topic_matches(topic_filter, topic):
        filter_levels = topic_filter.split('/')
        topic_levels = topic.split('/')
        for i, flevel in enumerate(filter_levels):
            if flevel == '#':
                return True                       # '#' বাকি সব লেভেল ম্যাচ করে
            if i >= len(topic_levels):
                return False
            if flevel == '+':
                continue                            # '+' ঠিক এক লেভেল ম্যাচ করে
            if flevel != topic_levels[i]:
                return False
        return len(filter_levels) == len(topic_levels)

    def publish(self, topic, payload):
        delivered_to = []
        for client, topic_filter in self.subscriptions:
            if self.topic_matches(topic_filter, topic):
                delivered_to.append(client)
        return delivered_to


broker = MqttBroker()
broker.subscribe("dashboard_bed1", "farm/bed1/#")   # আমাদের ডিভাইসের বেড সাবস্ক্রাইব করছে
broker.subscribe("dashboard_bed2", "farm/bed2/#")   # ভিন্ন বেডের ড্যাশবোর্ড -- ম্যাচ করা উচিত নয়

moisture_topic = "farm/bed1/moisture"
pump_topic = "farm/bed1/pump"
moisture_payload = f"{measured_moisture_pct:.1f}"
pump_payload = f"ran={pump_should_run},duration_s={pump_duration_s}"

delivered_moisture = broker.publish(moisture_topic, moisture_payload)
delivered_pump = broker.publish(pump_topic, pump_payload)

mqtt_delivered = ("dashboard_bed1" in delivered_moisture) and ("dashboard_bed1" in delivered_pump)

print(f"PUBLISH {moisture_topic} = '{moisture_payload}' -> ডেলিভার হলো: {delivered_moisture}")
print(f"PUBLISH {pump_topic} = '{pump_payload}' -> ডেলিভার হলো: {delivered_pump}")
print(f"'dashboard_bed2' ম্যাচ করেনি (ভিন্ন বেড) -- প্রমাণ করে ম্যাচিং হার্ডকোড নয়, সত্যিকারের ফিল্টার লজিক")
print(f"\nমোট MQTT ডেলিভারি সফল (dashboard_bed1-এ উভয় বার্তা): {mqtt_delivered}")

# ---- সম্মিলিত ব্যাটারি-লাইফ গণনা (M8/L34-এর প্যাটার্ন) -- আগের ধাপগুলোর ফলাফল ব্যবহার করে ----
CYCLE_PERIOD_S = 600   # প্রতি ১০ মিনিটে একবার সম্পূর্ণ চক্র (সেন্সর + সিদ্ধান্ত + প্রয়োজনে পাম্প + পাবলিশ)

sensor_active_s = 0.02      # ADC রিড + ধাপ ৩-এর I2C ট্রানজ্যাকশন সময়
sensor_active_mA = 15

pump_current_mA = 200                       # পাম্প মোটরের ফুল-পাওয়ার কারেন্ট (illustrative)
pump_duty_fraction = PUMP_PWM_DUTY_PCT / 100   # ধাপ ২-এর PWM ডিউটি সাইকেল
pump_active_s = pump_duration_s if pump_should_run else 0   # ধাপ ২-এর প্রকৃত ফলাফল
pump_avg_current_during_run_mA = pump_current_mA * pump_duty_fraction

publish_active_s = 1.5     # ধাপ ৫-এর WiFi+MQTT পাবলিশ সময়
publish_mA = 120

sleep_mA = 0.01             # বাকি সময় ডিপ-স্লিপে (M8-এর লো-পাওয়ার মোড)

active_time_used_s = sensor_active_s + pump_active_s + publish_active_s
sleep_time_s = CYCLE_PERIOD_S - active_time_used_s

charge_per_cycle_mA_s = (
    sensor_active_mA * sensor_active_s
    + pump_avg_current_during_run_mA * pump_active_s
    + publish_mA * publish_active_s
    + sleep_mA * sleep_time_s
)
average_current_mA = charge_per_cycle_mA_s / CYCLE_PERIOD_S

BATTERY_CAPACITY_MAH = 3000   # একটি ছোট 18650-জাতীয় Li-ion প্যাক (illustrative)
battery_life_hours = BATTERY_CAPACITY_MAH / average_current_mA
battery_life_days = battery_life_hours / 24

print(f"চক্র প্রতি সক্রিয় সময়: সেন্সর {sensor_active_s}s + পাম্প {pump_active_s}s + পাবলিশ {publish_active_s}s "
      f"= {active_time_used_s:.2f}s (ডিপ-স্লিপ: {sleep_time_s:.2f}s)")
print(f"গড় কারেন্ট ড্র: {average_current_mA:.3f} mA")
print(f"ব্যাটারি ক্যাপাসিটি: {BATTERY_CAPACITY_MAH} mAh")
print(f"আনুমানিক ব্যাটারি-লাইফ: {battery_life_hours:.1f} ঘণ্টা = {battery_life_days:.1f} দিন")

# ---- চূড়ান্ত সারাংশ -- ধাপ ১-৬-এর প্রকৃত গণনা করা ফলাফল থেকে তৈরি, হার্ডকোডেড নয় ----
print("===== স্মার্ট প্ল্যান্ট-ওয়াটারিং কন্ট্রোলার -- চক্র সারাংশ =====")
print(f"মাটির আর্দ্রতা রিডিং: {measured_moisture_pct:.1f}% (I2C-এর মাধ্যমে যাচাই করা কোড: {i2c_value})")
print(f"পাম্প চালানো হয়েছে: {'হ্যাঁ' if pump_should_run else 'না'}, সময়কাল: {pump_active_s:.1f} সেকেন্ড "
      f"({measured_duty_pct:.0f}% PWM ডিউটিতে)")
print(f"RTOS শিডিউলার: {TOTAL_TICKS} টিকে sensor_read={task_run_counts.get('sensor_read', 0)}, "
      f"pump_control={task_run_counts.get('pump_control', 0)}, "
      f"network_publish={task_run_counts.get('network_publish', 0)} বার চলেছে")
print(f"MQTT বার্তা ডেলিভার হয়েছে dashboard_bed1-এ: {mqtt_delivered}")
print(f"আনুমানিক ব্যাটারি-লাইফ: {battery_life_days:.1f} দিন "
      f"(গড় কারেন্ট {average_current_mA:.3f} mA, ক্যাপাসিটি {BATTERY_CAPACITY_MAH} mAh)")
print("=" * 55)