Zelf je boot op afstand monitoren

Inleiding

Als booteigenaar ken je het probleem waarschijnlijk maar al te goed: je komt bij je boot aan en de accu is leeg, er staat water in de bilge, of er is een ander probleem ontstaan terwijl je niet aanwezig was. De boot starten lukt niet, de walstroom is uitgevallen, of je bent simpelweg vergeten de boot aan te sluiten op de walstroom. Dit zijn ergernissen die soms ook kostbaar kunnen uitpakken.

In deze blog laat ik zien hoe je met moderne, energiezuinige technologie zelf een systeem kunt bouwen om je boot op afstand te monitoren. Voor wie geen tijd of technische kennis heeft om zelf aan de slag te gaan, biedt BlueStar natuurlijk een kant-en-klare oplossing, maar voor de doe-het-zelvers onder ons kan dit project een leerzame uitdaging zijn.

Energiezuinig en tegen lage kosten

Om te begrijpen welke technologie het meest geschikt is voor bootmonitoring, is het nuttig om verschillende draadloze technologieën te vergelijken op basis van bereik, datasnelheid, energieverbruik en kosten. Lees meer over de keuze voor een geschikte draadloze technologie in deze post.

Vanwege de aard van dit project kiezen we voor het gratis LoRaWAN netwerk van The Things Network.

Proof of Concept: Arduino-gebaseerde bootmonitor

Om te testen of deze technologie geschikt is voor bootmonitoring, heb ik een proof of concept gemaakt met behulp van een Arduino en The Things Network. Deze setup kan de volgende parameters meten:

• Accuspanning
• Temperatuur
• Luchtvochtigheid

Wat is een Arduino?

Voor wie niet bekend is met Arduino: dit is een open-source elektronisch platform gebaseerd op gebruiksvriendelijke hardware en software. Arduino-boards kunnen invoer (zoals de lezing van een sensor) lezen en omzetten in een uitvoer (zoals het activeren van een motor of het verzenden van data). Je kunt het board vertellen wat te doen door het programmeren met de Arduino-programmeertaal en de Arduino ontwikkelomgeving (IDE).

Arduino's zijn ideaal voor prototyping omdat ze:

• Betaalbaar zijn (€20-30 voor een basismodel)
• Cross-platform werken (Windows, Mac, Linux)
• Een eenvoudige, duidelijke programmeeromgeving hebben
• Open-source en uitbreidbaar zijn met "shields" voor extra functionaliteit

De componenten

Voor deze bootmonitor heb ik de volgende componenten gebruikt:

• Arduino (bijvoorbeeld Arduino Uno of Nano)
• LoRaWAN-zender module (bijvoorbeeld RN2483)
• Voltageregulator (om stabiele voeding te garanderen)
• Voltagemeter (om de accuspanning te meten)
• Temperatuur- en luchtvochtigheidssensor (bijvoorbeeld DHT22)
• Behuizing (spatwaterbestendig voor bootomgeving)

Hoe het werkt

De werking van dit doe-het-zelf-systeem is als volgt:

1. De Arduino leest elke 3 minuten de sensorwaarden uit: accuspanning, temperatuur en luchtvochtigheid
2. Deze data wordt via de LoRaWAN-module verzonden naar het dichtstbijzijnde gateway van The Things Network
3. The Things Network stuurt deze data door naar een MQTT server
4. Maak een dashboard op je telefoon met de app: IoT MQTT Panel

Arduino Code

Hieronder vind je een vereenvoudigde versie van Arduino-code die je kunt gebruiken voor dit project. Deze code moet je aanpassen aan jouw specifieke componenten en vereisten.

#include <TheThingsNetwork.h>
#include <DHT.h>

const char *appEui = "0000000000000000";  // Vul hier je Application EUI in
const char *appKey = "00000000000000000000000000000000";  // Vul hier je App Key in

