Skip to content

06. Gebruik van de API

Jump to bottom
Torch1969 edited this page Oct 14, 2026 · 1 revision

Inleiding over de API

DAO beschikt over een api, waarmee allerlei relevante gegevens uit de database kunnen worden opgevraagd en bijvoorbeeld in HomeAssistant of een ander programma (bijv Excel) kunnen getoond. Ook kun je met de api bewerkingen en berekeningen van DAO uitvoeren.

De api's kun je als volgt aanroepen (zie voor meer uitleg hierna):

  • http://<ip-adres van DAO>:<ip-poort van DAO>/api/run/<commando>
  • http://<ip-adres van DAO>:<ip-poort van DAO>/api/report/<variable>/<period>?<parameter>=<parameter_value>

Het <ip-adres van DAO> en de<ip-poort van DAO> zijn hetzelfde als bij het dashboard.

API/run - uitvoeren van acties

Omschrijving van de API/run

Met deze api kun je berekeningen en bewerkingen van DAO starten. Dit kan met curl maar ook kun je hiermee vanuit Home Assistant een bewerking of berekening uitvoeren.

syntax:http://<ip-adres van DAO>:<ip-poort van DAO>/api/run/<commando>

Bij <commando> vul je een van de volgende commando's in:

  • calc_zonder_debug: een optimaliseringsberekening wordt uitgevoerd. De resultaten worden doorgezet naar Home Assistant.
  • calc_met_debug: een optimaliseringsbereking wordt uitgevoerd. De resultaten worden niet doorgezet naar Home Assistant.
  • get_tibber: haalt verbruiksgegevens (consumption, production, cost, profit) op bij Tibber en slaat deze op in de database
  • get_meteo: haalt prognose van meteogegevens op bij Meteoserver en slaat deze op in de database
  • get_prices: haalt de day-ahead prijzen voor de volgende dag op en slaat deze op in de database
  • calc_baseloads: voert de baseload berekening uit en slaat de resultaten op in de json files op de ~\dao_data\baseload directory
  • train_ml_predictions: traint het ML (Machine Learning) model dat wordt gebruikt voor een zo nauwkeurig mogelijke voorspelling van de zonneopbrengst

Voorbeeld van de API/run

Een uitgewerkt voorbeeld hoe je vanuit Home Assistant een berekening kunt starten:

  • Maak een (of meer) rest-commands aan. Voeg hiervoor de volgende code toe aan configuration.yaml van Home Assistant: 
    rest_command:
  start_dao_calc:
    url: http://192.168.178.36:5000/api/run/calc_zonder_debug
    verify_ssl: false
  • Maak een helper aan in Home Assistant, bijvoorbeeld: input_button.start_day_ahead_berekening en zet deze helper op een voor jou passende entity card.
  • Maak een automatisering aan die wordt getriggerd als je op deze helper klikt. Bijvoorbeeld: 
    alias: Start berekening DAO via rest
description: Start berekening DAO
trigger:
  - platform: state
    entity_id:
      - input_button.start_day_ahead_berekening
condition: []
action:
  - service: rest_command.start_dao_calc
    data: {}
mode: single

API/report - ophalen van gegevens

Omschrijving van de API/report

Met deze api kun je diverse gegevens uit de database ophalen en deze kun je dan o.a. in Home Assistant gebruiken om grafieken te maken met bijv. apex-charts (zie voorbeeld hieronder).

http://<ip-adres van DAO>:<ip-poort van DAO>/api/report/<variable>/<period>?<parameter>=<parameter_value>

