# Energia i prosty zwrot modernizacji oświetlenia

Adres źródłowy: https://zamki-szyfrowe.pl/planer-uslug/koszt-modernizacji-oswietlenia/

Zaktualizowano: 2026-10-12T20:59:43+00:00

Przejdź do treści

MSWSUPER SERWISTechnika Twojego domuUsługiBlogPlaner usługKontakt570 933 114

MSW/Planer usług/ObliczeniaObliczenia · PLANER USŁUG

## Energia i prosty zwrot modernizacji oświetlenia

Porównaj energię przed i po zmianie opraw oraz prosty zwrot własnego kosztu modernizacji.

Narzędzie porównuje zużycie przy tej samej liczbie opraw i tym samym czasie świecenia. Zwrot obejmuje wyłącznie zmianę kosztu energii i nie potwierdza równoważności oświetlenia, trwałości ani kosztu wykonania usługi.

Do obliczeń potrzebny jest JavaScript. Możesz także omówić zakres usługi telefonicznie: 570 933 114.

## Twoje założenia

Wpisz dane dla swojego domu. Przycisk „Pokaż przykład” pozwala poznać sposób działania.

Liczba porównywanych opraw 

Moc pobierana przez jedną starą oprawę W

Moc pobierana przez jedną nową oprawę W

Czas świecenia dziennie h

Liczba dni świecenia w roku dni

Własna stawka za energię zł/kWh

Własny całkowity koszt modernizacji zł

Przygotuj wynikPokaż przykładWyczyść do wartości początkowych

Zachowaj szkic i wróć później

Zapis uruchamiasz przyciskiem. Szkic w przeglądarce jest dostępny na tym urządzeniu; plik JSON pozwala przenieść go do innego. Formularz nie wysyła danych do MSW.

Zapisz w przeglądarceWczytaj zapisUsuń zapisPobierz szkic JSON

Wczytaj własny plik szkicu

## Przygotuj swój wynik

Wynik pojawi się tutaj po przeliczeniu Twoich danych.

Kopiuj wynikPobierz TXTDrukuj / PDF

Wynik wraz z założeniami

Omów wynik na WhatsAppZadzwoń: 570 933 114

WhatsApp otworzy przygotowany tekst. Sprawdź go i samodzielnie zdecyduj o wysłaniu.

Dane są przeliczane w przeglądarce. Zapis i wysłanie uruchamiasz samodzielnie.

OD PLANU DO REALIZACJI

## Porozmawiajmy o usłudze

Przygotowany wynik pomaga określić zakres rozmowy. Dobór urządzeń, warunki montażu, termin i cenę potwierdzamy po poznaniu obiektu.

Elektryk do domu i firmy ↗Inteligentne domy ↗Wszystkie 30 narzędzi →

MSW Super Serwis

Warszawa i województwo mazowieckie. Zakres prac i możliwość dojazdu uzgadniamy dla konkretnego obiektu.

Zadzwoń: 570 933 114WhatsAppUzgodnij usługęPozostałe narzędzia

