.. 标题： PoE 功率预算计算器
.. slug： poe-budgeter
..日期：2026-01-09 15:00:00 世界标准时间
..标签：网络、计算器、工具、PoE、以太网
..类别：计算器
..链接：
.. 描述：计算网络设备的 PoE 电压传输和功率预算
..类型：文本
<style>
    .poe-calc-container {
        max-width: 1000px;
        margin: 20px auto;
        padding: 20px;
    }

    .calc-header {
        margin-bottom: 30px;
        padding: 25px;
        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        border-radius: 12px;
        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
        color: white;
    }

    .calc-header h2 {
        margin-top: 0;
        color: white;
        font-size: 28px;
        margin-bottom: 10px;
    }

    .calc-header p {
        margin: 10px 0 20px 0;
        opacity: 0.95;
        font-size: 15px;
        line-height: 1.6;
    }

    .input-section {
        display: grid;
        grid-template-columns: 1fr 1fr;
        gap: 15px;
        margin-bottom: 20px;
    }

    .input-group {
        display: flex;
        flex-direction: column;
    }

    .input-group label {
        font-weight: bold;
        color: white;
        margin-bottom: 8px;
        font-size: 14px;
    }

    .input-group select,
    .input-group input {
        padding: 14px;
        font-size: 16px;
        border: 2px solid rgba(255,255,255,0.3);
        border-radius: 6px;
        font-family: 'Courier New', monospace;
        background: rgba(255,255,255,0.95);
        transition: all 0.3s ease;
    }

    .input-group input:focus,
    .input-group select:focus {
        outline: none;
        border-color: #4CAF50;
        background: white;
        box-shadow: 0 0 0 3px rgba(76, 175, 80, 0.1);
    }

    .input-with-toggle {
        display: flex;
        gap: 10px;
        align-items: stretch;
    }

    .input-with-toggle input {
        flex: 1;
    }

    .unit-toggle {
        padding: 14px 20px;
        font-size: 14px;
        background: rgba(255,255,255,0.95);
        border: 2px solid rgba(255,255,255,0.3);
        border-radius: 6px;
        cursor: pointer;
        font-weight: bold;
        transition: all 0.3s ease;
        min-width: 60px;
    }

    .unit-toggle:hover {
        background: white;
        border-color: #4CAF50;
    }

    .checkbox-group {
        margin-top: 15px;
        display: flex;
        align-items: center;
        gap: 10px;
        background: rgba(0,0,0,0.1);
        padding: 12px 15px;
        border-radius: 6px;
    }

    .checkbox-group input[type="checkbox"] {
        width: 20px;
        height: 20px;
        cursor: pointer;
        accent-color: #4CAF50;
    }

    .checkbox-group label {
        margin-bottom: 0;
        cursor: pointer;
        font-size: 15px;
        user-select: none;
    }

    .calc-button {
        padding: 14px 35px;
        font-size: 16px;
        background: #4CAF50;
        color: white;
        border: none;
        border-radius: 6px;
        cursor: pointer;
        font-weight: bold;
        transition: all 0.3s ease;
        box-shadow: 0 2px 4px rgba(0,0,0,0.2);
        width: 100%;
        margin-top: 15px;
    }

    .calc-button:hover {
        background: #45a049;
        transform: translateY(-1px);
        box-shadow: 0 4px 8px rgba(0,0,0,0.3);
    }

    .calc-button:active {
        background: #3d8b40;
        transform: translateY(0);
    }

    .results {
        margin-top: 30px;
    }

    .result-section {
        background: white;
        border: 1px solid #e0e0e0;
        border-radius: 8px;
        margin-bottom: 15px;
        overflow: hidden;
        box-shadow: 0 2px 4px rgba(0,0,0,0.05);
        transition: all 0.3s ease;
    }

    .result-section:hover {
        box-shadow: 0 4px 8px rgba(0,0,0,0.1);
    }

    .section-header {
        background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%);
        color: white;
        padding: 15px 20px;
        font-weight: bold;
        font-size: 18px;
        display: flex;
        justify-content: space-between;
        align-items: center;
    }

    .status-badge {
        padding: 6px 16px;
        border-radius: 20px;
        font-size: 14px;
        font-weight: bold;
        background: rgba(255,255,255,0.2);
    }

    .status-badge.pass {
        background: #2e7d32;
    }

    .status-badge.marginal {
        background: #f57c00;
    }

    .status-badge.fail {
        background: #c62828;
    }

    .section-content {
        padding: 20px;
        background: #fafafa;
    }

    .voltage-health-bar-container {
        margin: 20px 0;
        background: #e0e0e0;
        border-radius: 8px;
        height: 40px;
        position: relative;
        overflow: hidden;
    }

    .voltage-health-bar {
        height: 100%;
        transition: all 0.5s ease;
        display: flex;
        align-items: center;
        justify-content: center;
        color: white;
        font-weight: bold;
        font-size: 14px;
    }

    .min-voltage-marker {
        position: absolute;
        top: 0;
        bottom: 0;
        width: 3px;
        background: rgba(0,0,0,0.5);
        z-index: 1;
    }

    .min-voltage-marker::after {
        content: 'MIN';
        position: absolute;
        top: -20px;
        left: -12px;
        font-size: 10px;
        font-weight: bold;
        color: #333;
    }

    .data-grid {
        display: grid;
        grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
        gap: 15px;
        margin-top: 15px;
    }

    .data-row {
        padding: 15px;
        background: white;
        border-radius: 6px;
        border-left: 4px solid #4CAF50;
        box-shadow: 0 1px 3px rgba(0,0,0,0.05);
    }

    .data-label {
        font-weight: bold;
        color: #555;
        font-size: 13px;
        margin-bottom: 8px;
        text-transform: uppercase;
        letter-spacing: 0.5px;
    }

    .data-value {
        color: #333;
        font-family: 'Courier New', monospace;
        font-size: 20px;
        font-weight: bold;
        color: #4CAF50;
    }

    .warning-section {
        margin-top: 15px;
    }

    .warning-message {
        padding: 12px 15px;
        border-radius: 6px;
        margin-bottom: 10px;
        font-size: 14px;
        line-height: 1.5;
    }

    .warning-message.error {
        background: #ffebee;
        color: #c62828;
        border-left: 4px solid #c62828;
    }

    .warning-message.warning {
        background: #fff3e0;
        color: #e65100;
        border-left: 4px solid #ff9800;
    }

    .warning-message.info {
        background: #e3f2fd;
        color: #1565c0;
        border-left: 4px solid #2196F3;
    }

    .summary-text {
        background: white;
        padding: 20px;
        border-radius: 8px;
        margin-top: 15px;
        font-family: 'Courier New', monospace;
        font-size: 14px;
        line-height: 1.8;
        white-space: pre-wrap;
        border: 1px solid #e0e0e0;
    }

    .description-section {
        margin-top: 30px;
        padding: 20px;
        background: white;
        border-radius: 8px;
        box-shadow: 0 2px 4px rgba(0,0,0,0.05);
        border-top: 3px solid #4CAF50;
    }

    .description-section h3 {
        color: #4CAF50;
        margin-top: 0;
    }

    .description-section p {
        line-height: 1.6;
        color: #555;
        margin-bottom: 15px;
    }

    .description-section ul {
        line-height: 1.8;
        color: #555;
    }

    /* Responsive design */
    @media (max-width: 768px) {
        .input-section {
            grid-template-columns: 1fr;
        }

        .data-grid {
            grid-template-columns: 1fr;
        }

        .calc-header h2 {
            font-size: 24px;
        }

        .section-header {
            flex-direction: column;
            gap: 10px;
            align-items: flex-start;
        }
    }
