Question 1

Philips Hue koppeling

Accepted Answer

## Philips Hue Koppeling

Met de Philips Hue koppeling kun je je slimme lampen laten reageren op P2000-meldingen. Denk aan rode lampen die aangaan bij een brandmelding, of blauwe lampen bij een ambulancemelding.

### Hoe werkt het?

De koppeling werkt via een automatisering met een webhook die communiceert met je Hue Bridge. Je hebt hiervoor een domotica-tussenlaag nodig (bijv. Home Assistant, Homey of IFTTT).

### Optie 1: Via Home Assistant

Zie het artikel **"Koppeling met Home Assistant"** voor de complete configuratie. In Home Assistant maak je een automation die:

1. Luistert naar de webhook van MeldingsMonitor
2. De Hue lampen aanstuurt via de Hue-integratie

### Optie 2: Via de Hue API direct

Als je de Hue Bridge direct wilt aansturen, heb je een tussenstap nodig:

1. **Hue Bridge API-key** — Genereer een API-key via je Hue Bridge
2. **Lokaal script** — Maak een klein script dat de webhook ontvangt en de Hue API aanroept
3. **Port forwarding** — Stel port forwarding in op je router (of gebruik een tunnel zoals ngrok)

### Voorbeeld: Hue laten knipperen bij een melding

```bash
# Voorbeeld: Hue lamp rood laten knipperen
curl -X PUT "http:///api//lights/1/state" \
  -d '{"on":true, "bri":254, "hue":0, "sat":254, "alert":"lselect"}'
```

### Voorbeeld scenario's

- **Brandmelding** → Lampen rood knipperen
- **Ambulance** → Lampen blauw knipperen
- **Alle meldingen** → Lampen kort wit flitsen

### Tips

- Gebruik de `alert` parameter (`lselect` = 15 seconden knipperen) voor tijdelijke notificaties
- Maak een apart Hue-profiel voor alarmering, zodat je de standaard verlichting niet verstoort
- Test eerst met één lamp voordat je een hele groep instelt

Question 2

Koppeling met Home Assistant

Accepted Answer

## Koppeling met Home Assistant

Home Assistant is een populair open-source domotica-platform. Met de webhook-functie van MeldingsMonitor kun je P2000-meldingen ontvangen in Home Assistant en daar allerlei acties aan koppelen.

### Stap 1: Webhook-trigger instellen in Home Assistant

Maak een nieuwe automation in Home Assistant met een webhook-trigger:

```yaml
automation:
  - alias: "P2000 Melding Ontvangen"
    trigger:
      - platform: webhook
        webhook_id: "meldingsmonitor-p2000"
        allowed_methods:
          - POST
        local_only: false
    action:
      - service: notify.mobile_app_jouw_telefoon
        data:
          title: "P2000 Melding"
          message: "{{ trigger.json.incident.message }}"
          data:
            priority: high
```

### Stap 2: Webhook URL verkrijgen

Je webhook URL wordt:

```
https://jouw-home-assistant.duckdns.org/api/webhook/meldingsmonitor-p2000
```

> **Belangrijk:** Je Home Assistant moet bereikbaar zijn via het internet. Gebruik hiervoor Nabu Casa, DuckDNS, of een andere oplossing.

### Stap 3: Automatisering instellen in MeldingsMonitor

1. Ga naar **Automatiseringen** in MeldingsMonitor
2. Maak een nieuwe automatisering aan
3. Stel je triggers in (capcodes, discipline, trefwoorden)
4. Plak de webhook URL van Home Assistant
5. Sla op

### Geavanceerde voorbeelden

#### Hue-lampen aansturen bij melding

```yaml
automation:
  - alias: "P2000 Hue Alarm"
    trigger:
      - platform: webhook
        webhook_id: "meldingsmonitor-p2000"
    condition:
      - condition: template
        value_template: "{{ 'Brandweer' in trigger.json.incident.disciplines }}"
    action:
      - service: light.turn_on
        target:
          entity_id: light.woonkamer
        data:
          color_name: red
          brightness: 255
          flash: long
      - delay: "00:00:30"
      - service: light.turn_off
        target:
          entity_id: light.woonkamer
```

#### Tekst-to-speech bij melding

```yaml
action:
  - service: tts.google_translate_say
    target:
      entity_id: media_player.woonkamer_speaker
    data:
      message: "Nieuwe P2000 melding: {{ trigger.json.incident.message }}"
```

### Beschikbare data in templates

De webhook stuurt een JSON-body met de volgende structuur. In Home Assistant kun je deze velden gebruiken in templates:

**Automatisering:**
- `trigger.json.automation_id` — ID van de automatisering
- `trigger.json.automation_name` — Naam van de automatisering