(()=>{
const toolDefinitionsA = (()=>{
/* Pure calculations for MSW. No DOM, requests, persistence or installation instructions. */

const categoryPath = (slug) => `/kategorie/${slug}/`;
const numberField = (id, label, defaultValue, min, max, step, unit) => ({
id, label, type: 'number', default: defaultValue, min, max, step,
...(unit ? { unit } : {}),
});
const listField = (id, label, defaultValue, unit) => ({
id, label, type: 'textarea', default: defaultValue, unit,
});
const selectField = (id, label, defaultValue, options) => ({
id, label, type: 'select', default: defaultValue,
options: options.map(() => ({ value, label: optionLabel })),
});
const round = (value, places = 4) => Number(value.toFixed(places));
const metric = (label, value, unit) => ({
label, value: typeof value === 'number' ? round(value) : value,
...(unit ? { unit } : {}),
});
const result = (title, metrics, details) => ({ title, metrics, details });
const inputError = (message) => result('Sprawdź dane wejŜciowe', [], );

function parseNumber(value) {
if (typeof value === 'number') return value;
if (typeof value !== 'string') return NaN;
const text = value.trim();
if (!/^?(?:\d+(?:\d*)?|\d+)(?:e?\d+)?$/i.test(text)) return NaN;
return Number(text.replace(',', '.'));
}

function parseList(text, label, { maxValue = 100000, integer = false } = {}) {
if (text.length > 20000) throw new Error(`${label}: lista jest za długa; wpisz najwyżej 200 pozycji.`);
const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
if (lines.length > 200) throw new Error(`${label}: wpisz najwyżej 200 pozycji.`);
return lines.map((line, index) => {
const value = parseNumber(line);
if (!Number.isFinite(value) || value < 0 || value > maxValue || (integer && !Number.isInteger(value))) {
throw new Error(`${label}, pozycja ${index + 1}: wpisz ${integer ? 'całkowitą ' : ''}liczbĚ od 0 do ${maxValue}, bez jednostki. Każdą pozycjĚ umieŜć w osobnym wierszu.`);
}
return value;
});
}

function duration(seconds) {
if (!Number.isFinite(seconds)) return 'Czas poza zakresem obliczeń';
if (seconds === 0) return '0 s';
if (seconds &lt; 1) return &#039;Mniej niż 1 s&#039;;
let remaining = Math.ceil(seconds);
const days = Math.floor(remaining / 86400);
remaining %= 86400;
const hours = Math.floor(remaining / 3600);
remaining %= 3600;
const minutes = Math.floor(remaining / 60);
const secs = remaining % 60;
return .filter(Boolean).join(&#039; &#039;);
}

function defineTool(specification, calculate) {
return {
...specification,
category: &#039;Obliczenia&#039;,
compute(values = {}) {
if (!values || typeof values !== &#039;object&#039; || Array.isArray(values)) {
return inputError(&#039;Wprowadź wartoŜci w polach formularza.&#039;);
}
const parsed = {};
for (const field of specification.fields) {
const raw = values === undefined ? field.default : values;
if (field.type === &#039;number&#039;) {
const value = parseNumber(raw);
if (!Number.isFinite(value) || value < field.min || value > field.max || (field.step === 1 && !Number.isInteger(value))) {
return inputError(`${field.label}: wpisz ${field.step === 1 ? 'całkowitą ' : ''}liczbĚ od ${field.min} do ${field.max}${field.unit ? ` ${field.unit}` : ''}.`);
}
parsed = value;
} else if (field.type === 'select') {
if (!field.options.some((option) => option.value === raw)) return inputError(`${field.label}: wybierz jedną z dostĚpnych opcji.`);
parsed = raw;
} else {
if (typeof raw !== 'string') return inputError(`${field.label}: wpisz tekst w wymaganym formacie.`);
parsed = raw;
}
}
try {
const calculated = calculate(parsed);
if (!calculated || typeof calculated.title !== 'string' || !Array.isArray(calculated.metrics) || !Array.isArray(calculated.details)
|| calculated.metrics.some((entry) => typeof entry.label !== 'string' || !.includes(typeof entry.value)
|| (typeof entry.value === 'number' && !Number.isFinite(entry.value)))
|| calculated.details.some((entry) => typeof entry !== 'string')) {
return inputError('Skala wpisanych wartoŜci przekracza zakres obliczeń. Sprawdź jednostki i wartoŜci.');
}
return calculated;
} catch (error) {
return inputError(error instanceof Error ? error.message : 'Sprawdź format i zakres wpisanych danych.');
}
},
};
}

const toolDefinitionsA = [
defineTool({
id: 'koszt-czuwania-urzadzen',
title: 'Koszt energii urządzeń w czuwaniu',
summary: 'Zsumuj zmierzone moce czuwania i oblicz zużycie oraz koszt wybranego okresu.',
description: 'NarzĚdzie przelicza listĚ mocy czuwania na energiĚ pobraną przez podaną liczbĚ godzin i dni. Koszt wynika wyłącznie z wpisanej przez Ciebie stawki za energiĚ i nie obejmuje opłat stałych.',
fields: [
listField('powersW', 'Moce czuwania urządzeń â€” jedna liczba w wierszu', '2\n3\n5', 'W'),
numberField('hoursPerDay', 'Czas czuwania w ciągu doby', 24, 0, 24, 0.1, 'h'),
numberField('days', 'Liczba dni w okresie', 365, 0, 3660, 1, 'dni'),
numberField('pricePerKwh', 'Własna stawka za energiĚ', 0, 0, 1000, 0.01, 'zł/kWh'),
],
sampleValues: { powersW: '2\n3\n5', hoursPerDay: 24, days: 365, pricePerKwh: 0 },
relatedPaths: ,
}, (v) => {
const powers = parseList(v.powersW, 'Moce czuwania', { maxValue: 10000 });
const watts = powers.reduce((sum, value) => sum + value, 0);
const energy = watts * v.hoursPerDay * v.days / 1000;
return result('Bilans energii w czuwaniu', , [
'Energia = suma mocy w watach Ø godziny na dobĚ Ø dni ÷ 1000. Lista zakłada taki sam czas czuwania dla każdej pozycji.',
'Wpisz istniejące odczyty albo dane urządzeń; wynik nie obejmuje okresów ich aktywnej pracy.',
v.pricePerKwh === 0 ? 'Stawka wynosi 0 zł/kWh, wiĚc wynik kosztu wynosi 0 zł. Wprowadź własną stawkĚ, aby obliczyć rzeczywisty wariant kosztowy.' : 'Podana stawka jest Twoim założeniem; kalkulator nie pobiera cen energii ani cennika MSW.',
]);
}),

defineTool({
id: 'energia-i-czas-ogrzania-wody',
title: 'Energia i czas ogrzania wody',
summary: 'Oszacuj energiĚ cieplną i czas przy własnej mocy oraz sprawnoŜci grzania.',
description: 'NarzĚdzie oblicza energiĚ potrzebną do podniesienia temperatury wskazanej objĚtoŜci ciekłej wody. Czas zakłada stałą moc i podaną sprawnoŜć, bez osobnego modelowania strat zbiornika, parowania lub pracy pompy ciepła.',
fields: [
numberField('litres', 'ObjĚtoŜć wody', 100, 0, 1000000, 0.1, 'l'),
numberField('startC', 'Temperatura początkowa', 15, 0, 95, 0.1, '°C'),
numberField('targetC', 'Temperatura docelowa', 40, 0, 95, 0.1, '°C'),
numberField('powerKw', 'Moc pobierana przez układ grzania', 3, 0, 1000, 0.01, 'kW'),
numberField('efficiencyPercent', 'PrzyjĚta sprawnoŜć przekazania energii do wody', 90, 0, 100, 0.1, '%'),
],
sampleValues: { litres: 100, startC: 15, targetC: 40, powerKw: 3, efficiencyPercent: 90 },
relatedPaths: ,
}, (v) => {
const difference = Math.max(0, v.targetC - v.startC);
// Approximate liquid-water model: 1.163 Wh/(litre Ø kelvin), not a property table.
const heatKwh = v.litres * difference * 1.163 / 1000;
const deliveredKw = v.powerKw * v.efficiencyPercent / 100;
const noHeating = heatKwh === 0;
const inputKwh = noHeating ? 0 : v.efficiencyPercent > 0 ? heatKwh / (v.efficiencyPercent / 100) : 'Brak obliczenia przy sprawnoŜci 0%';
const hours = noHeating ? 0 : deliveredKw > 0 ? heatKwh / deliveredKw : 'Nie można ogrzać przy zerowej mocy użytecznej';
return result(noHeating ? 'Nie jest potrzebne podnoszenie temperatury' : deliveredKw > 0 ? 'Idealny bilans ogrzania wody' : 'Brak mocy użytecznej do ogrzania', [
metric('Wzrost temperatury', difference, '°C'), metric('Energia cieplna dla wody', heatKwh, 'kWh'),
metric('Energia pobrana przy podanej sprawnoŜci', inputKwh, typeof inputKwh === 'number' ? 'kWh' : undefined),
metric('Moc użyteczna', deliveredKw, 'kW'), metric('Orientacyjny czas', hours, typeof hours === 'number' ? 'h' : undefined),
], [
'Przybliżenie dla ciekłej wody: 1 litr wymaga około 1,163 Wh na wzrost temperatury o 1°C. To uproszczony model, a właŜciwoŜci wody zmieniają siĚ z temperaturą.',
'Czas = energia cieplna ÷ moc użyteczna. Moc użyteczna = podana moc pobierana Ø sprawnoŜć; nie wpisuj tu współczynnika COP jako procentowej sprawnoŜci.',
v.targetC < v.startC ? 'Temperatura docelowa jest niższa od początkowej. Kalkulator pokazuje brak potrzeby grzania i nie oblicza chłodzenia.' : 'Wynik nie stanowi doboru grzałki, przewodów, zabezpieczeń ani dopuszczalnej temperatury urządzenia.',
]);
}),

defineTool({
id: 'czas-napelniania-z-przeplywu',
title: 'Czas napełniania ze zmierzonego przepływu',
summary: 'Przelicz istniejący pomiar objĚtoŜci i czasu na przepływ oraz pozostały czas napełniania.',
description: 'NarzĚdzie wykorzystuje podaną objĚtoŜć próbki oraz czas jej zebrania i odejmuje wodĚ już znajdującą siĚ w zbiorniku. Wynik zakłada niezmienny przepływ i nie uwzglĚdnia automatycznych przerw ani równoczesnego odpływu.',
fields: [
numberField('targetLitres', 'Docelowa objĚtoŜć w zbiorniku', 1000, 0, 10000000, 0.1, 'l'),
numberField('currentLitres', 'ObjĚtoŜć już znajdująca siĚ w zbiorniku', 200, 0, 10000000, 0.1, 'l'),
numberField('sampleLitres', 'ObjĚtoŜć zebranego pomiaru', 10, 0, 100000, 0.01, 'l'),
numberField('sampleSeconds', 'Czas zbierania pomiaru', 30, 0, 86400, 0.1, 's'),
],
sampleValues: { targetLitres: 1000, currentLitres: 200, sampleLitres: 10, sampleSeconds: 30 },
relatedPaths: ,
}, (v) => {
if (v.sampleSeconds === 0) return inputError('Czas pomiaru musi być wiĚkszy od zera, aby wyznaczyć przepływ.');
const remaining = Math.max(0, v.targetLitres - v.currentLitres);
const flow = v.sampleLitres * 60 / v.sampleSeconds;
const minutes = remaining === 0 ? 0 : flow > 0 ? remaining / flow : 'Nie można wyznaczyć przy zerowym przepływie';
return result(remaining === 0 ? 'Docelowa objĚtoŜć została już osiągniĚta' : flow === 0 ? 'Pomiar wskazuje brak dopływu' : 'Pozostały czas napełniania', [
metric('Zmierzony przepływ', flow, 'l/min'), metric('ObjĚtoŜć do uzupełnienia', remaining, 'l'),
metric('Pozostały czas', minutes, typeof minutes === 'number' ? 'min' : undefined),
metric('Czas w czytelnym zapisie', typeof minutes === 'number' ? duration(minutes * 60) : 'Brak dopływu'),
], );
}),

defineTool({
id: 'bilans-budzetu-poe',
title: 'Bilans mocy i budżetu switcha PoE',
summary: 'Porównaj zapotrzebowanie portów, własny zapas i wspólny budżet PoE.',
description: 'NarzĚdzie sumuje moc przypisaną do portów i porównuje ją z budżetem wybranego switcha. Arytmetyczny zapas nie potwierdza zgodnoŜci standardów PoE, limitów wszystkich portów ani warunków rozruchu urządzeń.',
fields: [
listField('portPowersW', 'Moce wymagane z budżetu switcha â€” jeden port w wierszu', '12\n12\n18\n18', 'W'),
numberField('budgetW', 'Łączny budżet PoE z dokumentacji switcha', 0, 0, 100000, 0.1, 'W'),
numberField('reservePercent', 'Własny zapas doliczany do sumy mocy', 20, 0, 100, 0.1, '%'),
numberField('perPortLimitW', 'Limit jednego portu do dodatkowego porównania', 0, 0, 1000, 0.1, 'W'),
],
sampleValues: { portPowersW: '12\n12\n18\n18', budgetW: 120, reservePercent: 20, perPortLimitW: 30 },
relatedPaths: ,
}, (v) => {
const ports = parseList(v.portPowersW, 'Moce portów', { maxValue: 1000 });
const watts = ports.reduce((sum, value) => sum + value, 0);
const planned = watts * (1 + v.reservePercent / 100);
const exceededPorts = v.perPortLimitW > 0 ? ports.filter((value) => value > v.perPortLimitW).length : null;
const title = v.budgetW === 0 ? 'Wprowadź budżet PoE do porównania'
: watts > v.budgetW ? 'Suma mocy przekracza budżet PoE'
: planned > v.budgetW ? 'Brakuje miejsca na podany zapas mocy'
: exceededPorts > 0 ? 'Sprawdź przekroczenie limitu pojedynczego portu' : 'Suma mieŜci siĚ w podanym budżecie PoE';
return result(title, [
metric('Suma mocy portów', watts, 'W'), metric('Suma z własnym zapasem', planned, 'W'),
metric('Budżet minus suma z zapasem', v.budgetW - planned, 'W'),
metric('Wykorzystanie budżetu bez zapasu', v.budgetW > 0 ? watts / v.budgetW * 100 : 'Nie podano budżetu', v.budgetW > 0 ? '%' : undefined),
metric('Porty ponad podanym limitem', exceededPorts === null ? 'Nie podano limitu portu' : exceededPorts),
], [
'Używaj wartoŜci po tej samej stronie bilansu: mocy wymaganej z budżetu switcha, z uwzglĚdnieniem ograniczeń producenta. Moc samego odbiornika i moc przydzielona przez switch nie muszą być jednakowe.',
'Suma z zapasem = suma mocy Ø (1 + własny zapas procentowy). Wynik ujemny w bilansie oznacza brak mocy na ten wariant.',
'Dodatkowy test zakłada taki sam wpisany limit dla porównywanych portów. Porty o różnych limitach wymagają osobnej oceny dokumentacji.',
]);
}),

defineTool({
id: 'pasmo-rejestratora-nvr',
title: 'Pasmo wejŜciowe rejestratora NVR',
summary: 'Zsumuj strumienie obrazu, dźwiĚku i innych danych oraz porównaj je z limitem wejŜciowym NVR.',
description: 'NarzĚdzie oblicza łączne pasmo przy jednakowym założeniu strumienia dla wskazanej liczby kamer. Wynik dotyczy przepływu danych i nie wyznacza pojemnoŜci dysku, czasu archiwizacji ani zdolnoŜci dekodowania obrazu.',
fields: [
numberField('cameras', 'Liczba kamer', 8, 0, 1024, 1),
numberField('videoMbps', 'Strumień wideo jednej kamery', 6, 0, 1000, 0.01, 'Mb/s'),
numberField('audioKbps', 'Strumień dźwiĚku jednej kamery', 128, 0, 10000, 0.1, 'kb/s'),
numberField('extraMbps', 'Pozostałe strumienie wejŜciowe', 0, 0, 100000, 0.01, 'Mb/s'),
numberField('reservePercent', 'Własny zapas doliczany do sumy', 20, 0, 100, 0.1, '%'),
numberField('incomingLimitMbps', 'Limit pasma wejŜciowego z dokumentacji NVR', 0, 0, 1000000, 0.1, 'Mb/s'),
],
sampleValues: { cameras: 8, videoMbps: 6, audioKbps: 128, extraMbps: 0, reservePercent: 20, incomingLimitMbps: 80 },
relatedPaths: ,
}, (v) => {
const incoming = v.cameras * (v.videoMbps + v.audioKbps / 1000) + v.extraMbps;
const planned = incoming * (1 + v.reservePercent / 100);
return result(v.incomingLimitMbps === 0 ? 'Podaj limit wejŜciowy NVR do porównania' : planned > v.incomingLimitMbps ? 'Suma z zapasem przekracza limit NVR' : 'Suma z zapasem mieŜci siĚ w podanym limicie', [
metric('Suma strumieni wejŜciowych', incoming, 'Mb/s'), metric('Pasmo z własnym zapasem', planned, 'Mb/s'),
metric('Limit minus pasmo z zapasem', v.incomingLimitMbps - planned, 'Mb/s'),
metric('Udział w limicie wejŜciowym', v.incomingLimitMbps > 0 ? planned / v.incomingLimitMbps * 100 : 'Nie podano limitu', v.incomingLimitMbps > 0 ? '%' : undefined),
], [
'Przeliczenie jednostek: 1000 kb/s = 1 Mb/s. Suma obejmuje liczbĚ kamer Ø (wideo + dźwiĚk) oraz dodatkowe strumienie.',
'Dla zmiennego bitrate wpisz właŜciwy dla porównania limit lub pomiar; Ŝrednia z krótkiego okresu nie opisuje każdego szczytu ruchu.',
'Limit wejŜciowy NVR należy odróżnić od limitu wyjŜciowego, wydajnoŜci dekodowania i przepustowoŜci łącza. Własny zapas nie jest parametrem producenta.',
]);
}),

defineTool({
id: 'czas-transferu-kopii',
title: 'Czas przesłania kopii plików',
summary: 'Przelicz rozmiar danych i rzeczywistą lub przyjĚtą przepustowoŜć na czas transferu.',
description: 'NarzĚdzie rozróżnia jednostki dziesiĚtne GB i TB od binarnych GiB i TiB. Wynik opisuje czas przesyłania danych przy stałej efektywnej prĚdkoŜci, bez czasu skanowania, szyfrowania i końcowej weryfikacji kopii.',
fields: , , , ]),
numberField('speedMbps', 'PrĚdkoŜć łącza lub zmierzona prĚdkoŜć transferu', 100, 0, 1000000, 0.01, 'Mb/s'),
numberField('utilizationPercent', 'Wykorzystanie podanej prĚdkoŜci', 80, 0, 100, 0.1, '%'),
],
sampleValues: { size: 100, sizeUnit: 'GB', speedMbps: 100, utilizationPercent: 80 },
relatedPaths: ,
}, (v) => {
const factors = { GB: 1e9, GiB: 2 ** 30, TB: 1e12, TiB: 2 ** 40 };
const bytes = v.size * factors;
const effectiveMbps = v.speedMbps * v.utilizationPercent / 100;
const seconds = bytes === 0 ? 0 : effectiveMbps > 0 ? bytes * 8 / (effectiveMbps * 1e6) : null;
return result(bytes === 0 ? 'Brak danych do przesłania' : seconds === null ? 'Brak efektywnej przepustowoŜci' : 'Czas przesłania podanego zbioru', [
metric('Rozmiar w dziesiĚtnych GB', bytes / 1e9, 'GB'), metric('Efektywna prĚdkoŜć', effectiveMbps, 'Mb/s'),
metric('Czas transferu', seconds === null ? 'Nie można wyznaczyć przy prĚdkoŜci 0' : seconds / 60, seconds === null ? undefined : 'min'),
metric('Czytelny czas transferu', seconds === null ? 'Transfer nie postĚpuje' : duration(seconds)),
], [
'Czas w sekundach = rozmiar w bajtach Ø 8 ÷ efektywna prĚdkoŜć w bitach na sekundĚ. Jednostka Mb/s oznacza megabity, a nie megabajty.',
'JeŜli wpisujesz już zmierzoną prĚdkoŜć kopiowania, wybierz wykorzystanie 100%, aby nie odejmować narzutu ponownie.',
'Wynik nie dowodzi poprawnoŜci kopii; odtworzenie i weryfikacja danych są osobnym zakresem.',
]);
}),

defineTool({
id: 'autonomia-ups-z-pojemnosci',
title: 'Orientacyjna autonomia UPS z Wh i W',
summary: 'Oszacuj czas zasilania na podstawie energii baterii i stałego obciążenia.',
description: 'NarzĚdzie mnoży energiĚ baterii przez przyjĚty udział dostĚpnej pojemnoŜci oraz sprawnoŜć, a nastĚpnie dzieli ją przez obciążenie. To model energetyczny bez krzywych rozładowania, poboru własnego UPS i ograniczeń mocy chwilowej.',
fields: [
numberField('capacityWh', 'Energia baterii przyjĚta do obliczenia', 600, 0, 10000000, 0.1, 'Wh'),
numberField('usablePercent', 'PrzyjĚty dostĚpny udział energii baterii', 80, 0, 100, 0.1, '%'),
numberField('efficiencyPercent', 'PrzyjĚta sprawnoŜć przetwarzania', 85, 0, 100, 0.1, '%'),
numberField('loadW', 'Łączne stałe obciążenie na wyjŜciu', 100, 0, 1000000, 0.1, 'W'),
],
sampleValues: { capacityWh: 600, usablePercent: 80, efficiencyPercent: 85, loadW: 100 },
relatedPaths: ,
}, (v) => {
const availableWh = v.capacityWh * v.usablePercent / 100 * v.efficiencyPercent / 100;
const hours = v.loadW > 0 ? availableWh / v.loadW : null;
return result(v.loadW === 0 ? 'Czas przy zerowym obciążeniu nie jest wyznaczany' : 'Orientacyjny bilans energii UPS', [
metric('Energia dostĚpna w modelu na wyjŜciu', availableWh, 'Wh'), metric('PrzyjĚte obciążenie', v.loadW, 'W'),
metric('Orientacyjna autonomia', hours === null ? 'Wprowadź dodatnie obciążenie' : hours, hours === null ? undefined : 'h'),
metric('Orientacyjna autonomia w minutach', hours === null ? 'Brak obliczenia' : hours * 60, hours === null ? undefined : 'min'),
], [
'Energia dostĚpna = Wh baterii Ø dostĚpny udział Ø sprawnoŜć. Czas = energia dostĚpna ÷ waty obciążenia; nie wpisuj VA w miejsce W.',
'DostĚpny udział i sprawnoŜć są Twoimi założeniami. Wiek baterii, temperatura, próg odłączenia i charakter obciążenia mogą zmienić rzeczywisty czas.',
'Przy zerowym obciążeniu kalkulator nie podaje nieskończonego czasu, ponieważ UPS również zużywa energiĚ. Dobór urządzenia wymaga danych i krzywych właŜciwego modelu.',
]);
}),

defineTool({
id: 'nocne-ladowanie-ev',
title: 'Ładowanie samochodu w nocnym oknie godzin',
summary: 'Porównaj energiĚ do uzupełnienia i czas ładowania z dostĚpnym oknem.',
description: 'NarzĚdzie oblicza wzrost energii akumulatora pomiĚdzy dwoma poziomami naładowania i porównuje go z podanym czasem ładowania. Zakłada stałą Ŝrednią moc oraz sprawnoŜć i nie dobiera instalacji elektrycznej ani zabezpieczeń.',
fields: [
numberField('capacityKwh', 'Użyteczna pojemnoŜć akumulatora samochodu', 70, 0, 1000, 0.1, 'kWh'),
numberField('startPercent', 'Początkowy poziom naładowania', 20, 0, 100, 0.1, '%'),
numberField('targetPercent', 'Docelowy poziom naładowania', 80, 0, 100, 0.1, '%'),
numberField('powerKw', 'średnia moc pobierana podczas ładowania', 7.2, 0, 1000, 0.01, 'kW'),
numberField('efficiencyPercent', 'PrzyjĚty udział energii trafiającej do akumulatora', 90, 0, 100, 0.1, '%'),
numberField('windowHours', 'DostĚpne nocne okno ładowania', 8, 0, 24, 0.1, 'h'),
],
sampleValues: { capacityKwh: 70, startPercent: 20, targetPercent: 80, powerKw: 7.2, efficiencyPercent: 90, windowHours: 8 },
relatedPaths: ,
}, (v) => {
if (v.capacityKwh === 0) return inputError('Podaj dodatnią użyteczną pojemnoŜć akumulatora, aby przeliczyć poziomy naładowania na energiĚ.');
const delta = Math.max(0, v.targetPercent - v.startPercent);
const neededKwh = v.capacityKwh * delta / 100;
const efficiency = v.efficiencyPercent / 100;
const usefulKw = v.powerKw * efficiency;
const inputKwh = neededKwh === 0 ? 0 : efficiency > 0 ? neededKwh / efficiency : null;
const hours = neededKwh === 0 ? 0 : usefulKw > 0 ? neededKwh / usefulKw : null;
const deliveredKwh = Math.min(neededKwh, usefulKw * v.windowHours);
const shortfallKwh = Math.max(0, neededKwh - deliveredKwh);
const finalPercent = neededKwh === 0 ? v.startPercent : Math.min(v.targetPercent, v.startPercent + deliveredKwh / v.capacityKwh * 100);
return result(neededKwh === 0 ? 'Docelowy poziom jest już osiągniĚty' : hours === null ? 'Brak mocy użytecznej do ładowania' : shortfallKwh > 1e-9 ? 'Podane okno nie wystarcza do osiągniĚcia celu' : 'Cel mieŜci siĚ w podanym oknie ładowania', [
metric('Energia do uzupełnienia w akumulatorze', neededKwh, 'kWh'),
metric('Energia pobrana do osiągniĚcia celu', inputKwh === null ? 'Brak obliczenia przy sprawnoŜci 0%' : inputKwh, inputKwh === null ? undefined : 'kWh'),
metric('Czas potrzebny do celu', hours === null ? 'Niemożliwy do wyznaczenia przy zerowej mocy użytecznej' : hours, hours === null ? undefined : 'h'),
metric('Poziom po podanym oknie, z zatrzymaniem na celu', finalPercent, '%'),
metric('Energia brakująca po oknie', shortfallKwh, 'kWh'),
], [
'Energia do uzupełnienia = użyteczna pojemnoŜć Ø dodatnia różnica poziomów naładowania. Czas = energia do uzupełnienia ÷ Ŝrednia moc trafiająca do akumulatora.',
'Podaj Ŝrednią moc możliwą w Twoich warunkach, a nie automatycznie moc maksymalną z nazwy ładowarki. Auto, instalacja, temperatura i ograniczanie mocy mogą zmienić przebieg ładowania.',
'Okno jest podawane jako liczba godzin; kalkulator nie ustala taryf, nie steruje samochodem i nie rezerwuje mocy przyłącza.',
]);
}),

defineTool({
id: 'koszt-modernizacji-oswietlenia',
title: 'Energia i prosty zwrot modernizacji oŜwietlenia',
summary: 'Porównaj energiĚ przed i po zmianie opraw oraz prosty zwrot własnego kosztu modernizacji.',
description: 'NarzĚdzie porównuje zużycie przy tej samej liczbie opraw i tym samym czasie Ŝwiecenia. Zwrot obejmuje wyłącznie zmianĚ kosztu energii i nie potwierdza równoważnoŜci oŜwietlenia, trwałoŜci ani kosztu wykonania usługi.',
fields: [
numberField('count', 'Liczba porównywanych opraw', 10, 0, 100000, 1),
numberField('oldW', 'Moc pobierana przez jedną starą oprawĚ', 50, 0, 10000, 0.1, 'W'),
numberField('newW', 'Moc pobierana przez jedną nową oprawĚ', 8, 0, 10000, 0.1, 'W'),
numberField('hoursPerDay', 'Czas Ŝwiecenia dziennie', 5, 0, 24, 0.1, 'h'),
numberField('daysPerYear', 'Liczba dni Ŝwiecenia w roku', 365, 0, 366, 1, 'dni'),
numberField('pricePerKwh', 'Własna stawka za energiĚ', 0, 0, 1000, 0.01, 'zł/kWh'),
numberField('investment', 'Własny całkowity koszt modernizacji', 0, 0, 100000000, 0.01, 'zł'),
],
sampleValues: { count: 10, oldW: 50, newW: 8, hoursPerDay: 5, daysPerYear: 365, pricePerKwh: 0, investment: 0 },
relatedPaths: ,
}, (v) => {
const annualHours = v.hoursPerDay * v.daysPerYear;
const oldKwh = v.count * v.oldW * annualHours / 1000;
const newKwh = v.count * v.newW * annualHours / 1000;
const savedKwh = oldKwh - newKwh;
const annualSaving = savedKwh * v.pricePerKwh;
let payback;
if (v.investment === 0) payback = 'Nie podano dodatniego kosztu modernizacji';
else if (v.pricePerKwh === 0) payback = 'Nie podano dodatniej stawki za energiĚ';
else if (annualSaving {
const added = parseList(v.newUnits, 'WysokoŜci nowych elementów', { maxValue: 1000, integer: true }).reduce((sum, value) => sum + value, 0);
const planned = v.occupiedU + added + v.reserveU;
return result(planned > v.rackU ? 'Brakuje wysokoŜci dla tego zestawienia' : 'Zestawienie mieŜci siĚ w podanej wysokoŜci', [
metric('WysokoŜć nowych elementów', added, 'U'), metric('ZajĚte i nowe elementy', v.occupiedU + added, 'U'),
metric('Łącznie z własną rezerwą', planned, 'U'), metric('Wolne miejsce po odjĚciu rezerwy', v.rackU - planned, 'U'),
metric('Brakująca wysokoŜć', Math.max(0, planned - v.rackU), 'U'),
], [
'Suma obejmuje zajĚte U, nowe U oraz rezerwĚ. Każdy element wymagający własnej wysokoŜci, także półka lub organizer, powinien być ujĚty w zestawieniu.',
'Wolne U nie gwarantują poprawnego montażu. Wymagania modelu dotyczące masy, szyn, głĚbokoŜci i wentylacji pozostają odrĚbną oceną.',
]);
}),

defineTool({
id: 'ekran-i-odleglosc-projektora',
title: 'Wymiary ekranu i zakres odległoŜci projekcji',
summary: 'Przelicz przekątną i format obrazu na wymiary oraz odległoŜć wynikającą z własnego throw ratio.',
description: 'NarzĚdzie oblicza szerokoŜć i wysokoŜć obrazu oraz zakres odległoŜci z wpisanych współczynników projekcji wybranego modelu. Nie okreŜla punktu mocowania, offsetu, przesuniĚcia obiektywu ani geometrii instalacji UST.',
fields: , , , ]),
numberField('throwMin', 'Najmniejszy throw ratio z dokumentacji modelu', 0, 0, 20, 0.001),
numberField('throwMax', 'NajwiĚkszy throw ratio z dokumentacji modelu', 0, 0, 20, 0.001),
],
sampleValues: { diagonalInches: 120, aspect: '16:9', throwMin: 1.2, throwMax: 1.6 },
relatedPaths: ,
}, (v) => {
if (v.throwMin > v.throwMax) return inputError('Najmniejszy współczynnik projekcji nie może być wiĚkszy od najwiĚkszego. Dla stałego obiektywu wpisz tĚ samą wartoŜć w obu polach.');
const = v.aspect.split(':').map(Number);
const diagonalM = v.diagonalInches * 0.0254;
const widthM = diagonalM * a / Math.hypot(a, b);
const heightM = diagonalM * b / Math.hypot(a, b);
const validRatio = v.throwMin > 0 && v.throwMax > 0;
return result(v.diagonalInches === 0 ? 'Przekątna wynosi zero' : validRatio ? 'Geometria obrazu i odległoŜci według współczynnika' : 'Wymiary obrazu; podaj współczynniki do wyliczenia odległoŜci', [
metric('SzerokoŜć obrazu', widthM * 100, 'cm'), metric('WysokoŜć obrazu', heightM * 100, 'cm'),
metric('Powierzchnia obrazu', widthM * heightM, 'm²'),
metric('Najmniejsza odległoŜć według ratio', validRatio ? widthM * v.throwMin : 'Podaj dodatni współczynnik', validRatio ? 'm' : undefined),
metric('NajwiĚksza odległoŜć według ratio', validRatio ? widthM * v.throwMax : 'Podaj dodatni współczynnik', validRatio ? 'm' : undefined),
], [
'Jeden cal = 2,54 cm. SzerokoŜć wynika z przekątnej i proporcji obrazu; odległoŜć według throw ratio = szerokoŜć obrazu Ø współczynnik.',
'Współczynniki trzeba odczytać dla wybranego modelu, obiektywu i formatu. W przykładzie są jedynie założeniami do demonstracji obliczeń.',
'Punkt odniesienia pomiaru i dokładny zakres ustala dokumentacja producenta. Szczególnie w UST nie należy traktować wyniku jako odstĚpu obudowy od Ŝciany.',
]);
}),

defineTool({
id: 'miesieczny-bilans-deszczowki',
title: 'MiesiĚczny bilans deszczówki i zbiornika',
summary: 'Przelicz opad na dopływ i porównaj dwa porządki poboru wody ze zbiornika.',
description: 'NarzĚdzie łączy rzut powierzchni dachu, miesiĚczny opad, odzysk, zużycie i pojemnoŜć zbiornika. Pokazuje dwa scenariusze kolejnoŜci zdarzeń, ponieważ miesiĚczne sumy nie wystarczają do odtworzenia dziennego stanu wody.',
fields: [
numberField('roofAreaM2', 'Poziomy rzut dachu objĚtego odzyskiem', 200, 0, 100000, 0.1, 'm²'),
numberField('rainfallMm', 'Opad w analizowanym miesiącu z własnych danych', 60, 0, 3000, 0.1, 'mm'),
numberField('recoveryPercent', 'PrzyjĚty udział odzyskanego opadu', 80, 0, 100, 0.1, '%'),
numberField('tankLitres', 'Użyteczna pojemnoŜć zbiornika', 5000, 0, 10000000, 0.1, 'l'),
numberField('initialLitres', 'Stan wody na początku miesiąca', 1000, 0, 10000000, 0.1, 'l'),
numberField('demandLitres', 'Zużycie wody w analizowanym miesiącu', 3000, 0, 10000000, 0.1, 'l'),
],
sampleValues: { roofAreaM2: 200, rainfallMm: 60, recoveryPercent: 80, tankLitres: 5000, initialLitres: 1000, demandLitres: 3000 },
relatedPaths: ,
}, (v) => {
if (v.initialLitres > v.tankLitres) return inputError('Początkowy stan wody nie może przekraczać użytecznej pojemnoŜci zbiornika.');
const inflow = v.roofAreaM2 * v.rainfallMm * v.recoveryPercent / 100;
const rainFirstWater = Math.min(v.tankLitres, v.initialLitres + inflow);
const rainFirstOverflow = Math.max(0, v.initialLitres + inflow - v.tankLitres);
const rainFirstUsed = Math.min(v.demandLitres, rainFirstWater);
const demandFirstUsed = Math.min(v.initialLitres, v.demandLitres);
const demandFirstBeforeRain = v.initialLitres - demandFirstUsed;
const demandFirstEnd = Math.min(v.tankLitres, demandFirstBeforeRain + inflow);
const demandFirstOverflow = Math.max(0, demandFirstBeforeRain + inflow - v.tankLitres);
return result('Bilans miesiąca w dwóch scenariuszach kolejnoŜci', [
metric('Dopływ po uwzglĚdnieniu odzysku', inflow, 'l'),
metric('Opad przed zużyciem: pokryte zużycie', rainFirstUsed, 'l'),
metric('Opad przed zużyciem: niedobór', v.demandLitres - rainFirstUsed, 'l'),
metric('Opad przed zużyciem: stan końcowy', rainFirstWater - rainFirstUsed, 'l'),
metric('Opad przed zużyciem: przelew', rainFirstOverflow, 'l'),
metric('Zużycie przed opadem: niedobór', v.demandLitres - demandFirstUsed, 'l'),
metric('Zużycie przed opadem: stan końcowy', demandFirstEnd, 'l'),
metric('Zużycie przed opadem: przelew', demandFirstOverflow, 'l'),
], [
'Dopływ w litrach = poziomy rzut dachu w m² Ø opad w mm Ø przyjĚty udział odzysku. Jeden milimetr opadu na jednym metrze kwadratowym odpowiada jednemu litrowi.',
'Scenariusz pierwszy przyjmuje cały dopływ przed całym poborem; drugi â€” cały pobór przed dopływem. Nadmiar ponad pojemnoŜć odpływa przelewem i nie jest później dostĚpny.',
'To dwa przykłady kolejnoŜci, a nie gwarantowany przedział wyników. Naprzemienne opady i pobory mogą dać inne pokrycie zużycia; do oceny zbiornika potrzebny jest dokładniejszy harmonogram.',
]);
}),

defineTool({
id: 'moc-ogrzewanej-powierzchni',
title: 'Powierzchnia i moc planowanego ogrzewania zewnĚtrznego',
summary: 'Odejmij przeszkody od pola ogrzewania i przelicz własną gĚstoŜć mocy na łączne zapotrzebowanie.',
description: 'NarzĚdzie oblicza powierzchniĚ netto tarasu lub podjazdu i mnoży ją przez wpisaną planowaną moc jednostkową. Wynik jest zestawieniem zapotrzebowania i nie dobiera przewodów, rozstawu grzania, zabezpieczeń ani warstw nawierzchni.',
fields: [
numberField('grossAreaM2', 'Cała analizowana powierzchnia', 60, 0, 100000, 0.1, 'm²'),
numberField('excludedAreaM2', 'Łączna powierzchnia wyłączona przez przeszkody', 10, 0, 100000, 0.1, 'm²'),
numberField('plannedWPerM2', 'Planowana gĚstoŜć mocy z własnych założeń lub projektu', 0, 0, 5000, 0.1, 'W/m²'),
],
sampleValues: { grossAreaM2: 60, excludedAreaM2: 10, plannedWPerM2: 250 },
relatedPaths: ,
}, (v) => {
if (v.excludedAreaM2 > v.grossAreaM2) return inputError('Powierzchnia wyłączona nie może być wiĚksza od całej analizowanej powierzchni.');
const net = v.grossAreaM2 - v.excludedAreaM2;
const watts = net * v.plannedWPerM2;
return result(net === 0 ? 'Nie pozostała powierzchnia do ogrzewania' : v.plannedWPerM2 === 0 ? 'Podaj planowaną gĚstoŜć mocy' : 'Zapotrzebowanie dla wpisanej powierzchni i gĚstoŜci', , [
'Powierzchnia netto = cała powierzchnia minus wyłączenia. Moc = powierzchnia netto Ø wpisana gĚstoŜć mocy.',
'Nie sumuj dwa razy nakładających siĚ wyłączeń. Przykładowa gĚstoŜć służy demonstracji i nie jest rekomendacją dla konkretnego tarasu lub podjazdu.',
'Wynik nie jest doborem zabezpieczeń ani potwierdzeniem możliwoŜci zasilania. WłaŜciwe rozwiązanie wymaga projektu i parametrów nawierzchni oraz instalacji.',
]);
}),

defineTool({
id: 'bilans-nawiewu-i-wywiewu',
title: 'Bilans zmierzonych nawiewów i wywiewów',
summary: 'Zsumuj wyniki pomiarów z anemostatów i porównaj dwie strony bilansu powietrza.',
description: 'NarzĚdzie zestawia podane strumienie nawiewu i wywiewu w tej samej jednostce i trybie pracy. Różnica sum nie potwierdza zgodnoŜci wentylacji z projektem ani prawidłowych przepływów w każdym pomieszczeniu.',
fields: [
listField('supplyFlows', 'Nawiewy z pomiaru â€” jedna liczba w wierszu', '30\n40\n50', 'm³/h'),
listField('extractFlows', 'Wywiewy z pomiaru â€” jedna liczba w wierszu', '45\n35\n40', 'm³/h'),
numberField('tolerancePercent', 'Własne kryterium różnicy wzglĚdem Ŝredniej obu sum', 5, 0, 200, 0.1, '%'),
],
sampleValues: { supplyFlows: '30\n40\n50', extractFlows: '45\n35\n40', tolerancePercent: 5 },
relatedPaths: ,
}, (v) => {
const supply = parseList(v.supplyFlows, 'Strumienie nawiewu', { maxValue: 100000 }).reduce((sum, value) => sum + value, 0);
const extract = parseList(v.extractFlows, 'Strumienie wywiewu', { maxValue: 100000 }).reduce((sum, value) => sum + value, 0);
const difference = supply - extract;
const mean = (supply + extract) / 2;
const relative = mean > 0 ? Math.abs(difference) / mean * 100 : null;
return result(mean === 0 ? 'Brak dodatnich strumieni do porównania' : relative > v.tolerancePercent ? 'Różnica przekracza własne kryterium' : 'Różnica mieŜci siĚ we własnym kryterium', [
metric('Suma nawiewów', supply, 'm³/h'), metric('Suma wywiewów', extract, 'm³/h'),
metric('Nawiew minus wywiew', difference, 'm³/h'),
metric('BezwzglĚdna różnica wzglĚdem Ŝredniej sum', relative === null ? 'Nie wyznacza siĚ przy dwóch zerowych sumach' : relative, relative === null ? undefined : '%'),
], [
'Różnica procentowa = bezwzglĚdna różnica sum ÷ Ŝrednia arytmetyczna sum Ø 100. Przy przepływie tylko po jednej stronie wynosi 200%, ponieważ mianownikiem jest Ŝrednia obu stron.',
'Dodatni wynik nawiew minus wywiew oznacza wiĚkszą sumĚ wpisanych nawiewów; sam ten wynik nie jest pomiarem ciŜnienia w budynku.',
'Własne kryterium nie jest przywołaniem normy. Porównuj pomiary z tego samego trybu i czasu, a zgodnoŜć poszczególnych pomieszczeń zlecaj wzglĚdem projektu.',
]);
}),

defineTool({
id: 'liczba-portow-sieciowych',
title: 'Liczba portów sieciowych i rezerwa rozbudowy',
summary: 'Zsumuj punkty końcowe, porty łączące urządzenia i własną rezerwĚ przyszłych połączeń.',
description: 'NarzĚdzie oblicza liczbĚ portów fizycznych potrzebnych w jednej analizowanej puli przełącznika lub szafy. Bilans nie potwierdza przepustowoŜci, budżetu PoE, zgodnoŜci modułów ani projektu całej sieci.',
fields: [
numberField('clientPorts', 'Porty komputerów, telewizorów i innych klientów', 8, 0, 100000, 1),
numberField('apPorts', 'Porty punktów dostĚpowych Wi-Fi', 3, 0, 100000, 1),
numberField('cameraPorts', 'Porty kamer', 6, 0, 100000, 1),
numberField('otherPorts', 'Pozostałe porty urządzeń końcowych', 1, 0, 100000, 1),
numberField('uplinkPorts', 'Porty połączeń miĚdzy urządzeniami zajmujące tĚ samą pulĚ', 2, 0, 100000, 1),
numberField