</style>
<div class="poe-calc-container">
<div class="calc-header">
<h2>PoE 功率预算计算器</h2>
<p>考虑电缆电阻后，计算受电设备 (PD) 是否会收到足够的电压来运行。 PoE 系统会随着距离的增加而失去电压，并且由于设备是恒定功率负载，因此它们会随着电压下降而吸收更多电流，从而可能导致启动故障或电源循环。</p>
<div class="input-section">
<div class="input-group">
<label for="poeStandard">PoE 标准：</label>
<select id="poeStandard">
<option value="802.3af">802.3af (PoE) - 15.4W</option>
<option selected="" value="802.3at">802.3at (PoE+) - 30W</option>
<option value="802.3bt-type3">802.3bt 类型 3 (PoE++) - 60W</option>
<option value="802.3bt-type4">802.3bt 类型 4 (PoE++) - 90W</option>
</select>
</div>
<div class="input-group">
<label for="cableType">电缆类型：</label>
<select id="cableType">
<option selected="" value="cat5e-24awg">Cat5e (24 AWG) - 8.4Ω/100m</option>
<option value="cat6-23awg">六类 (23 AWG) - 6.7Ω/100m</option>
<option value="patch-26awg">跳线 (26 AWG) - 14.0Ω/100m</option>
</select>
</div>
<div class="input-group">
<label for="cableLength">电缆长度：</label>
<div class="input-with-toggle">
<input autocomplete="off" id="cableLength" max="500" min="0" step="0.1" type="number" value="100"/>
<button class="unit-toggle" id="unitToggle" onclick="toggleUnits()" type="button">m</button>
</div>
</div>
<div class="input-group">
<label for="devicePower">设备功率（瓦）：</label>
<input autocomplete="off" id="devicePower" min="0" step="0.1" type="number" value="30"/>
</div>
</div>
<div class="checkbox-group">
<input id="customPower" onchange="toggleCustomPower()" type="checkbox"/>
<label for="customPower">使用自定义设备功率（否则使用标准最大值）</label>
</div>
<button class="calc-button" onclick="calculatePowerBudget()" type="button">计算功率预算</button>
</div>
<div class="results" id="results" style="display: none;">
<div class="result-section">
<div class="section-header">
<span>功率预算分析</span>
<span class="status-badge" id="statusBadge">-</span>
</div>
<div class="section-content">
<div class="voltage-health-bar-container">
<div class="min-voltage-marker" id="minVoltageMarker"></div>
<div class="voltage-health-bar" id="voltageHealthBar">-</div>
</div>
<div class="data-grid">
<div class="data-row">
<div class="data-label">电源电压：</div>
<div class="data-value" id="sourceVoltage">-</div>
</div>
<div class="data-row">
<div class="data-label">设备电压：</div>
<div class="data-value" id="deviceVoltage">-</div>
</div>
<div class="data-row">
<div class="data-label">电压降：</div>
<div class="data-value" id="voltageDrop">-</div>
</div>
<div class="data-row">
<div class="data-label">电流消耗：</div>
<div class="data-value" id="currentDraw">-</div>
</div>
<div class="data-row">
<div class="data-label">功率损耗：</div>
<div class="data-value" id="powerLoss">-</div>
</div>
<div class="data-row">
<div class="data-label">效率：</div>
<div class="data-value" id="efficiency">-</div>
</div>
</div>
<div class="warning-section" id="warningSection"></div>
<div class="summary-text" id="summaryText"></div>
</div>
</div>
</div>
<div class="description-section">
<h3>关于 PoE 功率预算</h3>
<p>PoE（以太网供电）预算器计算受电设备 (PD)（例如 IP 摄像机或无线接入点）在考虑以太网电缆的电阻后是否会收到足够的电压来运行。</p>
<p><strong>为什么这很重要？</strong></p>
<ul>
<li>随着电缆长度的增加，电压会因电阻而以热量的形式损失</li>
<li>PoE 设备是恒定功率负载，因此随着电压下降它们会消耗更多电流</li>
<li>这可能会导致设备无法启动或反复启动的“死亡螺旋”</li>
<li>IEEE 标准规定了设备必须维持的最低电压水平</li>
</ul>
<p><strong>主要考虑因素：</strong></p>
<ul>
<li><strong>802.3af（以太网供电）：</strong>最大 15.4W，使用 2 对，设备最小电压 37V</li>
<li><strong>802.3at（PoE+）：</strong>最大 30W，使用 2 对，设备最小电压 42.5V</li>
<li><strong>802.3bt 类型 3：</strong>最大 60W，使用 4 对（半电阻！），最小 42.5V</li>
<li><strong>802.3bt 类型 4：</strong>最大 90W，使用 4 对，设备最小电压 41.1V</li>
<li><strong>电缆规格事项：</strong>23 AWG 的电阻低于 24 AWG 或 26 AWG</li>
</ul>
<p>该计算器使用源自欧姆定律和幂律的二次公式来求解电压、电流和功率在电缆电阻上平衡的实际工作点。</p>
</div>
</div>
<script>
'use strict';

