Może ten temat coś podpowie:
Taką stronę znalazłem:
https://energy.instrat.pl/
Nie napisałem, że cena publikacji w bieżącym miesiącu to cena rozliczenia RCEm za bieżący miesiąc.
Próbowałem pobierać dane za pomocą NodeRed i przez MQTT ssać do HASS, ale niestety nie udało mi się. Od przyszłego roku rozliczanie ma być godzinowe więc będzie jeszcze ciekawiej by zrealizować taki projekt
Poszukuję idei jak wyliczyć ile zostało mi prądu z nadprodukcji paneli, rozliczam się na zasadzie opustu (stare zasady).
Ja monitoruję stan “magazynu” moich teściów w postaci dashboardu w grafanie. Dane są przechowywane w MySQL’u do którego trafiają po odczytaniu przez skrypt w nodejs łączący się z tauronem i solaredge’em. Będę chciał to przerobić na addon do HA żeby całe odczytywanie danych opierało się tylko na HA a nie dodatkowych systemach.
Aktualnie pracuję nad wersją dla swojej fotowoltaiki - będzie oparta o influxdb do którego dane będą trafiały bezpośrednio z urządzeń podpiętych pod HA - mam za głównymi bezpiecznikami założony Zamel MEW-01 a dane z falownika (Solplanet) mam odczytywane na bieżąco RESTful sensorem.
W takiej sytuacji wystarczy query:
SELECT oddane * 0.8 - pobrane FROM (SELECT value as oddane FROM “home_assistant”.“autogen”.“kWh” where “entity_id”=‘licznik_glowny_total_reverse_active_energy’), (SELECT value as pobrane FROM “home_assistant”.“autogen”.“kWh” where “entity_id”=‘licznik_glowny_total_forward_active_energy’) WHERE time > :dashboardTime: AND time < :upperDashboardTime: GROUP BY time(:interval:) FILL(previous)
Powyższe query można łatwo przerobić na template sensor w HA żeby zrezygnować z korzystania z influxdb / grafany.
Czego mi brakuje w moich pomysłach to rozliczanie zużycia po 12 msc kiedy część energii może przepaść.
1 Like
Czy ktoś ma aktualną wersję do G12W która działa?
Czytam i czytam i za nic nie moge tego uruchomić.
Nie zależy mi aktualnie na odliczaniu tych 2000kWh czy 3000kWh (według aktualnego stanu) ponieważ już dawno przekroczyłem…
Trochę odkopuję temat, ale mam dwa pytania.
Jak macie zrealizowane włacznie danej taryfy (tania/droga)? Ja na ten moment robie to w NR, ale to dość niewygodne, bo nowe sprzety muszę dodawać tam by taryfę liczyło 
Może da sie to jakoś inaczej zrobić?
Inna sprawa to u mnie jest Enea a tania taryfa nie jest tylko w weekendy ale:
Od poniedziałku do piątku w dniu robocze od 21:00 do 6:00 oraz we wszystkie godziny doby sobót, niedziel i innych dni ustawowo wolnych od pracy
Czyli przełączanie musiałoby też wykrywać dni ustawowo wolne od pracy jak święta. Jak to ogarnąć?
Nie wiem czy się uda, ale jest standardowa integracja workday (zwraca true w dni robocze, będą zaraz święta to sobie sprawdzisz jak działa przy standardowych ustawieniach dla PL).
A zmiana taryf jest opisana w dokumentacji HA.
taka integracja już jest GitHub - jacek2511/ha_rce: Rynkowa cena energii elektrycznej (RCE)
Cześć,
Czy mógłbyś udostępnić kompletny kod tego dashboardu? Czegoś takiego właśnie potrzebuję.
Mam co prawda jakieś swoje statystyki, ale mały ogląd na całą sytuację i zwłaszcza koszty (robię to inaczej, na podstawie danych wyciągniętych z bazy HA), niestety kiedyś podjąłem decyzję o użyciu InfluxDB 2, gdzie językiem zapytań jest Flux, a nie SQL, niemniej jednak chciałbym zapożyczyć logikę, żeby opracować u siebie one-view dashboard.
Witamy na forum.
To nie jest część UI HA, tylko Grafana. Umożliwia z tego co wiem wizualizacje danych z InfluxDb v2.0.
1 Like
Nie no, widzę, że to Grafana
U siebie też oprócz HA mam Grafanę + InfluxDB 2.
I proszę kolegę @zmszaman o udostępnienie kodu tego dashboardu, choć przypuszczam, że on ma u siebie InfluxDB 1.
Cześć, przyznam się szczerze, że dashboard w takiej postaci nie został jeszcze u mnie przeniesiony na dane w influxie ale dalej korzysta z mysql. Za to na swoje potrzeby (tamten dashboard był do monitorowania instalacji od teściów) mam przygotowany dashboard na influxdb 2 (mam 2 bo 1 nie wspierała pewnych funkcji które potrzebowałem do analizy danych).
Dashboard (a w zasadzie dashboardy) wyglądają tak:
- Ogólny podgląd produkcji z PV
- Monitorowanie kosztów prądu
Dane do podanych dashboardów są zbierane z kilku źródeł
- Dane odnośnie cen RCEm i RCEt są pobierane addonem GitHub - zbigniewmotyka/ha-addons - zależało mi na pobraniu danych historycznych a z tego co wiem to HA nie umożliwia zapisywania danych przyporządkowanych do daty z przeszłości (jeśli ktoś zna na to sposób to chętnie go poznam). Dane z dodatku są pobierane bezpośrednio do influxdb 2 za pomocą poniższego taska i są wrzucane do osobnego bucketu (
energy_prices).
Task RCEt i RCEm
import "csv"
import "http/requests"
option task = {
name: "import RCEt and RCEm",
cron: "0 20 * * *",
}
responseRCEM = requests.get(url: "http://homeassistantip:8099/api/rcem/csv")
csv.from(csv: string(v: responseRCEM.body))
|> to(bucket: "energy_prices")
responseRCET = requests.get(url: "http://homeassistantip:8099/api/rcet/csv")
csv.from(csv: string(v: responseRCET.body))
|> to(bucket: "energy_prices")
- Dane odnośnie produkcji z PV, pobranej energii / zużycia są pobierane z bucketu
home_assistantale po wcześniejszym obrobieniu tych danych. W tym celu w influxdb 2 mam stworzony osobny bucket o nazwiegrid_statsktóry dla każdej godziny zawiera informacje na temat:- Ilości energii pobranej / oddanej do sieci uwzględniając bilansowanie godzinowe i bez uwzględnienia bilansowania.
- Ilość wyprodukowanej energii przez PV.
- Ilość energii użytej do naładowania i rozładowania magazynu energii.
- Zużycie energii w domu.
- W ilu procentach energia zużyta w domu została w danej godzinie zaspokojona energią z sieci.
- Obrobienie danych z HA odbywa się za pomocą taska w influxdb 2 (wartość
START_DATEokreśla od kiedy chcemy zacząć obrabianie danych - u mnie jest to data montażu PV).
Task do przygotowania danych z HA
option task = {name: "Electric grid stats", every: 1h, offset: 15m}
START_DATE = 2023-07-01T00:00:00Z
data =
from(bucket: "home_assistant")
|> range(start: START_DATE)
|> filter(
fn: (r) =>
(r["entity_id"] == "licznik_glowny_total_reverse_active_energy" or r["entity_id"]
==
"licznik_glowny_total_forward_active_energy" or r["entity_id"]
==
"asw10kh_t1_suma" or r["entity_id"]
==
"solplanet_battery_invsn_battery_energy_for_charging"
or
r["entity_id"]
==
"solplanet_battery_invsn_battery_energy_for_discharging")
and
r["_field"] == "value",
)
|> aggregateWindow(every: 1h, fn: max, createEmpty: true)
|> fill(usePrevious: true)
|> pivot(rowKey: ["_time"], columnKey: ["entity_id"], valueColumn: "_value")
|> difference(
initialZero: true,
nonNegative: true,
columns: [
"solplanet_battery_invsn_battery_energy_for_charging",
"solplanet_battery_invsn_battery_energy_for_discharging",
],
)
|> difference(
columns: [
"licznik_glowny_total_reverse_active_energy",
"licznik_glowny_total_forward_active_energy",
"asw10kh_t1_suma",
],
)
|> map(
fn: (r) => {
balanced_active_energy =
r.licznik_glowny_total_forward_active_energy
-
r.licznik_glowny_total_reverse_active_energy
balanced_forward_active_energy =
if r.licznik_glowny_total_forward_active_energy
>
r.licznik_glowny_total_reverse_active_energy
then
r.licznik_glowny_total_forward_active_energy
-
r.licznik_glowny_total_reverse_active_energy
else
0.0
balanced_reverse_active_energy =
if r.licznik_glowny_total_reverse_active_energy
>
r.licznik_glowny_total_forward_active_energy
then
r.licznik_glowny_total_reverse_active_energy
-
r.licznik_glowny_total_forward_active_energy
else
0.0
solar_generated = r.asw10kh_t1_suma
battery_charged = r.solplanet_battery_invsn_battery_energy_for_charging
battery_discharged =
r.solplanet_battery_invsn_battery_energy_for_discharging
home_usage =
solar_generated - balanced_reverse_active_energy - battery_charged
+
balanced_forward_active_energy + battery_discharged
return {
_time: r._time,
_measurement: r._measurement,
balanced_active_energy: balanced_active_energy,
balanced_forward_active_energy: balanced_forward_active_energy,
balanced_reverse_active_energy: balanced_reverse_active_energy,
unbalanced_forward_active_energy: r.licznik_glowny_total_forward_active_energy,
unbalanced_reverse_active_energy: r.licznik_glowny_total_reverse_active_energy,
solar_generated: solar_generated,
home_usage: home_usage,
grid_energy_usage_ratio: balanced_forward_active_energy / home_usage * 100.0,
battery_charged: battery_charged,
battery_discharged: battery_discharged,
}
},
)
balanced =
data
|> keep(columns: ["_time", "_measurement", "balanced_active_energy"])
|> rename(columns: {balanced_active_energy: "_value"})
|> set(key: "_field", value: "balanced_active_energy")
balanced_total =
balanced
|> cumulativeSum()
|> set(key: "_field", value: "balanced_active_energy_total")
balanced_forward =
data
|> keep(columns: ["_time", "_measurement", "balanced_forward_active_energy"])
|> rename(columns: {balanced_forward_active_energy: "_value"})
|> set(key: "_field", value: "balanced_forward_active_energy")
balanced_forward_total =
balanced_forward
|> cumulativeSum()
|> set(key: "_field", value: "balanced_forward_active_energy_total")
balanced_reverse =
data
|> keep(columns: ["_time", "_measurement", "balanced_reverse_active_energy"])
|> rename(columns: {balanced_reverse_active_energy: "_value"})
|> set(key: "_field", value: "balanced_reverse_active_energy")
balanced_reverse_total =
balanced_reverse
|> cumulativeSum()
|> set(key: "_field", value: "balanced_reverse_active_energy_total")
unbalanced_forward =
data
|> keep(columns: ["_time", "_measurement", "unbalanced_forward_active_energy"])
|> rename(columns: {unbalanced_forward_active_energy: "_value"})
|> set(key: "_field", value: "unbalanced_forward_active_energy")
unbalanced_forward_total =
unbalanced_forward
|> cumulativeSum()
|> set(key: "_field", value: "unbalanced_forward_active_energy_total")
unbalanced_reverse =
data
|> keep(columns: ["_time", "_measurement", "unbalanced_reverse_active_energy"])
|> rename(columns: {unbalanced_reverse_active_energy: "_value"})
|> set(key: "_field", value: "unbalanced_reverse_active_energy")
unbalanced_reverse_total =
unbalanced_reverse
|> cumulativeSum()
|> set(key: "_field", value: "unbalanced_reverse_active_energy_total")
solar_generated =
data
|> keep(columns: ["_time", "_measurement", "solar_generated"])
|> rename(columns: {solar_generated: "_value"})
|> set(key: "_field", value: "solar_generated")
solar_generated_total =
solar_generated
|> cumulativeSum()
|> set(key: "_field", value: "solar_generated_total")
home_usage =
data
|> keep(columns: ["_time", "_measurement", "home_usage"])
|> rename(columns: {home_usage: "_value"})
|> set(key: "_field", value: "home_usage")
home_usage_total =
home_usage
|> cumulativeSum()
|> set(key: "_field", value: "home_usage_total")
grid_energy_usage_ratio =
data
|> keep(columns: ["_time", "grid_energy_usage_ratio"])
|> rename(columns: {grid_energy_usage_ratio: "_value"})
|> set(key: "_measurement", value: "%")
|> set(key: "_field", value: "grid_energy_usage_ratio")
battery_charged =
data
|> keep(columns: ["_time", "_measurement", "battery_charged"])
|> rename(columns: {battery_charged: "_value"})
|> set(key: "_field", value: "battery_charged")
battery_charged_total =
battery_charged
|> cumulativeSum()
|> set(key: "_field", value: "battery_charged_total")
battery_discharged =
data
|> keep(columns: ["_time", "_measurement", "battery_discharged"])
|> rename(columns: {battery_discharged: "_value"})
|> set(key: "_field", value: "battery_discharged")
battery_discharged_total =
battery_discharged
|> cumulativeSum()
|> set(key: "_field", value: "battery_discharged_total")
union(
tables: [
balanced,
balanced_total,
balanced_forward,
balanced_forward_total,
balanced_reverse,
balanced_reverse_total,
unbalanced_forward,
unbalanced_forward_total,
unbalanced_reverse,
unbalanced_reverse_total,
solar_generated,
solar_generated_total,
home_usage,
home_usage_total,
grid_energy_usage_ratio,
battery_charged,
battery_charged_total,
battery_discharged,
battery_discharged_total,
],
)
|> group(columns: ["_field"])
|> to(bucket: "grid_stats")
W powyższym tasku użyte są następujące encje z HA:
licznik_glowny_total_reverse_active_energy- łączna ilość energii oddanej do siecilicznik_glowny_total_forward_active_energy- łączna ilość energii pobranej z sieciasw10kh_t1_suma- łączna ilość energii wyprodukowanej przez PVsolplanet_battery_invsn_battery_energy_for_charging- Ilość energii W DANYM DNIU użyta do ładowania magazynu energiisolplanet_battery_invsn_battery_energy_for_discharging- Ilość energii W DANYM DNIU pobrana z magazynu energii
Na podstawie takich danych można zrobić dashboardy:
- ogolne.json (19,4 KB)
- ceny.json (45,3 KB)
Do powyższych dashboardów można jeszcze dodać informację na temat pracy magazynu energii (ilość energii użytej do ładowania magazynu oraz pobranej z magazynu).
Druga kwestia to ceny w taryfach G11, G12, G12w, G13 - nie są pobierane z żadnego bucketu z influxa tylko są jako hardcode’y we fluxie. Jest to wystarczające do porównania która taryfa się najbardziej opłaca ale może rodzić problemy w momencie zmiany cennika.
Na wykresie Sprzedaż energii po cenach RCEt są dwie wartości:
balanced_reverse_active_energy_value_total- Pokazuje faktyczną kwotę związaną z oddawaniem prądu do sieci.balanced_reverse_active_energy_value_total_without_minus- Symuluje sytuację w której w razie ujemnych cen prądu wyłączamy falownik.
2 Likes
Natomiast jeśli masz ochotę przepisać dasboard z mysql na influxa to tak on wygląda:
dane na temat produkcji / oddanej i pobranej energii są przechowywane w bazie tabeli o takiej strukturze:
Tabela
CREATE TABLE `energy` (
`id` int(11) NOT NULL,
`date` datetime NOT NULL,
`solar_generation` int(11) NOT NULL DEFAULT 0,
`tauron_usage` decimal(10,4) NOT NULL DEFAULT 0.0000,
`tauron_oze` decimal(10,4) NOT NULL DEFAULT 0.0000
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3 COLLATE=utf8mb3_general_ci;
ALTER TABLE `energy`
ADD PRIMARY KEY (`id`),
ADD UNIQUE KEY `date` (`date`);
ALTER TABLE `energy`
MODIFY `id` int(11) NOT NULL AUTO_INCREMENT;
W tabeli mam dane zapisywane co 15 minut odnośnie produkcji PV (falownik solaredge poprzez api raportuje dane co taką ilość minut), natomiast odnośnie pobierania / oddawania danych do sieci dane są zapisywane o pełnej godzinie (podczas scrapowania danych z elicznika taurony możliwy jest odczyt co godzinę). Próbka danych poniżej:
Próbka danych
INSERT INTO `energy` (`id`, `date`, `solar_generation`, `tauron_usage`, `tauron_oze`) VALUES
(1375120, '2022-09-02 15:00:00', 693, 0.0000, 4431.0000),
(1375121, '2022-09-02 15:15:00', 1396, 0.0000, 0.0000),
(1375122, '2022-09-02 15:30:00', 1681, 0.0000, 0.0000),
(1375123, '2022-09-02 15:45:00', 1408, 0.0000, 0.0000),
(1375124, '2022-09-02 16:00:00', 547, 427.0000, 1214.0000),
(1375125, '2022-09-02 16:15:00', 583, 0.0000, 0.0000),
(1375126, '2022-09-02 16:30:00', 483, 0.0000, 0.0000),
(1375127, '2022-09-02 16:45:00', 511, 0.0000, 0.0000),
(1375128, '2022-09-02 17:00:00', 524, 625.0000, 611.0000),
(1375129, '2022-09-02 17:15:00', 275, 0.0000, 0.0000),
(1375130, '2022-09-02 17:30:00', 240, 0.0000, 0.0000),
(1375131, '2022-09-02 17:45:00', 302, 0.0000, 0.0000);
Oprócz tego baza danych zawiera też informację o cenach prądu (trzeba uzupełnić bo jest to nieaktualne, ale w zasadzie nikt nie patrzy na te tabelki w dashboardzie ):
Pozostałe tabele
CREATE TABLE `prices` (
`id` int(10) UNSIGNED NOT NULL,
`date` date NOT NULL,
`g11` decimal(10,6) NOT NULL,
`g12_day` decimal(10,6) NOT NULL,
`g12_night` decimal(10,6) NOT NULL,
`g12w_day` decimal(10,6) NOT NULL,
`g12w_night` decimal(10,6) NOT NULL,
`g13_zone1` decimal(10,6) NOT NULL,
`g13_zone2` decimal(10,6) NOT NULL,
`g13_zone3` decimal(10,6) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3 COLLATE=utf8mb3_general_ci;
INSERT INTO `prices` (`id`, `date`, `g11`, `g12_day`, `g12_night`, `g12w_day`, `g12w_night`, `g13_zone1`, `g13_zone2`, `g13_zone3`) VALUES
(1, '2021-01-01', 0.373400, 0.461000, 0.238300, 0.492200, 0.238300, 0.411800, 0.639100, 0.277700),
(2, '2022-01-01', 0.430200, 0.532400, 0.273000, 0.569100, 0.273000, 0.473100, 0.738200, 0.318200);
CREATE TABLE `prices_dist` (
`id` int(10) UNSIGNED NOT NULL,
`date` date NOT NULL,
`g11` decimal(10,6) NOT NULL,
`g12_day` decimal(10,6) NOT NULL,
`g12_night` decimal(10,6) NOT NULL,
`g12w_day` decimal(10,6) NOT NULL,
`g12w_night` decimal(10,6) NOT NULL,
`g13_zone1` decimal(10,6) NOT NULL,
`g13_zone2` decimal(10,6) NOT NULL,
`g13_zone3` decimal(10,6) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3 COLLATE=utf8mb3_general_ci;
INSERT INTO `prices_dist` (`id`, `date`, `g11`, `g12_day`, `g12_night`, `g12w_day`, `g12w_night`, `g13_zone1`, `g13_zone2`, `g13_zone3`) VALUES
(1, '2021-01-01', 0.212400, 0.228300, 0.049400, 0.264500, 0.043300, 0.157800, 0.279100, 0.029300),
(2, '2022-01-01', 0.191500, 0.206700, 0.044600, 0.238600, 0.039200, 0.142900, 0.252800, 0.026600);
CREATE TABLE `prices_net_billing` (
`id` int(10) UNSIGNED NOT NULL,
`date` date NOT NULL,
`price` decimal(10,6) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3 COLLATE=utf8mb3_general_ci;
INSERT INTO `prices_net_billing` (`id`, `date`, `price`) VALUES
(1, '2022-04-01', 0.656040),
(2, '2022-07-01', 0.796270),
(3, '2022-08-01', 1.019060),
(4, '2022-09-01', 0.710030),
(5, '2022-10-01', 0.575480),
(6, '2022-11-01', 0.701670),
(7, '2022-12-01', 0.723490),
(8, '2023-01-01', 0.594590),
(9, '2023-02-01', 0.668510),
(10, '2023-03-01', 0.509720),
(11, '2023-04-01', 0.505440),
(12, '2023-05-01', 0.381440);
ALTER TABLE `prices`
ADD PRIMARY KEY (`id`);
ALTER TABLE `prices_dist`
ADD PRIMARY KEY (`id`);
ALTER TABLE `prices_net_billing`
ADD PRIMARY KEY (`id`);
ALTER TABLE `prices`
MODIFY `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=3;
ALTER TABLE `prices_dist`
MODIFY `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=3;
ALTER TABLE `prices_net_billing`
MODIFY `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=13;
Oraz widok generujący statystyki:
Widok
CREATE ALGORITHM=UNDEFINED DEFINER=`user`@`localhost` SQL SECURITY DEFINER VIEW `energy_stats` AS SELECT `es`.`date` AS `date`, `es`.`solar_generation` AS `solar_generation`, `es`.`tauron_usage` AS `tauron_usage`, `es`.`tauron_usage_balanced` AS `tauron_usage_balanced`, `es`.`tauron_oze` AS `tauron_oze`, `es`.`tauron_oze_balanced` AS `tauron_oze_balanced`, sum(`es`.`solar_generation`) over ( order by `es`.`date`) AS `sum_solar_generation`, sum(`es`.`tauron_usage`) over ( order by `es`.`date`) AS `sum_tauron_usage`, sum(`es`.`tauron_oze`) over ( order by `es`.`date`) AS `sum_tauron_oze`, sum(`es`.`tauron_usage_balanced`) over ( order by `es`.`date`) AS `sum_tauron_usage_balanced`, sum(`es`.`tauron_oze_balanced`) over ( order by `es`.`date`) AS `sum_tauron_oze_balanced` FROM (select min(`e`.`date`) AS `date`,sum(`e`.`solar_generation`) AS `solar_generation`,sum(`e`.`tauron_usage`) AS `tauron_usage`,if(min(`e`.`date`) >= '2022-04-01',greatest(0,sum(`e`.`tauron_usage`) - sum(`e`.`tauron_oze`)),sum(`e`.`tauron_usage`)) AS `tauron_usage_balanced`,sum(`e`.`tauron_oze`) AS `tauron_oze`,if(min(`e`.`date`) >= '2022-04-01',greatest(0,sum(`e`.`tauron_oze`) - sum(`e`.`tauron_usage`)),sum(`e`.`tauron_oze`)) AS `tauron_oze_balanced` from `energy` `e` group by date_format(`e`.`date`,'%Y-%m-%d %H') order by `e`.`date`) AS `es` ;
Po podpięciu takiej bazy mysql do grafany można przygotować dashboard jak na screenie: Prąd-1749506169424.json (62,4 KB)
2 Likes
VictoriaMetrics Home Assistant Add-on VictoriaMetrics Time Series Database
VictoriaMetrics to szybkie, oszczędne i skalowalne rozwiązanie do monitorowania i zarządzania danymi szeregów czasowych. Zapewnia wysoką wydajność i niezawodność, co czyni je idealnym wyborem dla firm każdej wielkości.
Bardzo dziękuję, @zmszaman, że poświęciłeś czas na to, żeby podzielić się swoją pracą. Jest to dla mnie bardzo przydatne, choć czekają mnie przeróbki z wersji SQL na InfluxDB 2.
Osobiście uważam, że te dashboardy zasługują na własny wątek.