Als resultaat krijg je de opgevraagde gegevens geformarteerd als JSON. Bijvoorbeeld:

  {"message": "Success",
  "data": [
    {
      "time_ts": 1743890400000,
      "time": "2025-04-06 00:00",
      "value": 0.653,
      "datatype": "recorded"
    },
    {
      "time_ts": 1743894000000,
      "time": "2025-04-06 01:00",
      "value": 0,
      "datatype": "recorded"
    },
    ...

Hierin vindt je de volgende gegevens terug:

  • data: een array met daarin alle opgevraagde datapunten
  • time_ts: datum tijd van het begintijdstip als timestamp in milli seconden
  • time: datum tijd van het begintijdstip in leesbare vorm
  • value: de gevraagde waarde
  • datatype: kan zijn
    • "recorded": daadwerkelijk gerealiseerd
    • "expected": de prognose van wat gerealiseerd gaat worden

Opmerking: Dit onderdeel werkt pas echt goed als DAO prijs- en meteogegevens heeft opgehaald en opgeslagen in de database en met succes optimaliseringsberekeningen heeft uitgevoerd.

Bij variable kun je één van de volgende gebruiken:

  • da: Hiermee vraag je de day ahead prijzen op. Deze variabele heeft afwijkende value's:
    • da_ex: kale day ahead prijs, excl. belasting, excl. btw en excl opslag leverancier
    • da_cons: de day ahead prijs waarvoor jij elektriciteit koopt, dus inclusief energiebelasting, btw en opslag leverancier
    • da_prod: de day ahead prijs waarvoor jij elektriciteit teruglevert. Deze kan afwijken van de prijs waarvoor je elektriciteit koopt
  • consumption of cons: Hiermee vraag je je verbruiksgegevens (in kWh) op
  • production of prod: Hiermee vraag je je teruglevering gegevens (in kWh) op. De indeling is hetzelfde als bij consumption.
  • cost
    Hiermee vraag je je verbruikskosten (in euro) op.
  • profit
    Hiermee vraag je je teruglevering inkomsten (in euro) op.
  • soc of soc_0, soc_1 enz. Hiermee vraag je de te verwachten SoC (State of Charge in %) op van je batterij. Als je meer dan 1 batterij hebt zijn er ook meer SoC's die je apart kunt opvragen:
    • soc is de capaciteits-gewogen gemiddelde van de SoC's van alle batterijen
    • soc_0 is de SoC van de eerste batterij
    • soc_1 is de SoC van de tweede batterij
    • enz..
  • bat_in, de energie (in kWh) die de batterij ingaat
  • bat_out, de energie (in kWh) die uit de batterij komt
  • base, de basislast (in kWh)
  • boil, het energieverbruik (in kWh) van de boiler
  • wp, het energieverbruik (in kWh) van de warmtepomp
  • ev, het energieverbruik (in kWh) van je ev's
  • pv_ac, de energieproductie (in kWh) van je ac-gekoppelde zonnepanelen
  • pv_dc, de energieproductie (in kWh) van je dc-gekoppelde zonnepanelen

Bij period kun je de periode opgeven waarover je de gevraagde gegevens wilt ontvangen.

Je kunt kiezen uit:

  • vandaag met interval uur
  • vandaag_en_morgen met interval uur
  • morgen met interval uur
  • deze_week met interval dag
  • vorige_week met interval dag
  • deze_maand met interval dag
  • vorige_maand met interval dag
  • dit jaar met interval maand
  • vorig_jaar met interval maand
  • dit_contractjaar met interval maand Bij pv_ac en pv_dc wordt bij periode vandaag_en_morgen de voorspelling verlengd tot zover stralingsgegevens bekend zijn (afhankelijk van opgehaalde meteogegevens harmonie of gfs)

Bij parameter kun je één van de volgend gebruiken:

Het laatste stuk ?<parameter>=<parameter_value> is facultatief. Er is één parameter die je kunt invullen. Voor de opgegeven parameter staat altijd een vraagteken.

  • cumulate=1: Als je cumulate opgeeft en je zet deze op "1" dan worden alle resultaten cumulatief berekend. Oftewel elke volgende waarde is de optelling van alle waarden t/m dat datapunt.

Voorbeeld van de API/report

We gaan gegevens uit DAO ophalen en deze tonen in een dashboard van Home Asistant. Hiervoor maken we gebruik van de restful integratie van Home Assistant en apex charts (je kunt de standaard functionaliteit voor grafieken van Home assistant uiteraard ook gebruiken, maar wij vinden de apex charts mooier en je kunt veel meer configureren).

Je maakt in configuration.yaml eerst de gewenste sensoren aan. Bijvoorbeeld:

rest:
  - resource: http://192.168.178.64:5000/api/report/da/vandaag_en_morgen
    verify_ssl: false
    scan_interval: 600
    sensor:
      - name: DA Price
        unique_id: da_price
        unit_of_measurement: 'euro/kWh'
        value_template: "{{ (value_json.data[now().hour].da_ex) | round(5) }}"
        json_attributes:
          - data
  - resource: http://192.168.178.64:5000/api/report/consumption/vandaag_en_morgen
    verify_ssl: false
    scan_interval: 600
    sensor:
      - name: DAO Grid consumption
        unique_id: dao_grid_consumption
        unit_of_measurement: 'kWh'
        value_template: "{{ (value_json.data[now().hour].value) | round(3) }}"
        json_attributes:
          - data
  - resource: http://192.168.178.64:5000/api/report/consumption/vandaag?cumulate=1
    verify_ssl: false
    scan_interval: 600
    sensor:
      - name: DAO Grid consumption cumulatief
        unique_id: dao_grid_consumption_cumulatief
        unit_of_measurement: 'kWh'
        value_template: "{{ (value_json.data[now().hour].value) | round(3) }}"
        json_attributes:
          - data
  - resource: http://192.168.178.64:5000/api/report/production/vandaag_en_morgen
    verify_ssl: false
    scan_interval: 600
    sensor:
      - name: DAO Grid production
        unique_id: dao_grid_production
        unit_of_measurement: 'kWh'
        value_template: "{{ (value_json.data[now().hour].value) | round(3) }}"
        json_attributes:
          - data

Korte toelichting:

  • resource: http://192.168.178.64:5000/api/report/da/vandaag_en_morgen verwijst naar de hierboven beschreven url-api waarmee je de data ophaalt van de gewenste sensor
  • verify_ssl: false, voorlopig nog geen https
  • scan_interval: 600: haal de data iedere 10 minuten op, dit kun je zelf aanpassen, het verversen van de data is natuurlijk wel afhankelijk van het uitvoeren van de berekeningen.
  • sensor:
    • name: da_price naam van de sensor in Home Assistant
    • unit_of_measurement: 'euro/kWh' de dimensie
    • value_template: "{{ (value_json.data[now().hour].value) | round(5) }}" de template waarmee de actuele waarde van de sensor uit de attributen wordt gehaald en als state wordt ingesteld
    • **json_attributes:
      - data de lijst met waarden die als attribuut bij de sensor wordt opgeslagen

TIP, wil je de meest actuele gegevens meteen ophalen om een grafiek bij te werken? Maak op je dashboard een button waarmee je de actie "Bijwerken entiteit" uitvoert op je gedefinieerde REST sensoren. Daarna ververs je het dashoard zodat die opnieuw opbouwt op basis van de bijgewerkte gegevens.

Controleer of de sensor goed werkt door in Home Assistant via Ontwikkelhulpmiddelen/Statussen de desbetreffende sensor op te zoeken. De status moet de actuele waarde weergeven en als attribuut moet het hele JSON bericht aanwezig zijn.

Nu de sensor(en) goed werken, presenteren we de gegevens in een mooie grafief mbv apex charts. Als voorbeeld de volgende grafiek:

img_10.png

De configuratie van deze grafiek ziet er als volgt uit:

type: custom:apexcharts-card
graph_span: 48h
span:
  start: day
header:
  show: true
  title: Day Ahead Price vandaag en morgen
  colorize_states: true
  show_states: true
yaxis:
  - min: ~0
    max: ~0.2
    decimals: 2
series:
  - entity: sensor.da_price
    attribute: data
    name: Exclusief historie
    type: line
    curve: stepline
    show:
      in_header: true
      legend_value: false
    color: orange
    opacity: 1
    float_precision: 5
    statistics:
      align: start
    data_generator: |
      let td = entity.attributes.data;
      const tdrecorded = td.filter(td => td.datatype === 'recorded');
      return tdrecorded.map(row => {
              return [row.time_ts, row.da_ex];
            });
  - entity: sensor.da_price
    attribute: data
    name: Exclusief prognose
    type: line
    curve: stepline
    show:
      in_header: false
      legend_value: false
    color: orange
    opacity: 0.5
    float_precision: 5
    data_generator: |
      let td = entity.attributes.data;
      const tdexpected = td.filter(td => td.datatype === 'expected');
      return tdexpected.map(row => {
              return [row.time_ts, row.da_ex];
            });
  - entity: sensor.da_price
    attribute: data
    name: Consumptie historie
    type: line
    curve: stepline
    show:
      in_header: true
      legend_value: false
    color: blue
    opacity: 1
    float_precision: 5
    statistics:
      align: start
    data_generator: |
      let td = entity.attributes.data;
      const tdrecorded = td.filter(td => td.datatype === 'recorded');
      return tdrecorded.map(row => {
              return [row.time_ts, row.da_cons];
            });
  - entity: sensor.da_price
    attribute: data
    name: Consumptie prognose
    type: line
    curve: stepline
    show:
      in_header: false
      legend_value: false
    color: blue
    opacity: 0.5
    float_precision: 5
    data_generator: |
      let td = entity.attributes.data;
      const tdexpected = td.filter(td => td.datatype === 'expected');
      return tdexpected.map(row => {
              return [row.time_ts, row.da_cons];
            });

We definieren hier 4 lijnen in de grafiek (kale prijs historie en toekomst en totaalprijs historie en toekomst). In het data_generator deel halen we de juiste gegevens uit de JSON in het data attribuut van de sensor. We filteren op 'recorded' voor de historie en 'expected' voor toekomst en gebruiken het relevante attribuut (da_ex en da_cons) voor de waarden. De andere configuratie instellingen zijn voor de opmaak van de grafief. Daarin is veel mogelijk. Voor verdere uitleg van deze instellingen verwijs ik je naar de documentatie van de apexcharts

Op deze manier kun je zelf eenvoudig andere grafieken maken van de andere api report mogelijkheden. Maak een rest-sensor aan voor het gewenste api-endpoint, neem die op in de apex-chart configuratie (achter entity), filter op de gewenste gegevens (recorded of expected) en pak de juiste waarde (meestal row.value).

Clone this wiki locally