/**
 * PoE Power Budget Calculator
 * Calculates voltage delivery and power efficiency for PoE systems
 * accounting for cable resistance and IEEE 802.3 standard requirements
 */

// Reference Data Objects
const POE_STANDARDS = {
    '802.3af': {
        name: '802.3af (PoE)',
        maxPower: 15.4,
        sourceVoltage: 44,
        minDeviceVoltage: 37,
        pairs: 2
    },
    '802.3at': {
        name: '802.3at (PoE+)',
        maxPower: 30,
        sourceVoltage: 50,
        minDeviceVoltage: 42.5,
        pairs: 2
    },
    '802.3bt-type3': {
        name: '802.3bt Type 3 (PoE++)',
        maxPower: 60,
        sourceVoltage: 52,
        minDeviceVoltage: 42.5,
        pairs: 4
    },
    '802.3bt-type4': {
        name: '802.3bt Type 4 (PoE++)',
        maxPower: 90,
        sourceVoltage: 52,
        minDeviceVoltage: 41.1,
        pairs: 4
    }
};

const CABLE_RESISTANCE = {
    'cat5e-24awg': {
        ohms: 8.4,
        name: 'Cat5e (24 AWG)'
    },
    'cat6-23awg': {
        ohms: 6.7,
        name: 'Cat6 (23 AWG)'
    },
    'patch-26awg': {
        ohms: 14.0,
        name: 'Patch Cable (26 AWG)'
    }
};