**Melding:**
- `trigger.json.incident.id` — Melding ID
- `trigger.json.incident.message` — Volledige meldingtekst
- `trigger.json.incident.priority` — Prioriteit (P1, P2, etc.)
- `trigger.json.incident.occurred_at` — Tijdstip (ISO 8601)
- `trigger.json.incident.disciplines` — Lijst van disciplines (bijv. `["Brandweer"]`)
- `trigger.json.incident.capcodes` — Lijst van capcodes met `capcode` en `description`
- `trigger.json.incident.safety_regions` — Lijst van veiligheidsregio's
- `trigger.json.incident.street` — Straatnaam
- `trigger.json.incident.city` — Plaatsnaam
- `trigger.json.incident.postal_code` — Postcode
- `trigger.json.incident.latitude` — Breedtegraad (kan `null` zijn)
- `trigger.json.incident.longitude` — Lengtegraad (kan `null` zijn)

Question 3

Koppeling met Telegram

Accepted Answer

## Koppeling met Telegram

Met de native Telegram-koppeling stuur je een melding rechtstreeks naar Telegram wanneer een automatisering afgaat. Je gebruikt je eigen bot. Er zijn geen credits nodig.

### Wat je nodig hebt

- Een Telegram-account
- Een eigen bot via [BotFather](https://t.me/BotFather)
- Een chat, groep of kanaal waar de bot berichten mag sturen

### Stap 1: Bot aanmaken

1. Open Telegram en zoek **@BotFather**
2. Stuur `/newbot` en volg de stappen
3. Kopieer het token dat BotFather geeft

### Stap 2: Bot koppelen in MeldingsMonitor

1. Open je profiel en ga naar **Instellingen → Telegram**
2. Plak het **bot-token**
3. Klik op **Bot koppelen**

Het token wordt versleuteld opgeslagen. Na het koppelen zie je de botnaam, bijvoorbeeld `@mijn_p2000_bot`.

### Stap 3: Chat, groep of kanaal toevoegen

**Persoonlijke chat**
1. Zoek je bot in Telegram en stuur een bericht, bijvoorbeeld `start`
2. Klik in MeldingsMonitor op **Recente chats zoeken**, of vul het chat-ID handmatig in

**Groep**
1. Voeg de bot toe aan de groep
2. Stuur een bericht in de groep, of gebruik **Recente chats zoeken**

**Kanaal**
1. Voeg de bot toe als beheerder van het kanaal
2. Vul het chat-ID in, of gebruik `@kanaalnaam` bij een openbaar kanaal

Je kunt een chat eerst testen vanaf de Telegram-instellingen.

### Stap 4: Automatisering instellen

1. Ga naar **Mijn automatiseringen** (of **Automatiseringen** in een kazerne-workspace)
2. Maak een automatisering of open een bestaande
3. Kies bij acties **Telegram versturen**
4. Selecteer een opgeslagen chat of vul een extra chat-ID in
5. Pas de berichttekst aan met variabelen, of laat het standaardsjabloon staan
6. Sla op. Met **Testen** controleer je of het bericht aankomt. De test gebruikt voorbeeldgegevens.

### Berichttekst zelf opbouwen

Je kunt de Telegram-tekst zelf maken. Kies een variabele via **Variabele toevoegen** of typ die tussen accolades, bijvoorbeeld `{bericht}`.

**Direct beschikbaar** (ook bij snelle verwerking):

| Variabele | Inhoud |
|-----------|--------|
| `{automatisering}` | Naam van de automatisering |
| `{bericht}` | De P2000-meldingstekst |
| `{prioriteit}` | Prioriteit, bijvoorbeeld P1 |
| `{tijdstip}` | Datum en tijd |
| `{datum}` | Alleen de datum |
| `{tijd}` | Alleen de tijd |
| `{discipline}` | Discipline, bijvoorbeeld Brandweer |
| `{capcodes}` | Gekoppelde capcodes |
| `{regio}` | Veiligheidsregio |
| `{voertuigen}` | Voertuigen uit de melding |
| `{melding_url}` | Link naar de melding in MeldingsMonitor |

**Pas na verrijking** (leeg bij snelle verwerking):

| Variabele | Inhoud |
|-----------|--------|
| `{straat}` | Straatnaam |
| `{plaats}` | Plaats |
| `{postcode}` | Postcode |
| `{locatie}` | Straat en plaats samen |
| `{categorie}` | Categorie, bijvoorbeeld Brand gebouw |
| `{latitude}` | Breedtegraad |
| `{longitude}` | Lengtegraad |
| `{kaart}` | Link naar Google Maps |

Snelle verwerking stuurt het bericht meteen, nog voordat straat, plaats en coördinaten bekend zijn. Een regel zoals `Locatie: {locatie}` verdwijnt dan vanzelf als die waarde leeg is.

### Tips

- Eén bot kan naar meerdere chats, groepen en kanalen sturen
- Voor een kazerne-automatisering geldt de Telegram-bot van de eigenaar van die automatisering
- Als een test faalt, controleer of de bot lid is van de groep of beheerder van het kanaal

Question 4

Koppeling met Homey

Accepted Answer

## Koppeling met Homey

Homey van Athom is een populaire domotica-hub in Nederland. Je kunt MeldingsMonitor webhooks koppelen aan Homey om slimme acties uit te voeren bij P2000-meldingen.

### Via de Webhooks-app

1. Installeer de **Webhooks** app uit de Homey App Store
2. Maak een nieuwe webhook-trigger aan in de app
3. Kopieer de webhook URL die de app genereert

### Stap voor stap

#### 1. Homey Webhooks app instellen

- Open de Homey app op je telefoon
- Ga naar **Apps** → zoek naar **Webhooks**
- Installeer de app en open de instellingen
- Maak een nieuwe webhook aan en kopieer de URL

#### 2. MeldingsMonitor automatisering

- Ga naar **Automatiseringen** in MeldingsMonitor
- Maak een nieuwe automatisering met je gewenste triggers
- Plak de Homey webhook URL als actie-URL
- Sla de automatisering op

#### 3. Homey Flow maken

Maak een Flow in Homey:

- **Als** → Webhook ontvangen (Webhooks app)
- **Dan** → Kies je actie, bijvoorbeeld:
  - Hue lamp rood knipperen
  - Sonos spreker: melding voorlezen
  - Pushbericht naar je telefoon
  - Sirene activeren

### Voorbeeld Flow

```
ALS: Webhook ontvangen van "meldingsmonitor"
DAN: Zeg op Sonos "Nieuwe P2000 melding ontvangen"
EN: Zet Hue lamp Woonkamer op rood
EN: Wacht 30 seconden
DAN: Zet Hue lamp Woonkamer terug naar normaal
```

### Tips

- De Homey Pro heeft betere webhook-ondersteuning dan de Homey (standaard)
- Gebruik de Advanced Flow editor voor complexe scenario's
- Test je Flow met een testmelding vanuit MeldingsMonitor

Question 5

Koppeling met IFTTT

Accepted Answer

## Koppeling met IFTTT

IFTTT (If This Then That) is een populaire automatiseringsservice waarmee je duizenden apps en apparaten met elkaar kunt verbinden. Door MeldingsMonitor te koppelen via webhooks, kun je P2000-meldingen gebruiken als trigger voor IFTTT-acties.

### Stap 1: IFTTT Webhooks inschakelen

1. Ga naar [ifttt.com](https://ifttt.com) en log in
2. Zoek naar de **Webhooks** service
3. Klik op **Connect**
4. Ga naar **Webhooks Settings** en noteer je **webhook key**

### Stap 2: Je webhook URL samenstellen

Je IFTTT webhook URL ziet er als volgt uit:

```
https://maker.ifttt.com/trigger/{event_name}/json/with/key/{your_key}
```

Vervang:
- `{event_name}` door een naam naar keuze, bijv. `p2000_melding`
- `{your_key}` door je IFTTT webhook key

### Stap 3: Applet maken in IFTTT

1. Maak een nieuwe Applet (**Create**)
2. **If This**: kies **Webhooks** → **Receive a web request with a JSON payload**
3. Event name: `p2000_melding`
4. **Then That**: kies je gewenste actie, bijvoorbeeld:
   - **Notifications** — Pushbericht op je telefoon
   - **Philips Hue** — Lampen aansturen
   - **Google Sheets** — Meldingen loggen in een spreadsheet
   - **Email** — E-mail versturen
   - **Telegram** — Bericht in een Telegram groep

### Stap 4: Koppel in MeldingsMonitor

1. Ga naar **Automatiseringen** in MeldingsMonitor
2. Maak een nieuwe automatisering
3. Plak je IFTTT webhook URL
4. Sla op

### Populaire IFTTT-acties

| Actie | Beschrijving |
|-------|-------------|
| Pushbericht | Ontvang een notificatie op je telefoon |
| Philips Hue | Lampen laten knipperen bij een melding |
| Google Sheets | Log alle meldingen in een spreadsheet |
| Telegram | Bericht naar een Telegram-kanaal |
| SMS | Verstuur een SMS bij belangrijke meldingen |

### Beperkingen

- IFTTT gratis accounts zijn beperkt tot 2 Applets
- De Pro-versie biedt meer mogelijkheden en snellere verwerking
- Er kan een kleine vertraging zitten tussen trigger en actie (1-15 seconden)

Question 6

Koppeling met Zapier

Accepted Answer

## Koppeling met Zapier

Zapier is een krachtige automatiseringsplatform waarmee je MeldingsMonitor kunt koppelen aan duizenden andere apps en diensten.

### Stap 1: Zapier Webhook instellen

1. Ga naar [zapier.com](https://zapier.com) en log in
2. Klik op **Create Zap**
3. Kies als trigger: **Webhooks by Zapier**
4. Selecteer **Catch Hook**
5. Kopieer de webhook URL die Zapier genereert

### Stap 2: MeldingsMonitor koppelen

1. Ga naar **Automatiseringen** in MeldingsMonitor
2. Maak een nieuwe automatisering aan met je gewenste triggers
3. Plak de Zapier webhook URL als actie-URL
4. Sla op en verstuur een testmelding

### Stap 3: Actie kiezen in Zapier

Nadat Zapier de test-webhook heeft ontvangen, kun je een actie kiezen:

- **Slack** — Bericht in een Slack-kanaal
- **Microsoft Teams** — Bericht in een Teams-kanaal
- **Notion** — Melding loggen in een Notion-database
- **Airtable** — Melding opslaan in een Airtable-base
- **Twilio** — SMS of telefoongesprek bij een melding
- **Discord** — Bericht in een Discord-kanaal
- **Email** — E-mail versturen

### Voorbeeld: Slack-notificatie

1. Trigger: Webhooks by Zapier → Catch Hook
2. Action: Slack → Send Channel Message
3. Configureer het bericht:
   - Channel: `#p2000-meldingen`
   - Message: `Nieuwe melding: {{message}} - Locatie: {{location}}`

### Voorbeeld: Meldingen loggen in Google Sheets

1. Trigger: Webhooks by Zapier → Catch Hook
2. Action: Google Sheets → Create Spreadsheet Row
3. Map de velden:
   - Kolom A: `{{created_at}}` (Tijdstip)
   - Kolom B: `{{discipline}}` (Discipline)
   - Kolom C: `{{message}}` (Melding)
   - Kolom D: `{{location}}` (Locatie)

### Tips

- Zapier heeft een gratis plan met 100 taken per maand
- Gebruik "Paths" voor complexe logica (bijv. verschillende acties per discipline)
- Test altijd met een testmelding voordat je live gaat

Question 7

Koppeling met Domoticz

Accepted Answer

## Koppeling met Domoticz

Domoticz is een open-source domotica-systeem dat populair is onder doe-het-zelvers. Met een klein script kun je MeldingsMonitor webhooks ontvangen en vertalen naar Domoticz-acties.

### Optie 1: Via een script (aanbevolen)

Maak een klein Python-script dat de webhook ontvangt en de Domoticz API aanroept:

```python
from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

DOMOTICZ_URL = "http://localhost:8080"

@app.route('/webhook/meldingsmonitor', methods=['POST'])
def webhook():
    data = request.json

# Schakel een virtueel apparaat in Domoticz
    requests.get(f"{DOMOTICZ_URL}/json.htm", params={
        "type": "command",
        "param": "switchlight",
        "idx": 1,  # IDX van je virtuele switch
        "switchcmd": "On"
    })

# Stuur een notificatie
    requests.get(f"{DOMOTICZ_URL}/json.htm", params={
        "type": "command",
        "param": "sendnotification",
        "subject": "P2000 Melding",
        "body": data.get('message', 'Nieuwe melding'),
        "subsystem": "fcm"
    })

return jsonify({"status": "ok"})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)
```

### Optie 2: Via Node-RED

Als je Node-RED gebruikt naast Domoticz:

1. Installeer de `node-red-contrib-domoticz-output` node
2. Maak een HTTP-input node met het pad `/webhook/meldingsmonitor`
3. Verbind deze met een Domoticz-output node
4. Configureer het gewenste apparaat en de actie

### Stap voor stap in MeldingsMonitor

1. Draai het Python-script (of Node-RED) op je server
2. Maak de webhook bereikbaar via het internet (port forwarding, ngrok, reverse proxy)
3. Ga naar **Automatiseringen** in MeldingsMonitor
4. Maak een nieuwe automatisering en plak je webhook URL
5. Test de koppeling

### Domoticz-acties bij een melding

Met Domoticz kun je bij een P2000-melding:

- Lampen aansturen (Hue, Z-Wave, Zigbee)
- Sirenes activeren
- Notificaties versturen (Pushover, Prowl, Telegram)
- Een logboek bijhouden
- Scripts uitvoeren

### Tips

- Gebruik een virtuele switch in Domoticz als "trigger" apparaat
- Stel een timer in zodat het apparaat automatisch na X seconden uitschakelt
- Test eerst lokaal voordat je het bereikbaar maakt via het internet

Onderwerpen

Koppelingen & Integraties

Philips Hue koppeling

Koppeling met Home Assistant

Koppeling met Telegram

Koppeling met Homey

Koppeling met IFTTT

Koppeling met Zapier

Koppeling met Domoticz

Staat je antwoord er niet bij?

Cookies