# Planer usług dla domu — 30 narzędzi

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

Zaktualizowano: 2026-10-12T21:01:52+00:00

Przejdź do treści

MSWSUPER SERWISTechnika Twojego domuUsługiBlogPlaner usługKontakt570 933 114

MSW SUPER SERWIS · PLANER DLA TWOJEGO DOMU

## Dobrze zaplanowana instalacja
zaczyna się od konkretów.

Sprawdź parametry, uporządkuj budżet i przygotuj zakres prac. Wybierz narzędzie, wpisz własne dane i zachowaj wynik do rozmowy.

Wybierz narzędzieOmów usługę: 570 933 114

30 osobnych narzędzi4 obszary planowaniaTwój zapis i eksport

Czego potrzebujesz?

ObszarWszystkie narzędziaObliczeniaWycenaOrganizacjaZamówienie

Dostępne narzędzia: 30 z 30.

Obliczenia01

## Koszt energii urządzeń w czuwaniu

Zsumuj zmierzone moce czuwania i oblicz zużycie oraz koszt wybranego okresu.

Otwórz narzędzie ↗

Obliczenia02

## Energia i czas ogrzania wody

Oszacuj energię cieplną i czas przy własnej mocy oraz sprawności grzania.

Otwórz narzędzie ↗

Obliczenia03

## Czas napełniania ze zmierzonego przepływu

Przelicz istniejący pomiar objętości i czasu na przepływ oraz pozostały czas napełniania.

Otwórz narzędzie ↗

Obliczenia04

## Bilans mocy i budżetu switcha PoE

Porównaj zapotrzebowanie portów, własny zapas i wspólny budżet PoE.

Otwórz narzędzie ↗

Obliczenia05

## Pasmo wejściowe rejestratora NVR

Zsumuj strumienie obrazu, dźwięku i innych danych oraz porównaj je z limitem wejściowym NVR.

Otwórz narzędzie ↗

Obliczenia06

## Czas przesłania kopii plików

Przelicz rozmiar danych i rzeczywistą lub przyjętą przepustowość na czas transferu.

Otwórz narzędzie ↗

Obliczenia07

## Orientacyjna autonomia UPS z Wh i W

Oszacuj czas zasilania na podstawie energii baterii i stałego obciążenia.

Otwórz narzędzie ↗

Obliczenia08

## Ładowanie samochodu w nocnym oknie godzin

Porównaj energię do uzupełnienia i czas ładowania z dostępnym oknem.

Otwórz narzędzie ↗

Obliczenia09

## Energia i prosty zwrot modernizacji oświetlenia

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

Otwórz narzędzie ↗

Obliczenia10

## Bilans wysokości szafy rack w U

Dodaj wysokości urządzeń i własną rezerwę, aby sprawdzić wolne miejsce w szafie.

Otwórz narzędzie ↗

Obliczenia11

## Wymiary ekranu i zakres odległości projekcji

Przelicz przekątną i format obrazu na wymiary oraz odległość wynikającą z własnego throw ratio.

Otwórz narzędzie ↗

Obliczenia12

## Miesięczny bilans deszczówki i zbiornika

Przelicz opad na dopływ i porównaj dwa porządki poboru wody ze zbiornika.

Otwórz narzędzie ↗

Obliczenia13

## Powierzchnia i moc planowanego ogrzewania zewnętrznego

Odejmij przeszkody od pola ogrzewania i przelicz własną gęstość mocy na łączne zapotrzebowanie.

Otwórz narzędzie ↗

Obliczenia14

## Bilans zmierzonych nawiewów i wywiewów

Zsumuj wyniki pomiarów z anemostatów i porównaj dwie strony bilansu powietrza.

Otwórz narzędzie ↗

Obliczenia15

## Liczba portów sieciowych i rezerwa rozbudowy

Zsumuj punkty końcowe, porty łączące urządzenia i własną rezerwę przyszłych połączeń.

Otwórz narzędzie ↗

Wycena16

## Budżet etapów montażu

Zestaw koszty dostawy, przygotowania, montażu i uruchomienia.

Otwórz narzędzie ↗

Wycena17

## Rezerwa dla wskazanych pozycji budżetu

Policz rezerwę dla poszczególnych niepewnych kosztów.

Otwórz narzędzie ↗

Wycena18

## Wpływ zmiany zakresu prac

Oblicz różnicę kosztu i nakładu czasu po dodaniu lub rezygnacji z prac.

Otwórz narzędzie ↗

Wycena19

## Podział płatności na etapy

Sprawdź zgodność własnych rat z pełną kwotą projektu.

Otwórz narzędzie ↗

Wycena20

## Koszt posiadania instalacji

Połącz zakup, energię i obsługę we własnym horyzoncie lat.

Otwórz narzędzie ↗

Organizacja21

## Wstępne sprawdzenie przejścia dla opakowania

Porównaj prostokątne przejście z dwoma ustawieniami opakowania.

Otwórz narzędzie ↗

Organizacja22

## Plan prac w dostępnym oknie domowym

Sprawdź, czy kolejne etapy i przerwy mieszczą się w podanym czasie.

Otwórz narzędzie ↗

Organizacja23

## Nakład konfiguracji wielu urządzeń

Zlicz konfigurację seryjną, ustawienia wspólne, testy i dokumentację.

Otwórz narzędzie ↗

Organizacja24

## Nakład prób dla stref i funkcji

Policz liczbę prób oraz czas przygotowania i zapisania wyników.

Otwórz narzędzie ↗

Organizacja25

## Zbiorcze zestawienie urządzeń domu

Uporządkuj ilości urządzeń według nazw i pomieszczeń.

Otwórz narzędzie ↗

Zamówienie26

## Robocza macierz dostępu do wejść

Połącz role, wybrane wejścia i cel dostępu bez zapisywania sekretów.

Otwórz narzędzie ↗

Zamówienie27

## Podział odpowiedzialności w zleceniu

Wskaż, kto odpowiada za dostawę, przyłącza, integrację i odbiór.

Otwórz narzędzie ↗

Zamówienie28

## Robocza kolejność zgłoszeń modernizacyjnych

Porównaj własne oceny stanu, użytkowania i skutków przestoju.

Otwórz narzędzie ↗

Zamówienie29

## Brief realizacji pod nieobecność właściciela

Ustal kontakt, zastępstwo, granice prac i dodatkowe akceptacje.

Otwórz narzędzie ↗

Zamówienie30

## Porównanie funkcji trzech wariantów wyposażenia

Porównaj trzy propozycje według własnych kryteriów i ocen.

Otwórz narzędzie ↗

Nie ma narzędzi dla tego wyszukiwania. Skróć hasło lub wybierz wszystkie obszary.

TWOJE DANE, TWÓJ ZAKRES

## Wynik, do którego możesz wrócić

Każde narzędzie pozwala zapisać szkic w przeglądarce, pobrać plik i odtworzyć go później. Gotowy wynik możesz skopiować, wydrukować lub przygotować do rozmowy na WhatsApp. Dane pozostają na Twoim urządzeniu do chwili, gdy zdecydujesz się je przekazać.

Kwoty wynikają z Twoich danych i założeń. Zakres, cenę oraz termin prac MSW potwierdza indywidualnie.

Uzgodnij usługę ↗Zobacz zakres usług ↗Pozostałe narzędzia MSW ↗

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