// Unit conversion state
let isMeters = true;

/**
 * Calculate PoE power delivery using quadratic formula
 * Solves for operating point where V, I, and P are balanced
 *
 * @param {number} sourceVolts - PSE source voltage (V)
 * @param {number} deviceWatts - PD power consumption (W)
 * @param {number} lengthMeters - Cable length in meters
 * @param {number} ohmsPer100m - Cable resistance per 100m
 * @param {number} pairs - Number of wire pairs (2 or 4)
 * @returns {Object} Calculation results or error object
 */
function calculatePoE(sourceVolts, deviceWatts, lengthMeters, ohmsPer100m, pairs) {
    // Calculate total cable resistance
    // For 4-pair PoE, effective resistance is halved (parallel paths)
    let cableResistance = (ohmsPer100m * lengthMeters) / 100;

    if (pairs === 4) {
        cableResistance = cableResistance / 2;
    }

    // Quadratic formula derivation:
    // V_device = V_source - I * R_cable
    // P_device = V_device * I
    // Substituting: P = (V_source - I * R_cable) * I
    // Expanding: P = V_source * I - I² * R_cable
    // Rearranging: I² * R_cable - V_source * I + P = 0
    // Using quadratic formula: I = (V_source ± sqrt(V_source² - 4 * R_cable * P)) / (2 * R_cable)

    const discriminant = Math.pow(sourceVolts, 2) - (4 * cableResistance * deviceWatts);

    // Check if solution is possible
    if (discriminant < 0) {
        return {
            error: true,
            message: 'No valid solution: power demand exceeds what can be delivered through this cable. Try shorter cable, lower gauge wire, or 4-pair PoE.',
            discriminant
        };
    }

    // Calculate current (use minus solution for physical operating point)
    const current = (sourceVolts - Math.sqrt(discriminant)) / (2 * cableResistance);

    // Calculate voltage drop across cable
    const voltageDrop = current * cableResistance;

    // Calculate voltage at device
    const deviceVoltage = sourceVolts - voltageDrop;

    // Calculate power loss in cable
    const powerLoss = Math.pow(current, 2) * cableResistance;

    // Calculate efficiency
    const efficiency = ((deviceWatts / (deviceWatts + powerLoss)) * 100);

    return {
        error: false,
        current,
        voltageDrop,
        deviceVoltage,
        powerLoss,
        efficiency,
        cableResistance
    };
}