// LoRaWAN instellingen
#define freqPlan TTN_FP_EU868  // Dit is het frequentieplan voor EU (op 868MHz)
#define DHTPIN 2               // Pin waarop de DHT-sensor is aangesloten
#define DHTTYPE DHT22          // DHT 22 (AM2302)
#define VOLTAGE_PIN A0         // Analoge pin voor spanningsmetingen

// TTN-instantie aanmaken
TheThingsNetwork ttn(Serial1, Serial, freqPlan);

// DHT-sensor instantiëren
DHT dht(DHTPIN, DHTTYPE);

// Variabelen voor sensorwaarden
float voltage, temperature, humidity;

// Buffer voor data
byte data[6];

void setup() {
  Serial.begin(9600);
  Serial1.begin(57600);

  // Initialize the DHT sensor
  dht.begin();

  // Initialize the TTN connection
  ttn.join(appEui, appKey);

  // Wacht op TTN-verbinding
  while (!ttn.isJoined()) {
    Serial.println("Joining TTN...");
    delay(5000);
  }

  Serial.println("Joined TTN!");
}

void loop() {
  // Lees accuspanning
  int rawVoltage = analogRead(VOLTAGE_PIN);
  voltage = rawVoltage * (15.0 / 1023.0); // Aanpassen aan je spanningsdeler

  // Lees temperatuur en luchtvochtigheid
  humidity = dht.readHumidity();
  temperature = dht.readTemperature();

  // Debug info
  Serial.print("Voltage: ");
  Serial.print(voltage);
  Serial.print("V, Temperature: ");
  Serial.print(temperature);
  Serial.print("°C, Humidity: ");
  Serial.print(humidity);
  Serial.println("%");

  // Data voorbereiden voor verzending
  // We sturen voltage, temperatuur en luchtvochtigheid als float waardes
  // Elke float neemt 4 bytes in beslag, waardoor het totaal op 12 bytes komt
  memcpy(data, &voltage, 4);
  memcpy(data + 4, &temperature, 4);
  memcpy(data + 8, &humidity, 4);

  // Data verzenden via TTN
  ttn.sendBytes(data, sizeof(data));

  // Wacht 3 minuten voor de volgende meting
  delay(180000);
}

Deze code moet je aanpassen aan jouw specifieke setup, met name:

• De pinnen waarop sensoren zijn aangesloten
• De kalibratie van de spanningsdeler voor de accuspanningsmeting
• De TTN-applicatie gegevens (appEui en appKey)

De stap naar The Things Network (TTN)

Na het opbouwen van je hardware is de volgende stap het verbinden met The Things Network. Dit is een belangrijk onderdeel waar beginners vaak moeite mee hebben.

Een account aanmaken bij The Things Network

Voordat je je bootmonitor kunt gebruiken, moet je een gratis account aanmaken bij The Things Network:

1. Ga naar The Things Network website
2. Klik op "Sign up" rechtsboven in het scherm
3. Klik op "Join The Things Network"
4. Vul je gegevens in en bevestig je e-mailadres
5. Na het inloggen kom je in het TTN Console terecht

Een applicatie aanmaken in TTN

Je moet een applicatie aanmaken om je bootmonitor aan te koppelen:

1. In de TTN Console, ga naar "Applications"
2. Klik op "+ Add application"
3. Vul een unieke Application ID in (bijvoorbeeld "bootmonitor-jouw naam")
4. Vul een beschrijving in zoals "Monitoring systeem voor mijn boot"
5. Klik op "Create application"

Een apparaat registreren in TTN

Nu moet je je Arduino als apparaat registreren:

1. In je nieuwe applicatie, ga naar "Devices"
2. Klik op "+ Register device"
3. Vul een Device ID in (bijvoorbeeld "arduino-bootmonitor")
4. Voor de Device EUI kun je op het pictogram klikken om er automatisch een te genereren
5. Laat alle andere instellingen op hun standaardwaarden staan
6. Klik op "Register"

Na registratie krijg je drie belangrijke codes te zien:

