Upload 2 files

pages/2_⚙️_Hardware.py

@@ -0,0 +1,712 @@
+import streamlit as st
+import pandas as pd
+import math
+import json
+import os
+from io import BytesIO
+
+st.set_page_config(page_title="Расчет потребления", layout="wide")
+
+DB_FILE = "equipment_db.json"
+
+
+# ==================== ФУНКЦИИ БАЗЫ ДАННЫХ ====================
+def load_db():
+    if os.path.exists(DB_FILE):
+        try:
+            with open(DB_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except:
+            return []
+    return []
+
+
+def save_db(data):
+    with open(DB_FILE, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=4)
+
+
+# ==================== БОКОВАЯ ПАНЕЛЬ ====================
+with st.sidebar:
+    st.header("📂 База данных")
+    uploaded_file = st.file_uploader("Импорт Excel", type=["xlsx", "xls"])
+    if uploaded_file:
+        try:
+            df_import = pd.read_excel(uploaded_file, header=None)
+            df_import.columns = [f"Колонка {i}" for i in range(len(df_import.columns))]
+            col_target = st.selectbox("В какой колонке данные?", options=df_import.columns)
+            if st.button("📥 Разбить текст и загрузить", type="primary"):
+                current_db = load_db()
+                existing_map = {item["article"]: item["power"] for item in current_db}
+                new_items = []
+                count_ok = 0
+                for index, row in df_import.iterrows():
+                    raw_text = str(row[col_target]).strip()
+                    if not raw_text or raw_text.lower() == "nan": continue
+                    parts = raw_text.rsplit(' ', 1)
+                    if len(parts) == 2:
+                        name = parts[0].strip()
+                        article = parts[1].strip()
+                    else:
+                        name = raw_text
+                        article = "-"
+                    power = existing_map.get(article, 0.0)
+                    new_items.append({"name": name, "article": article, "power": power})
+                    count_ok += 1
+                final_db_map = {item["article"]: item for item in current_db}
+                for item in new_items: final_db_map[item["article"]] = item
+                save_db(list(final_db_map.values()))
+                st.success(f"Готово! Обработано строк: {count_ok}.")
+        except Exception as e:
+            st.error(f"Ошибка: {e}")
+
+# ==================== ОСНОВНОЙ КОД ====================
+raw_cabinet = st.session_state.get("cabinet_final", "")
+cabinet_label = raw_cabinet if raw_cabinet else "Общий_шкаф"
+st.title(f"⚡ Расчет потребления: {cabinet_label}")
+
+# --- ИНИЦИАЛИЗАЦИЯ И РАСЧЕТ МОДУЛЕЙ ---
+if "manual_signals_counts" in st.session_state:
+    manual = st.session_state['manual_signals_counts']
+    init_rs, init_eth = manual.get("RS-485", 0), manual.get("ETH", 0)
+    init_ti, init_ts = manual.get("AI (TI)", 0), manual.get("DI (TS)", 0)
+    init_tu, init_tr = manual.get("DO (TU)", 0), manual.get("TR (AO)", 0)
+    init_reserve = st.session_state.get("reserve_val", 20)
+    st.toast("✅ Загружены данные с учетом ручной коррекции!", icon="✏️")
+elif "res_list" in st.session_state and st.session_state.res_list:
+    init_rs = sum(r.counts.RS485 for r in st.session_state.res_list)
+    init_eth = sum(r.counts.ETH for r in st.session_state.res_list)
+    init_ti = sum(r.counts.TI for r in st.session_state.res_list)
+    init_ts = sum(r.counts.TS for r in st.session_state.res_list)
+    init_tu = sum(r.counts.TU for r in st.session_state.res_list)
+    init_tr = sum(r.counts.AO for r in st.session_state.res_list)
+    init_reserve = st.session_state.get("reserve_val", 20)
+else:
+    init_rs, init_eth, init_ti, init_ts, init_tu, init_tr = 12, 2, 42, 102, 51, 0
+    init_reserve = 20
+
+with st.expander("🛠 Настройки модулей (Канальность)", expanded=False):
+    c1, c2 = st.columns(2)
+    ti_ch = c1.number_input("Каналов ТИ", value=32)
+    ts_ch = c2.number_input("Каналов ТС", value=32)
+    tu_ch = c1.number_input("Каналов ТУ", value=32)
+    tr_ch = c2.number_input("Каналов TR", value=8)
+    rs_ch = c1.number_input("Каналов RS", value=8)
+
+st.subheader("1. Сигналы")
+col_l, col_r = st.columns([3, 1])
+with col_r:
+    st.write("###")
+    reserve_pct = st.number_input("Резерв %", value=init_reserve, step=5)
+with col_l:
+    signals_data = [
+        {"Тип": "RS-485", "Факт": init_rs}, {"Тип": "ETH", "Факт": init_eth},
+        {"Тип": "TI (AI)", "Факт": init_ti}, {"Тип": "TS (DI)", "Факт": init_ts},
+        {"Тип": "TU (DO)", "Факт": init_tu}, {"Тип": "TR (AO)", "Факт": init_tr},
+    ]
+    for item in signals_data:
+        item["Итого (с резервом)"] = math.ceil(item["Факт"] * (1 + reserve_pct / 100))
+    edited_signals = st.data_editor(pd.DataFrame(signals_data), hide_index=True, key="sig_edit")
+
+final_signals = {row["Тип"]: row["Итого (с резервом)"] for _, row in edited_signals.iterrows()}
+q_ti = math.ceil(final_signals.get("TI (AI)", 0) / ti_ch) if ti_ch else 0
+q_ts = math.ceil(final_signals.get("TS (DI)", 0) / ts_ch) if ts_ch else 0
+q_tu = math.ceil(final_signals.get("TU (DO)", 0) / tu_ch) if tu_ch else 0
+q_tr = math.ceil(final_signals.get("TR (AO)", 0) / tr_ch) if tr_ch else 0
+q_rs = math.ceil(final_signals.get("RS-485", 0) / rs_ch) if rs_ch else 0
+total_io = q_ti + q_ts + q_tu + q_tr + q_rs
+designation_io = f"A12...A{11 + total_io}" if total_io > 0 else ""
+
+# ==================== ТАБЛИЦА ОБОРУДОВАНИЯ ====================
+st.subheader("2. Спецификация оборудования")
+
+current_project_id = st.session_state.get("last_filename", "")
+saved_project_id = st.session_state.get("equip_rows_source_id", "")
+
+if current_project_id != saved_project_id:
+    if "equip_rows" in st.session_state:
+        del st.session_state["equip_rows"]
+    st.session_state["equip_rows_source_id"] = current_project_id
+    st.toast("🔄 Таблица оборудования сброшена для нового проекта!", icon="🆕")
+
+# --- ИНИЦИАЛИЗАЦИЯ ---
+if "equip_rows" not in st.session_state or len(st.session_state.equip_rows) == 0:
+    st.session_state.equip_rows = [
+        {"Потребитель": "ПЛК (Master)", "Артикул": "ПР (Р02)", "P_шт": 3.0, "Q_внутр": 1, "Q_внешн": 0, "Q_спец": 0,
+         "Q_220": 0, "Коэф.": 1.0, "Это БП?": False, "ups": False, "input2": False},
+        {"Потребитель": "Блок питания осн.", "Артикул": "БП (Р01)", "P_шт": 2.0, "Q_внутр": 1, "Q_внешн": 0,
+         "Q_спец": 0, "Q_220": 0, "Коэф.": 1.0, "Это БП?": True, "ups": False, "input2": False},
+        {"Потребитель": "Модули ввода-вывода", "Артикул": designation_io, "P_шт": 3.0, "Q_внутр": total_io,
+         "Q_внешн": 0, "Q_спец": 0, "Q_220": 0, "Коэф.": 1.0, "Это БП?": False, "ups": False, "input2": False},
+        {"Потребитель": "Вентилятор", "Артикул": "NLV-2600", "P_шт": 50.0, "Q_внутр": 0, "Q_внешн": 0, "Q_спец": 0,
+         "Q_220": 1, "Коэф.": 1.0, "Это БП?": False, "ups": False, "input2": False},
+        {"Потребитель": "Светильник", "Артикул": "ДБО 3001", "P_шт": 4.0, "Q_внутр": 0, "Q_внешн": 0, "Q_спец": 0,
+         "Q_220": 1, "Коэф.": 1.0, "Это БП?": False, "ups": False, "input2": False},
+        {"Потребитель": "Розетка пользователя", "Артикул": "18012DEK", "P_шт": 0.0, "Q_внутр": 0, "Q_внешн": 0,
+         "Q_спец": 0, "Q_220": 1, "Коэф.": 1.0, "Это БП?": False, "ups": False, "input2": False},
+    ]
+
+# === НАСТРОЙКА ТАБЛИЦЫ ===
+has_input2_flag = st.session_state.get("has_input2", False)
+
+for r in st.session_state.equip_rows:
+    if "input2" not in r: r["input2"] = False
+    if "Q_спец" not in r: r["Q_спец"] = 0
+
+df_to_edit = pd.DataFrame(st.session_state.equip_rows)
+
+try:
+    df_to_edit = df_to_edit.astype({
+        "P_шт": "float", "Q_внутр": "int", "Q_внешн": "int", "Q_спец": "int", "Q_220": "int",
+        "Коэф.": "float", "Это БП?": "bool", "ups": "bool", "input2": "bool"
+    })
+except Exception:
+    pass
+
+my_column_config = {
+    "Потребитель": st.column_config.TextColumn(required=True, width="medium"),
+    "P_шт": st.column_config.NumberColumn("P_1шт (Вт)", format="%.2f", width="small"),
+    "Q_внутр": st.column_config.NumberColumn("Q (Внутр)", min_value=0, step=1, help="Нагрузка 24В (Логика)"),
+    "Q_внешн": st.column_config.NumberColumn("Q (Внешн)", min_value=0, step=1, help="Нагрузка 24В (Датчики)"),
+    "Q_спец": st.column_config.NumberColumn("Q (Доп.)", min_value=0, step=1, help="Нагрузка 12В"),
+    "Q_220": st.column_config.NumberColumn("Q (220В)", min_value=0, step=1),
+    "Коэф.": st.column_config.NumberColumn("К спр.", step=0.05, format="%.2f", width="small"),
+    "Это БП?": st.column_config.CheckboxColumn("Это БП?", help="Источник Питания"),
+    "ups": st.column_config.CheckboxColumn("На ИБП?", help="Питается от ИБП"),
+}
+my_column_order = ["Потребитель", "Артикул", "P_шт", "Q_внутр", "Q_внешн", "Q_спец", "Q_220", "Коэф.", "Это БП?", "ups"]
+
+if has_input2_flag:
+    my_column_config["input2"] = st.column_config.CheckboxColumn("На ��вод 2?", help="Питается от резерва")
+    my_column_order.append("input2")
+
+st.info(
+    "ℹ️ Потребление Блоков Питания (DC) добавляется к ОБОИМ вводам (резервирование). Потребители 220В распределяются по галочке 'На Ввод 2'.")
+edited_equip = st.data_editor(
+    df_to_edit,
+    num_rows="dynamic",
+    use_container_width=True,
+    column_config=my_column_config,
+    column_order=my_column_order,
+    key="equip_editor"
+)
+
+st.session_state.equip_rows = edited_equip.to_dict('records')
+
+col_save, _ = st.columns([1, 4])
+with col_save:
+    if st.button("💾 Сохранить устройство в db"):
+        current_db = load_db()
+        db_map = {(str(i.get("article", "")), str(i.get("name", ""))): i for i in current_db}
+        upd = 0
+        for _, row in edited_equip.iterrows():
+            name = str(row.get("Потребитель", "")).strip()
+            art = str(row.get("Артикул", "")).strip()
+            if not name: continue
+            try:
+                p_val = float(row.get("P_шт", 0))
+            except:
+                p_val = 0.0
+
+            key = (art, name)
+            new_item = {"name": name, "article": art, "power": p_val}
+
+            if key not in db_map or db_map[key]["power"] != p_val:
+                db_map[key] = new_item
+                upd += 1
+
+        if upd > 0:
+            save_db(list(db_map.values()))
+            st.toast(f"✅ Успешно! Обновлено: {upd} записей.")
+        else:
+            st.toast("Нет изменений для сохранения.")
+
+# Меню добавления
+with st.container():
+    db_data = load_db()
+    db_options = {f"{i['name']} ({i['article']}) — {i['power']}Вт": i for i in db_data}
+    c_a1, c_a2, c_a3 = st.columns([3, 1, 1])
+    sel_key = c_a1.selectbox("Поиск по базе:", [""] + list(db_options.keys()))
+    add_qty = c_a2.number_input("Кол-во", 1, value=1)
+    if c_a3.button("➕ Добавить") and sel_key:
+        item = db_options[sel_key]
+        nm_low = item["name"].lower()
+        is_psu = any(x in nm_low for x in ["ип ", "бп ", "питания"])
+        q_in, q_ext, q_sp, q_220 = 0, 0, 0, 0
+        if "вентилятор" in nm_low or "свет" in nm_low or "220" in nm_low or "розетка" in nm_low:
+            q_220 = add_qty
+        elif "датчик" in nm_low:
+            q_ext = add_qty
+        elif "12в" in nm_low or "tk16" in item.get("article", "").lower():
+            q_sp = add_qty
+        else:
+            q_in = add_qty
+
+        new_row = {
+            "Потребитель": item["name"], "Артикул": item["article"], "P_шт": float(item["power"]),
+            "Q_внутр": int(q_in), "Q_внешн": int(q_ext), "Q_спец": int(q_sp), "Q_220": int(q_220),
+            "Коэф.": 1.0, "Это БП?": is_psu, "ups": False, "input2": False
+        }
+        st.session_state.equip_rows.append(new_row)
+        st.rerun()
+
+st.divider()
+
+
+# ==================== ЛОГИКА РАСЧЕТА ====================
+def safe_float(val):
+    try:
+        return float(val) if val is not None else 0.0
+    except:
+        return 0.0
+
+
+col_eff, _ = st.columns([1, 3])
+with col_eff:
+    efficiency = st.number_input("КПД Источников Питания (AC/DC)", min_value=0.5, max_value=1.0, value=0.92, step=0.01)
+
+# Списки для суммирования
+loads = {"Internal": 0.0, "External": 0.0, "Special": 0.0, "Mains": 0.0}
+ups_groups_map = {"Internal": False, "External": False, "Special": False}
+direct_ups_load_220 = 0.0
+non_critical_220 = 0.0
+
+mains_220_in1 = 0.0
+mains_220_in2 = 0.0
+
+psu_export_list = []
+custom_220_list = []
+
+# --- 1. ПЕРВЫЙ ПРОХОД: Считаем нагрузки (DC) и распределяем 220В ---
+dc_loads_total = {"Internal": 0.0, "External": 0.0, "Special": 0.0}
+
+for _, row in edited_equip.iterrows():
+    is_psu = row.get("Это БП?", False)
+    if is_psu: continue
+
+    p_unit = safe_float(row.get("P_шт"))
+    k_coef = safe_float(row.get("Коэф.")) or 1.0
+
+    # --- DC Нагрузка ---
+    val_in = p_unit * safe_float(row.get("Q_внутр")) * k_coef
+    val_ex = p_unit * safe_float(row.get("Q_внешн")) * k_coef
+    val_sp = p_unit * safe_float(row.get("Q_спец")) * k_coef
+
+    dc_loads_total["Internal"] += val_in
+    dc_loads_total["External"] += val_ex
+    dc_loads_total["Special"] += val_sp
+
+    loads["Internal"] += val_in
+    loads["External"] += val_ex
+    loads["Special"] += val_sp
+
+    # --- AC Нагрузка ---
+    q_220 = safe_float(row.get("Q_220"))
+    if q_220 > 0:
+        p_ac = p_unit * q_220 * k_coef
+        loads["Mains"] += p_ac
+
+        is_in2 = row.get("input2", False)
+        if is_in2:
+            mains_220_in2 += p_ac
+        else:
+            mains_220_in1 += p_ac
+
+        if row.get("ups", False):
+            direct_ups_load_220 += p_ac
+        else:
+            non_critical_220 += p_ac
+
+        custom_220_list.append({
+            "name": str(row.get("Потребитель", "")),
+            "power": p_ac,
+            "on_ups": row.get("ups", False),
+            "input_id": 2 if is_in2 else 1
+        })
+
+# --- 2. РАСЧЕТ ИТОГОВОГО ПОТРЕБЛЕНИЯ ---
+total_dc_watts = dc_loads_total["Internal"] + dc_loads_total["External"] + dc_loads_total["Special"]
+psu_ac_consumption_total = total_dc_watts / efficiency if efficiency > 0 else 0
+
+watts_input_1 = mains_220_in1 + psu_ac_consumption_total
+watts_input_2 = mains_220_in2 + psu_ac_consumption_total if has_input2_flag else 0
+
+# --- 3. ВТОРОЙ ПРОХОД: Формируем список БП ---
+for _, row in edited_equip.iterrows():
+    if not row.get("Это БП?", False): continue
+
+    original_name = str(row.get("Потребитель", ""))
+    article_name = str(row.get("Артикул", ""))
+    is_in2 = row.get("input2", False)
+    on_ups = row.get("ups", False)
+
+    has_in = safe_float(row.get("Q_внутр")) > 0
+    has_ex = safe_float(row.get("Q_внешн")) > 0
+    has_sp = safe_float(row.get("Q_спец")) > 0
+
+    # ФОРМИРУЕМ ИМЯ
+    if has_sp:
+        export_name = "Питание терминального контроллера"
+    elif has_in and has_ex:
+        export_name = "Питание внутренних и внешних цепей шкафа"
+    elif has_ex:
+        export_name = "Питание внешних потребителей"
+    elif has_in:
+        export_name = "Питание внутренних цепей шкафа"
+    else:
+        # Если БП без нагрузки - добавляем артикул к имени для ясности
+        if article_name and article_name != "-":
+            export_name = f"{original_name} ({article_name})"
+        else:
+            export_name = original_name
+
+    current_psu_dc_load = 0.0
+    if has_in: current_psu_dc_load += dc_loads_total["Internal"]
+    if has_ex: current_psu_dc_load += dc_loads_total["External"]
+    if has_sp: current_psu_dc_load += dc_loads_total["Special"]
+
+    if on_ups:
+        if has_in: ups_groups_map["Internal"] = True
+        if has_ex: ups_groups_map["External"] = True
+        if has_sp: ups_groups_map["Special"] = True
+
+    volts = 12 if has_sp else 24
+
+    psu_export_list.append({
+        "name": export_name,
+        "dc_power": current_psu_dc_load,
+        "voltage_dc": volts,
+        "ac_power": 0,
+        "on_ups": on_ups,
+        "input_id": 2 if is_in2 else 1
+    })
+
+# --- ВЫВОД РЕЗУЛЬТАТОВ ---
+st.subheader("3. Расчет нагрузки по группам (DC)")
+c1, c2, c3, c4 = st.columns(4)
+c1.metric("Внутр (24В)", f"{loads['Internal']:.1f} Вт", delta="На ИБП" if ups_groups_map["Internal"] else "Мимо ИБП")
+c2.metric("Внешн (24В)", f"{loads['External']:.1f} Вт", delta="На ИБП" if ups_groups_map["External"] else "Мимо ИБП")
+c3.metric("Спец (12В)", f"{loads['Special']:.1f} Вт", delta="На ИБП" if ups_groups_map["Special"] else "Мимо ИБП")
+c4.metric("Сеть (220В)", f"{loads['Mains']:.1f} Вт", f"UPS: {direct_ups_load_220:.1f} | Grid: {non_critical_220:.1f}")
+
+# === БЛОК: Скачивание спецификации + ИТОГИ ===
+
+st.write("###")  # Отступ
+if st.session_state.equip_rows:
+    # 1. Готовим данные таблицы
+    df_spec = pd.DataFrame(st.session_state.equip_rows).copy()
+
+    # Считаем общее кол-во и мощность
+    df_spec["Всего_шт"] = (df_spec.get("Q_внутр", 0) + df_spec.get("Q_внешн", 0) +
+                           df_spec.get("Q_спец", 0) + df_spec.get("Q_220", 0))
+    df_spec["P_общ (Вт)"] = df_spec["P_шт"] * df_spec["Всего_шт"] * df_spec["Коэф."]
+
+    # --- ЗАМЕНА TRUE/FALSE НА ГАЛОЧКИ ---
+    bool_cols = ["Это БП?", "ups", "input2"]
+    for col in bool_cols:
+        if col in df_spec.columns:
+            df_spec[col] = df_spec[col].map({True: "✔", False: ""})
+
+    # Настройка названий
+    cols_export = {
+        "Потребитель": "Наименование",
+        "Артикул": "Артикул",
+        "P_шт": "P_ед (Вт)",
+        "Всего_шт": "Кол-во",
+        "P_общ (Вт)": "P_итог (Вт)",
+        "Q_внутр": "Внутр (24В)",
+        "Q_внешн": "Внешн (24В)",
+        "Q_спец": "Спец",
+        "Q_220": "220В",
+        "Это БП?": "Блок Питания",
+        "ups": "На ИБП",
+        "input2": "На Ввод 2"
+    }
+
+    available_cols = [c for c in cols_export.keys() if c in df_spec.columns]
+    df_final = df_spec[available_cols].rename(columns=cols_export)
+
+    # 2. Подготовка данных для ИТОГОВ
+    # Используем переменные loads и efficiency, которые уже посчитаны выше в коде
+    val_in = loads['Internal']
+    val_ex = loads['External']
+    val_psu_in = val_in / efficiency if efficiency > 0 else 0
+    val_psu_ex = val_ex / efficiency if efficiency > 0 else 0
+
+    # Общая мощность (220В + вся DC через КПД)
+    val_total_cab = loads['Mains'] + (loads['Internal'] + loads['External'] + loads['Special']) / efficiency
+
+    summary_data = [
+        ["--- ИТОГИ ---", ""],
+        ["Нагрузка Внутр (24В)", round(val_in, 2)],
+        ["Нагрузка Внешн (24В)", round(val_ex, 2)],
+        [f"Потребление БП Внутр (КПД {efficiency})", round(val_psu_in, 2)],
+        [f"Потребление БП Внешн (КПД {efficiency})", round(val_psu_ex, 2)],
+        ["ОБЩИЙ ВВОД 220В", round(val_total_cab, 2)]
+    ]
+
+    # 3. Создаем Excel
+    bio_spec = BytesIO()
+    with pd.ExcelWriter(bio_spec, engine='openpyxl') as writer:
+        # Записываем основную таблицу
+        df_final.to_excel(writer, index=False, sheet_name="Спецификация")
+
+        ws = writer.sheets["Спецификация"]
+        from openpyxl.styles import Alignment, Font
+
+        # Настройка ширины
+        ws.column_dimensions['A'].width = 40
+        ws.column_dimensions['B'].width = 20
+
+        # Центрируем галочки
+        for row in ws.iter_rows(min_row=2, max_row=len(df_final) + 1):
+            for cell in row:
+                if cell.column > 2:
+                    cell.alignment = Alignment(horizontal='center')
+
+        # --- ДОПИСЫВАЕМ ИТОГИ ВНИЗУ ---
+        start_row = len(df_final) + 3  # Отступаем 2 строки вниз
+
+        for i, (label, value) in enumerate(summary_data):
+            current_row = start_row + i
+
+            # Пишем название в колонку A
+            cell_name = ws.cell(row=current_row, column=1, value=label)
+            cell_name.font = Font(bold=True)
+
+            # Пишем значение в колонку E (P_итог) - чтобы было наглядно
+            # Колонка E это 5-я по счету
+            ws.cell(row=current_row, column=5, value=value)
+
+    # 4. Кнопка
+    st.download_button(
+        label="📥 Скачать спецификацию оборудования (.xlsx)",
+        data=bio_spec.getvalue(),
+        file_name=f"Spec_{cabinet_label}.xlsx",
+        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    )
+# ===========================================
+st.markdown("---")
+
+# ==================== БЛОК РАСЧЕТА ИБП ====================
+# 1. Инициализация переменных (чтобы не было ошибки NameError)
+ups_dc_demand = 0.0
+ups_charge_power = 0.0
+ups_input_normal = 0.0
+ups_input_max = 0.0
+
+
+
+# 2. Сбор нагрузки по группам
+if ups_groups_map["Internal"]: ups_dc_demand += loads["Internal"]
+if ups_groups_map["External"]: ups_dc_demand += loads["External"]
+if ups_groups_map["Special"]:  ups_dc_demand += loads["Special"]
+
+ups_load_from_psus = ups_dc_demand / efficiency if efficiency > 0 else 0
+ups_inverter_load = direct_ups_load_220 + ups_load_from_psus
+
+# 3. ЕСЛИ ЕСТЬ НАГРУЗКА -> РАСЧЕТ
+ups_vars = {
+    "t_req": 0, "u_sys": 0, "eff": 0, "k_temp": 0, "k_depth": 0,
+    "c_req": 0, "c_act": 0, "bat_qty": 0, "bat_nom": 0,
+    "t_fact_str": "", "p_norm": 0, "p_charge": 0, "p_max": 0
+}
+
+if ups_inverter_load > 0:
+    st.subheader("4. Подробный расчет ИБП и АКБ")
+    st.markdown("#### А. Определение нагрузки на инвертор")
+    st.latex(r"P_{Inv} = P_{220(UPS)} + \frac{P_{DC(UPS)}}{\eta_{PSU}}")
+    st.info(f"⚡ **Расчетная нагрузка на инвертор:** {ups_inverter_load:.2f} Вт")
+
+    # Ввод параметров
+    c_u1, c_u2, c_u3 = st.columns(3)
+    t_autonomy_req = c_u1.number_input("Время автономии (мин)", value=60, step=10)
+    u_bat_sys = c_u2.selectbox("Напряжение АКБ (U_sys)", [12, 24, 36, 48, 72, 96], index=2)
+    k_inv_eff = c_u3.number_input("КПД ИБП (Inv)", 0.8, 1.0, 0.90, step=0.01)
+
+    with st.expander("Коэф. АКБ", expanded=False):
+        c_k1, c_k2 = st.columns(2)
+        k_temp = c_k1.number_input("K_temp", 1.0, 1.5, 1.2)
+        k_depth = c_k2.number_input("K_depth", 0.5, 1.0, 0.7)
+
+    # 1. Расчет требуемой емкости
+    hours_req = t_autonomy_req / 60
+    st.markdown("**1. Рас��ет требуемой емкости:**")
+    st.latex(r"C_{req} = \frac{P_{Inv} \times T_{hours} \times K_{temp}}{U_{sys} \times \eta_{Inv} \times K_{depth}}")
+    capacity_needed = (ups_inverter_load * hours_req * k_temp) / (u_bat_sys * k_inv_eff * k_depth)
+    st.write(f"📉 Требуемая емкость: **{capacity_needed:.2f} Ач**")
+
+    col_b1, col_b2 = st.columns(2)
+    with col_b1:
+        st.write("**2. Выбор батарей:**")
+        bat_nominal = st.selectbox("Номинал АКБ (Ач)", [4.5, 5, 7, 9, 12, 17, 26, 40, 55, 100], index=3)
+        series_qty = int(u_bat_sys / 12)
+        parallel_qty = math.ceil(capacity_needed / bat_nominal)
+        total_bat_qty = series_qty * parallel_qty
+        actual_capacity_system = parallel_qty * bat_nominal
+
+        st.success(
+            f"🔋 Конфигурация: {total_bat_qty} шт. ({series_qty} послед. x {parallel_qty} паралл.) = {actual_capacity_system} Ач")
+
+        if st.button("➕ Добавить ИБП и АКБ в таблицу"):
+            st.session_state.equip_rows.append(
+                {"Потребитель": f"ИБП (Вх. макс)", "Артикул": "UPS", "P_шт": 0.0, "Q_внутр": 0, "Q_внешн": 0,
+                 "Q_спец": 0, "Q_220": 1, "Коэф.": 1.0, "Это БП?": False, "ups": False, "input2": False})
+            st.session_state.equip_rows.append(
+                {"Потребитель": f"АКБ 12В {bat_nominal}Ач", "Артикул": "BAT", "P_шт": 0.0, "Q_внутр": 0, "Q_внешн": 0,
+                 "Q_спец": 0, "Q_220": total_bat_qty, "Коэф.": 1.0, "Это БП?": False, "ups": False, "input2": False})
+            st.rerun()
+
+    with col_b2:
+        st.write("**3. Энергобаланс:**")
+        ups_input_normal = ups_inverter_load / k_inv_eff
+        charge_current = actual_capacity_system * 0.15
+        ups_charge_power = (u_bat_sys * charge_current) / 0.85
+        ups_input_max = ups_input_normal + ups_charge_power
+
+        st.latex(r"P_{Charge} = \frac{U_{sys} \times C_{act} \times 0.15}{0.85}")
+        st.write(f"Мощность заряда: **{ups_charge_power:.2f} Вт**")
+
+        # Расчет фактического времени (для Excel)
+        t_fact_hours = (actual_capacity_system * u_bat_sys * k_inv_eff * k_depth) / (ups_inverter_load * k_temp)
+        h_disp = int(t_fact_hours)
+        m_disp = int((t_fact_hours - h_disp) * 60)
+        t_fact_str = f"{h_disp}ч {m_disp}мин"
+        st.caption(f"Фактическое время автономии: {t_fact_str}")
+
+        # Сохраняем данные для Excel
+        ups_vars = {
+            "t_req": t_autonomy_req, "u_sys": u_bat_sys, "eff": k_inv_eff,
+            "k_temp": k_temp, "k_depth": k_depth,
+            "c_req": capacity_needed, "c_act": actual_capacity_system,
+            "bat_qty": total_bat_qty, "bat_nom": bat_nominal,
+            "t_fact_str": t_fact_str,
+            "p_norm": ups_input_normal, "p_charge": ups_charge_power, "p_max": ups_input_max
+        }
+else:
+    st.info("Нет нагрузки на ИБП.")
+
+st.divider()
+st.subheader("5. Итоговое потребление (Вводные автоматы)")
+
+final_cabinet_max = watts_input_1 + ups_charge_power
+
+c_fin1, c_fin2 = st.columns(2)
+with c_fin1:
+    st.write(f"### Ввод 1 (Основной)")
+    st.latex(r"P_{In1} = \sum P_{220(In1)} + P_{PSU(Total)}")
+    st.write(f"= {mains_220_in1:.2f} + {psu_ac_consumption_total:.2f}")
+    st.success(f"Рабочий ток: **{watts_input_1:.2f} Вт**")
+    if ups_charge_power > 0:
+        st.warning(f"Макс. (с зарядом АКБ): **{final_cabinet_max:.2f} Вт**")
+
+with c_fin2:
+    if has_input2_flag:
+        st.write(f"### Ввод 2 (Резерв)")
+        st.latex(r"P_{In2} = \sum P_{220(In2)} + P_{PSU(Total)}")
+        st.write(f"= {mains_220_in2:.2f} + {psu_ac_consumption_total:.2f}")
+        st.success(f"Рабочий ток: **{watts_input_2:.2f} Вт**")
+    else:
+        st.caption("Ввод 2 не используется")
+
+# Сохранение данных для файла 3
+st.session_state['summary_data'] = {
+    "total_input_1": watts_input_1,
+    "max_input_1": final_cabinet_max,
+    "total_input_2": watts_input_2,
+    "has_input2": has_input2_flag,
+    "psu_list": psu_export_list,
+    "custom_220_list": custom_220_list,
+    "cabinet_name": cabinet_label,
+    "ups_charge_power": ups_charge_power,
+    "ups_input_normal": ups_input_normal,  # Передаем потребление ИБП в норм. режиме
+    "ups_input_max": ups_input_max  # Передаем потребление ИБП в макс. режиме
+}
+st.success("✅ Данные сохранены для экспорта.")
+
+# ==================== ЭКСПОРТ В EXCEL (ПОДРОБНЫЙ) ====================
+st.markdown("---")
+st.subheader("7. Выгрузка отчета")
+
+if st.button("📥 Скачать полный расчет (.xlsx)"):
+    report_data = []
+
+
+    # Функция-помощник для добавления строк
+    def add_row(param, val, unit, comment=""):
+        report_data.append({
+            "Параметр": param,
+            "Значение": val,
+            "Ед.изм": unit,
+            "Формула / Комментарий": comment
+        })
+
+
+    # === БЛОК 1: ИСХОДНЫЕ ДАННЫЕ ===
+    add_row("ИСХОДНЫЕ ДАННЫЕ", "", "", "")
+    add_row("Нагрузка 24В (Внутр)", round(loads["Internal"], 2), "Вт", "Логика, модули")
+    add_row("Нагрузка 24В (Внешн)", round(loads["External"], 2), "Вт", "Датчики")
+    add_row("Нагрузка 220В (Прямая)", round(loads["Mains"], 2), "Вт", "Вент, розетки")
+    add_row("КПД Блоков питания", efficiency, "о.е.", "")
+    add_row("", "", "", "")  # Пустая строка
+
+    # === БЛОК 2: РАСЧЕТ ИБП ===
+    if ups_inverter_load > 0:
+        add_row("РАСЧЕТ ИБП И АКБ", "", "", "")
+        add_row("Нагрузка на инвертор (P_inv)", round(ups_inverter_load, 2), "Вт", "P_220(ups) + P_24(ups)/Efficiency")
+        add_row("Время автономии (T_req)", ups_vars["t_req"], "мин", "Задание")
+        add_row("Напряжение АКБ (U_sys)", ups_vars["u_sys"], "В", "")
+        add_row("КПД Инвертора (Eff)", ups_vars["eff"], "о.е.", "")
+        add_row("Коэф. глубины разряда (K_depth)", ups_vars["k_depth"], "о.е.", "")
+        add_row("Коэф. запаса (K_temp)", ups_vars["k_temp"], "о.е.", "")
+
+        add_row("Требуемая емкость (C_req)", round(ups_vars["c_req"], 2), "Ач",
+                "(P_inv * T_h * K_temp) / (U_sys * Eff * K_depth)")
+        add_row("Выбранная емкость (C_act)", ups_vars["c_act"], "Ач",
+                f"{ups_vars['bat_qty']} шт по {ups_vars['bat_nom']} Ач")
+        add_row("Фактическое время (T_fact)", ups_vars["t_fact_str"], "",
+                "(C_act * U_sys * Eff * K_depth) / (P_inv * K_temp)")
+
+        add_row("", "", "", "")  # Пустая строка
+
+        add_row("ЭНЕРГОБАЛАНС", "", "", "")
+        add_row("Потребление ИБП (Норма)", round(ups_vars["p_norm"], 2), "Вт", "P_inv / Eff_inv")
+        add_row("Мощность заряда (P_charge)", round(ups_vars["p_charge"], 2), "Вт", "(U_sys * C_act * 0.15) / 0.85")
+        add_row("Потребление ИБП (Макс)", round(ups_vars["p_max"], 2), "Вт", "P_norm + P_charge")
+        add_row("", "", "", "")  # Пустая строка
+
+    # === БЛОК 3: ИТОГИ ===
+    add_row("ИТОГИ ПО ШКАФУ", "", "", "")
+
+    # Ввод 1
+    add_row("Ввод 1 (Рабочий ток)", round(watts_input_1, 2), "Вт", "Вся нагрузка + потери КПД")
+    if ups_charge_power > 0:
+        add_row("Ввод 1 (Для автомата)", round(final_cabinet_max, 2), "Вт", "С учетом заряда АКБ")
+
+    # Ввод 2 (если есть)
+    if has_input2_flag:
+        add_row("Ввод 2 (Резерв)", round(watts_input_2, 2), "Вт", "Резервирование нагрузки")
+
+    # Генерация Excel
+    df_rep = pd.DataFrame(report_data)
+    bio_rep = BytesIO()
+    with pd.ExcelWriter(bio_rep, engine='openpyxl') as writer:
+        df_rep.to_excel(writer, index=False, sheet_name="Calculation")
+
+        # Наводим красоту
+        ws = writer.sheets["Calculation"]
+        from openpyxl.styles import Font, Border, Side
+
+        # Ширина колонок
+        ws.column_dimensions['A'].width = 35
+        ws.column_dimensions['B'].width = 15
+        ws.column_dimensions['C'].width = 10
+        ws.column_dimensions['D'].width = 60
+
+        # Жирный шрифт для заголовков разделов-
+        for row in ws.iter_rows():
+            cell_param = row[0]
+            if cell_param.value in ["ИСХОДНЫЕ ДАННЫЕ", "РАСЧЕТ ИБП И АКБ", "ЭНЕРГОБАЛАНС", "ИТОГИ ПО ШКАФУ"]:
+                cell_param.font = Font(bold=True)
+
+    st.download_button("Скачать файл (.xlsx)", data=bio_rep.getvalue(), file_name=f"Calculation_{cabinet_label}.xlsx")

pages/3_📝_SingleLine.py

@@ -0,0 +1,199 @@
+import streamlit as st
+import pandas as pd
+import os
+from io import BytesIO
+
+st.set_page_config(page_title="Генерация таблицы Eplan", layout="wide")
+st.title("📑 Генерация данных для Eplan")
+
+# ==================== 1. ЗАГРУЗКА ДАННЫХ ====================
+if "summary_data" not in st.session_state:
+    st.warning("⚠️ Нет данных для расчета! Сначала выполните расчет на странице 'Hardware' и нажмите 'Сохранить'.")
+    st.stop()
+
+data = st.session_state['summary_data']
+cabinet_name = data.get("cabinet_name", "Шкаф")
+st.info(f"Активный проект: **{cabinet_name}**")
+
+# ==================== 2. НАСТРОЙКИ МАКРОСОВ ====================
+with st.expander("⚙️ Настройки макросов", expanded=False):
+    base_macro_path = st.text_input("Базовая папка:", value=r"C:\Eplan_DB\Data\Макросы\Однолинейные схемы")
+    col1, col2 = st.columns(2)
+    with col1:
+        f_in = st.text_input("Ввод (XT)", "XT.ema")
+        f_qs = st.text_input("Автомат (QS)", "QF.ema")
+    with col2:
+        f_psu = st.text_input("Блок питания (PSU)", "Fus_24.ems")
+        f_light = st.text_input("Свет/Вент", "Lamp_fan.ems")
+        f_generic = st.text_input("Устройства", "Gen_Device.ems")
+
+
+def get_path(filename):
+    return os.path.join(base_macro_path, filename) if filename else ""
+
+
+u_ac = 230
+
+# ==================== 3. ПОДГОТОВКА ДАННЫХ ====================
+p_charge = data.get('ups_charge_power', 0)
+val_in1_norm = data.get('total_input_1', 0)
+val_in1_max = data.get('max_input_1', 0)
+val_in2 = data.get('total_input_2', 0)
+
+# ДАННЫЕ ПО ИБП ИЗ ФАЙЛА 2
+ups_val_norm = data.get('ups_input_normal', 0)
+ups_val_max = data.get('ups_input_max', 0)
+
+has_in2 = data.get('has_input2', False)
+
+psu_items = data.get('psu_list', [])
+custom_items = data.get('custom_220_list', [])
+
+
+# Функции форматирования
+def fmt_p(val_normal, val_max=None, placeholder=False):
+    if not val_normal or val_normal <= 0:
+        return "ХХ Вт" if placeholder else ""
+
+    base = f"{int(val_normal)} Вт"
+    if val_max and (val_max - val_normal) > 5:
+        return f"{base}\n{int(val_max)} Вт (при заряде АКБ)"
+    return base
+
+
+def fmt_iu(watts, volts, suffix, watts_max=None, placeholder=False):
+    if not watts or watts <= 0:
+        return "ХХ-ХХ" if placeholder else ""
+
+    amp = watts / volts
+    base = f"{amp:.2f}A / {volts}В {suffix}"
+    if watts_max and (watts_max - watts) > 5:
+        amp_max = watts_max / volts
+        return f"{base}\n{amp_max:.2f} А (макс)"
+    return base
+
+
+# ==================== 4. СБОРКА ТАБЛИЦЫ ====================
+structure = []
+
+# 1. ВВОД 1
+structure.append({
+    "Установка": "Вводные клеммы", "Устройство": "Ввод питания 230В (Ввод 1)",
+    "I-расч./U-ном.": fmt_iu(val_in1_norm, u_ac, "AC", val_in1_max),
+    "P установочное": fmt_p(val_in1_norm, val_in1_max),
+    "Макросы": get_path(f_in)
+})
+
+# 1.1 ВВОД 2 (Если есть)
+if has_in2:
+    structure.append({
+        "Установка": "Вводные клеммы", "Устройство": "Ввод питания 230В (Ввод 2)",
+        "I-расч./U-ном.": fmt_iu(val_in2, u_ac, "AC"),
+        "P установочное": fmt_p(val_in2),
+        "Макросы": get_path(f_in)
+    })
+
+structure.append({"Установка": "Вводные автоматы", "Устройство": "", "I-расч./U-ном.": "", "P установочное": "",
+                  "Макросы": get_path(f_qs)})
+structure.append({"Установка": "Распред.Автоматы шкафа", "Устройство": "", "I-расч./U-ном.": "", "P установочное": "",
+                  "Макросы": get_path(f_qs)})
+
+# 2. Блоки Питания
+for psu in psu_items:
+    name = psu['name']
+    dc_p = psu.get('dc_power', 0)
+    volts = psu['voltage_dc']
+    i_dc = dc_p / volts if volts else 0
+
+    structure.append({
+        "Установка": "Оборудование шкафа",
+        "Устройство": name,
+        "I-расч./U-ном.": f"{i_dc:.2f}A / {volts}В DC",
+        "P установочное": fmt_p(dc_p),
+        "Макросы": get_path(f_psu)
+    })
+
+# 3. Устройства 220В
+for item in custom_items:
+    name = item['name']
+    p_val = item['power']
+
+    # ПРОВЕРКА НА ИБП
+    is_ups_device = any(k in name.lower() for k in ["ибп", "ups", "sr1101"])
+
+    # Если это ИБП, подставляем расчетные данные из Файла 2
+    if is_ups_device:
+        p_show = ups_val_norm
+        p_max_show = ups_val_max
+        use_place = False
+    else:
+        p_show = p_val
+        p_max_show = None
+        # Если мощность 0 (как у розетки), включаем плейсхолдер
+        use_place = True if p_val == 0 else False
+
+    if any(x in name.lower() for x in ["свет", "вент", "розет"]):
+        macro = get_path(f_light)
+    else:
+        macro = get_path(f_generic)
+
+    structure.append({
+        "Установка": "Оборудование шкафа",
+        "Устройство": name,
+        "I-расч./U-ном.": fmt_iu(p_show, u_ac, "AC", p_max_show, placeholder=use_place),
+        "P установочное": fmt_p(p_show, p_max_show, placeholder=use_place),
+        "Макросы": macro
+    })
+
+# Пустые строки
+structure.append(
+    {"Установка": "Р установочное", "Устройство": "", "I-расч./U-ном.": "", "P установочное": "", "Макросы": ""})
+structure.append(
+    {"Установка": "I-расч./U-ном.", "Устройство": "", "I-расч./U-ном.": "", "P установочное": "", "Макросы": ""})
+structure.append(
+    {"Установка": "Устройство", "Устройство": "", "I-расч./U-ном.": "", "P установочное": "", "Макросы": ""})
+
+# Создание DataFrame
+df_initial = pd.DataFrame(structure)
+if df_initial.empty:
+    df_initial = pd.DataFrame(columns=["Установка", "Устройство", "I-расч./U-ном.", "P установочное", "Макросы"])
+else:
+    df_initial = df_initial[["Установка", "Устройство", "I-расч./U-ном.", "P установочное", "Макросы"]]
+
+# ==================== 5. ВЫВОД- ====================
+st.subheader("Предварительный просмотр (Можно добавлять строки 👇)")
+
+edited_df = st.data_editor(
+    df_initial,
+    use_container_width=True,
+    hide_index=True,
+    num_rows="dynamic",
+    column_config={
+        "Установка": st.column_config.TextColumn("Установка", width="medium"),
+        "Устройство": st.column_config.TextColumn("Устройство", width="large"),
+        "Макросы": st.column_config.TextColumn("Макросы", width="large"),
+    }
+)
+
+st.divider()
+if st.button("📥 Скачать Excel (.xlsx)", type="primary"):
+    bio = BytesIO()
+    with pd.ExcelWriter(bio, engine='openpyxl') as writer:
+        edited_df.to_excel(writer, index=False, sheet_name="Generate_Data")
+
+        ws = writer.sheets["Generate_Data"]
+        from openpyxl.styles import Alignment, Font
+
+        ws.column_dimensions['A'].width = 25
+        ws.column_dimensions['B'].width = 40
+        ws.column_dimensions['C'].width = 30
+        ws.column_dimensions['D'].width = 30
+        ws.column_dimensions['E'].width = 60
+
+        for row in ws.iter_rows(min_row=1):
+            for cell in row:
+                cell.alignment = Alignment(wrap_text=True, vertical='center', horizontal='left')
+                if cell.row == 1:
+                    cell.font = Font(bold=True)
+
+    st.download_button("Скачать файл", data=bio.getvalue(), file_name=f"Eplan_{cabinet_name}.xlsx")