/**
 * Validate calculation results against IEEE standards
 *
 * @param {Object} result - Calculation results from calculatePoE
 * @param {Object} standard - PoE standard object
 * @param {number} lengthMeters - Cable length in meters
 * @returns {Object} Validation status and warnings
 */
function validateResults(result, standard, lengthMeters) {
    const warnings = [];
    let status = 'PASS';

    // Check minimum voltage requirement
    const voltageMargin = result.deviceVoltage - standard.minDeviceVoltage;

    if (result.deviceVoltage < standard.minDeviceVoltage) {
        status = 'FAIL';
        warnings.push({
            type: 'error',
            message: `Device voltage (${result.deviceVoltage.toFixed(2)}V) is below IEEE minimum (${standard.minDeviceVoltage}V). Device may fail to power on or operate unstably.`
        });
    } else if (voltageMargin < 2) {
        status = 'MARGINAL';
        warnings.push({
            type: 'warning',
            message: `Device voltage is only ${voltageMargin.toFixed(2)}V above minimum. Consider shorter cable or lower resistance wire for reliability.`
        });
    }

    // Check for excessive voltage drop
    const dropPercentage = (result.voltageDrop / standard.sourceVoltage) * 100;
    if (dropPercentage > 15) {
        warnings.push({
            type: 'warning',
            message: `High voltage drop (${dropPercentage.toFixed(1)}%). Consider using lower resistance cable or reducing length.`
        });
    }

    // Check efficiency
    if (result.efficiency < 85) {
        warnings.push({
            type: 'warning',
            message: `Low efficiency (${result.efficiency.toFixed(1)}%). ${result.powerLoss.toFixed(2)}W being wasted as heat in the cable.`
        });
    }

    // Cable bundle heating warning for high-power PoE
    if (standard.maxPower >= 60 && lengthMeters > 50) {
        warnings.push({
            type: 'info',
            message: 'PoE++ over 50m: Be aware of potential cable bundle heating. IEEE 802.3bt recommends derating for large bundles.'
        });
    }

    // High current warning
    if (result.current > 0.6) {
        warnings.push({
            type: 'info',
            message: `High current draw (${result.current.toFixed(3)}A). Ensure connectors and terminations are properly seated to avoid hot spots.`
        });
    }

    return {
        status,
        warnings
    };
}

/**
 * Update voltage health bar visualization
 *
 * @param {number} deviceVoltage - Voltage at device
 * @param {number} sourceVoltage - Source voltage
 * @param {number} minVoltage - Minimum required voltage
 */
function updateVoltageHealthBar(deviceVoltage, sourceVoltage, minVoltage) {
    const bar = document.getElementById('voltageHealthBar');
    const marker = document.getElementById('minVoltageMarker');

    // Calculate percentage of source voltage delivered
    const percentage = (deviceVoltage / sourceVoltage) * 100;

    // Set bar width and text
    bar.style.width = `${percentage}%`;
    bar.textContent = `${deviceVoltage.toFixed(2)}V (${percentage.toFixed(1)}%)`;

    // Color coding based on voltage margin
    if (deviceVoltage >= minVoltage + 2) {
        bar.style.background = 'linear-gradient(90deg, #4CAF50 0%, #45a049 100%)';
    } else if (deviceVoltage >= minVoltage) {
        bar.style.background = 'linear-gradient(90deg, #ff9800 0%, #f57c00 100%)';
    } else {
        bar.style.background = 'linear-gradient(90deg, #f44336 0%, #c62828 100%)';
    }

    // Position minimum voltage marker
    const markerPosition = (minVoltage / sourceVoltage) * 100;
    marker.style.left = `${markerPosition}%`;
}