• Device EUI: De unieke identifier van je apparaat
• Application EUI: De identifier van je applicatie
• App Key: De beveiligingssleutel voor je apparaat

Deze drie codes moet je kopiëren en in je Arduino-code invullen:

// Vervang deze regels in de eerdere code
const char *appEui = "0000000000000000";  // Vul hier je Application EUI in
const char *appKey = "00000000000000000000000000000000";  // Vul hier je App Key in

Een decoder maken voor je data

Wanneer je apparaat data verstuurt naar TTN, komt deze binnen als ruwe bytes. Een decoder zet deze bytes om in leesbare waarden:

1. Ga naar je applicatie in de TTN Console
2. Klik op "Payload Formats"
3. Selecteer "Custom" als Payload Format
4. Kopieer en plak de volgende decoder-code:

function Decoder(bytes, port) {
  // Controleer of we genoeg bytes hebben
  if (bytes.length != 12) {
    return {
      error: 'Verwachtte 12 bytes, maar ontvangen: ' + bytes.length,
    }
  }

  // Float waarden uit de bytes halen
  var voltage = bytesToFloat(bytes.slice(0, 4))
  var temperature = bytesToFloat(bytes.slice(4, 8))
  var humidity = bytesToFloat(bytes.slice(8, 12))

  // Afronden op 2 decimalen voor leesbaarheid
  voltage = Math.round(voltage * 100) / 100
  temperature = Math.round(temperature * 10) / 10
  humidity = Math.round(humidity * 10) / 10

  return {
    voltage: voltage,
    temperature: temperature,
    humidity: humidity,
  }
}

// Hulpfunctie om bytes naar float om te zetten
function bytesToFloat(bytes) {
  var buffer = new ArrayBuffer(4)
  var view = new DataView(buffer)

  bytes.forEach(function (b, i) {
    view.setUint8(i, b)
  })

  return view.getFloat32(0, true) // true voor little-endian
}

5. Klik op "Save payload functions"

Deze decoder zet de binaire data die je Arduino verstuurt om in leesbare voltage-, temperatuur- en luchtvochtigheidswaarden.

Data ontvangen via MQTT

The Things Network gebruikt MQTT (Message Queuing Telemetry Transport) om IoT-data te versturen. Dit is een soort berichtensysteem speciaal ontworpen voor apparaten met beperkte bandbreedte en rekenkracht.

Elk apparaat dat je in TTN registreert, publiceert automatisch zijn data via MQTT. Je hoeft hiervoor niets speciaals te doen - TTN regelt dit allemaal automatisch.

Data visualiseren met IoT MQTT Panel

Met de IoT MQTT Panel app op je smartphone kun je de data van je bootmonitor bekijken:

1. Download de IoT MQTT Panel app uit de Google Play Store of Apple App Store
2. Open de app en maak een nieuwe verbinding aan
3. Vul de volgende MQTT-verbindingsgegevens in:
   • Naam: Bootmonitor (of een andere naam naar keuze)
   • Host: eu1.cloud.thethings.network (of de juiste regio voor jouw locatie)
   • Poort: 1883 (of 8883 voor een beveiligde verbinding)
   • Gebruikersnaam: Je TTN Application ID
   • Wachtwoord: De Access Key van je TTN-applicatie (te vinden onder "API Keys" in je applicatie)
   • Client ID: Een willekeurige naam, bijvoorbeeld "boot-monitoring-app"
4. Klik op "Opslaan" om de verbinding te maken
5. Nu moet je je apparaat-topic toevoegen:
   • Klik op "+" om een nieuw dashboard-item toe te voegen
   • Kies "Tekst" als type
   • Naam: Accuspanning (bijvoorbeeld)
   • Topic: v3/{je-application-id}/devices/{je-device-id}/up/uplink_message/decoded_payload/voltage
   • Klik op "Opslaan"
6. Herhaal stap 5 voor temperatuur en luchtvochtigheid, maar pas de topic-naam aan (vervang 'voltage' door 'temperature' of 'humidity')

Nu zie je de laatste waarden van je bootmonitor in de app. Elke keer als je Arduino nieuwe data verstuurt, wordt de app automatisch bijgewerkt.

Een stap verder: visualisatie met grafieken

Als je trends over tijd wilt zien, kun je ook grafieken toevoegen in de IoT MQTT Panel app:

1. Klik op "+" om een nieuw dashboard-item toe te voegen
2. Kies "Grafiek" als type
3. Naam: Accuspanning Grafiek
4. Topic: Hetzelfde als eerder voor accuspanning
5. Kies je gewenste grafiekinstellingen (kleuren, bereik, etc.)
6. Klik op "Opslaan"

Nu kun je zien hoe je accuspanning, temperatuur of luchtvochtigheid verandert over tijd.

Troubleshooting

Enkele veelvoorkomende problemen en hun oplossingen:

Geen data in de app?

• Controleer of je Arduino correct is aangesloten en ingeschakeld
• Controleer of je de juiste EUI's en App Key hebt gebruikt in je code
• Controleer of er een TTN Gateway in de buurt is (check de TTN coverage map)
• Kijk in de TTN Console of er data binnenkomt bij "Live data"

Data in TTN maar niet in de app?

• Controleer je MQTT-instellingen en toegangsgegevens
• Controleer of je de juiste topic-namen gebruikt
• Probeer de MQTT-verbinding te vernieuwen

Onlogische waarden?

• Controleer je sensoren en aansluitingen
• Controleer de kalibratie van je spanningsdeler
• Controleer de decoder-functie in TTN

Kosten

Een van de voordelen van deze DIY-aanpak is de lagere kosten in vergelijking met sommige commerciële oplossingen. Hier een indicatie van wat je kwijt bent:

• Arduino: €20-30
• LoRaWAN-module: €20-40
• Sensoren (temperatuur, vochtigheid, voltage): €10-20
• Behuizing en draden: €10-15
• Totaal: ongeveer €60-105

Uitbreidingsmogelijkheden

Het beschreven systeem is slechts een basis. Je kunt het systeem gemakkelijk uitbreiden met extra sensoren, zoals:

1. Waterlevel sensor voor de bilge
2. Deur-/luiksensoren om te controleren of alles gesloten is
3. Temperatuur- / luchtvochtigheidsensor voor conditie van kajuit & motorruimte. Maar ook om te controleren of je accu niet overladen wordt.
4. Walstroomdetectie om te zien of de walstroom nog werkt

Conclusie

Met relatief eenvoudige middelen en voor een fractie van de kosten van sommige commerciële systemen, kun je een basis monitoringsysteem voor je boot bouwen. Dankzij de energiezuinige LoRaWAN-technologie en het gratis The Things Network kun je je boot maandenlang in de gaten houden zonder je zorgen te maken over stroomverbruik of datakosten.

Het geeft niet alleen gemoedsrust maar kan je ook daadwerkelijk geld besparen door problemen vroegtijdig te signaleren voordat ze escaleren tot kostbare reparaties.

Als je echter een volledig ontwikkelde, professionele oplossing zoekt zonder de uitdagingen van een DIY-project, dan is het zeker de moeite waard om naar kant-en-klare systemen zoals BlueStar te kijken, die speciaal zijn ontworpen voor eenvoudige installatie (draadloze sensoren) en betrouwbare bootmonitoring.

Volgende Stappen

Geïnteresseerd om dit zelf te bouwen? Hier zijn enkele bronnen om je op weg te helpen:

1. The Things Network Community
2. Arduino Getting Started Guide
3. LoRaWAN Tutorial
4. BlueStar Bootmonitoring - Voor wie een kant-en-klare oplossing zoekt

Disclaimer: Dit project is bedoeld voor educatieve doeleinden. Zorg ervoor dat je systeem voldoet aan alle veiligheidsvoorschriften voor maritieme elektronica. Dit systeem is een aanvulling op, geen vervanging van, normale veiligheidsmaatregelen aan boord.