/**
 * Main calculation function - orchestrates all calculations and UI updates
 */
function calculatePowerBudget() {
    try {
        // Get input values
        const poeStandardKey = document.getElementById('poeStandard').value;
        const cableTypeKey = document.getElementById('cableType').value;
        let lengthValue = parseFloat(document.getElementById('cableLength').value);
        const devicePowerInput = parseFloat(document.getElementById('devicePower').value);
        const customPowerEnabled = document.getElementById('customPower').checked;

        // Get reference data
        const standard = POE_STANDARDS[poeStandardKey];
        const cable = CABLE_RESISTANCE[cableTypeKey];

        // Input validation
        if (isNaN(lengthValue) || lengthValue <= 0) {
            alert('Please enter a valid cable length greater than 0.');
            return;
        }

        if (isNaN(devicePowerInput) || devicePowerInput <= 0) {
            alert('Please enter a valid device power greater than 0.');
            return;
        }

        // Convert feet to meters if necessary
        const lengthMeters = isMeters ? lengthValue : lengthValue / 3.28084;

        // Determine device power (custom or standard max)
        const deviceWatts = customPowerEnabled ? devicePowerInput : standard.maxPower;

        // Validate power doesn't exceed standard
        if (deviceWatts > standard.maxPower) {
            alert(`Device power (${deviceWatts}W) exceeds ${standard.name} maximum (${standard.maxPower}W). Please select a higher power standard or reduce device power.`);
            return;
        }

        // Perform calculation
        const result = calculatePoE(
            standard.sourceVoltage,
            deviceWatts,
            lengthMeters,
            cable.ohms,
            standard.pairs
        );

        // Handle calculation errors
        if (result.error) {
            alert(result.message);
            return;
        }

        // Validate results
        const validation = validateResults(result, standard, lengthMeters);

        // Update UI elements
        updateVoltageHealthBar(result.deviceVoltage, standard.sourceVoltage, standard.minDeviceVoltage);

        // Update status badge
        const statusBadge = document.getElementById('statusBadge');
        statusBadge.textContent = validation.status;
        statusBadge.className = `status-badge ${validation.status.toLowerCase()}`;

        // Update data fields
        document.getElementById('sourceVoltage').textContent = `${standard.sourceVoltage.toFixed(1)}V`;
        document.getElementById('deviceVoltage').textContent = `${result.deviceVoltage.toFixed(2)}V`;
        document.getElementById('voltageDrop').textContent = `${result.voltageDrop.toFixed(2)}V`;
        document.getElementById('currentDraw').textContent = `${result.current.toFixed(3)}A`;
        document.getElementById('powerLoss').textContent = `${result.powerLoss.toFixed(2)}W`;
        document.getElementById('efficiency').textContent = `${result.efficiency.toFixed(1)}%`;

        // Display warnings
        const warningSection = document.getElementById('warningSection');
        if (validation.warnings.length > 0) {
            warningSection.innerHTML = validation.warnings.map(warning =>
                `<div class="warning-message ${warning.type}">${warning.message}</div>`
            ).join('');
        } else {
            warningSection.innerHTML = '<div class="warning-message info">All parameters within acceptable ranges. System should operate normally.</div>';
        }

        // Generate summary text
        const lengthDisplay = isMeters ? `${lengthMeters.toFixed(1)}m` : `${(lengthMeters * 3.28084).toFixed(1)}ft`;
        const summary = `
PoE Power Budget Analysis:

Standard: ${standard.name}
Cable: ${cable.name} @ ${lengthDisplay}
Device Power: ${deviceWatts.toFixed(1)}W
Wire Pairs: ${standard.pairs}

Power Source (PSE):
  Source Voltage: ${standard.sourceVoltage}V

Cable Loss:
  Total Resistance: ${result.cableResistance.toFixed(3)}Ω ${standard.pairs === 4 ? '(4-pair halves resistance)' : ''}
  Current Draw: ${result.current.toFixed(3)}A
  Voltage Drop: ${result.voltageDrop.toFixed(2)}V
  Power Loss: ${result.powerLoss.toFixed(2)}W

Powered Device (PD):
  Device Voltage: ${result.deviceVoltage.toFixed(2)}V
  Min Required: ${standard.minDeviceVoltage}V
  Voltage Margin: ${(result.deviceVoltage - standard.minDeviceVoltage).toFixed(2)}V
  Efficiency: ${result.efficiency.toFixed(1)}%

Result: ${validation.status}
${validation.status !== 'PASS' ? '\nRecommendation: ' + validation.warnings[0].message : ''}
        `.trim();

        document.getElementById('summaryText').textContent = summary;

        // Show results section
        document.getElementById('results').style.display = 'block';

        // Smooth scroll to results
        document.getElementById('results').scrollIntoView({ behavior: 'smooth', block: 'nearest' });

    } catch (error) {
        console.error('Calculation error:', error);
        alert(`Calculation error: ${error.message}`);
    }
}

/**
 * Toggle between meters and feet
 */
function toggleUnits() {
    const lengthInput = document.getElementById('cableLength');
    const toggleButton = document.getElementById('unitToggle');
    const currentValue = parseFloat(lengthInput.value);

    if (isNaN(currentValue)) {
        return;
    }

    if (isMeters) {
        // Convert meters to feet
        lengthInput.value = (currentValue * 3.28084).toFixed(1);
        toggleButton.textContent = 'ft';
        isMeters = false;
    } else {
        // Convert feet to meters
        lengthInput.value = (currentValue / 3.28084).toFixed(1);
        toggleButton.textContent = 'm';
        isMeters = true;
    }
}

/**
 * Toggle custom power input
 */
function toggleCustomPower() {
    const customCheckbox = document.getElementById('customPower');
    const devicePowerInput = document.getElementById('devicePower');
    const poeStandardKey = document.getElementById('poeStandard').value;
    const standard = POE_STANDARDS[poeStandardKey];

    if (customCheckbox.checked) {
        // Enable custom power input
        devicePowerInput.disabled = false;
        devicePowerInput.focus();
    } else {
        // Disable and set to standard maximum
        devicePowerInput.disabled = true;
        devicePowerInput.value = standard.maxPower;
    }
}

/**
 * Update device power field when PoE standard changes (if not custom)
 */
function updateDevicePowerFromStandard() {
    const customCheckbox = document.getElementById('customPower');

    if (!customCheckbox.checked) {
        const poeStandardKey = document.getElementById('poeStandard').value;
        const standard = POE_STANDARDS[poeStandardKey];
        document.getElementById('devicePower').value = standard.maxPower;
    }
}

// Event Listeners
document.addEventListener('DOMContentLoaded', () => {
    // Initialize device power input state
    const devicePowerInput = document.getElementById('devicePower');
    devicePowerInput.disabled = true;

    // Add Enter key support for inputs
    const inputs = document.querySelectorAll('input[type="number"]');
    inputs.forEach(input => {
        input.addEventListener('keypress', (event) => {
            if (event.key === 'Enter') {
                event.preventDefault();
                calculatePowerBudget();
            }
        });
    });

    // Update device power when standard changes
    const poeStandardSelect = document.getElementById('poeStandard');
    poeStandardSelect.addEventListener('change', updateDevicePowerFromStandard);

    // Prevent form submission if wrapped in a form
    const calcButton = document.querySelector('.calc-button');
    calcButton.addEventListener('click', (event) => {
        event.preventDefault();
        calculatePowerBudget();
    });

    console.log('PoE Power Budget Calculator initialized successfully');
});
</script>