This guide describes the complete integration of Didactum monitoring devices into Checkmk (Raw Edition, Standard Edition, and Managed Services Edition). The objective is the centralized monitoring of all connected sensors - temperature, humidity, leakage, voltage, door contacts, and others - via SNMP, including automatic service discovery, alerting, and trend graphs.

Checkmk is a comprehensive monitoring platform with a strong focus on automatic configuration. Service discovery detects many services automatically – for SNMP devices like the Didactum via a walk of the device data. Manual configuration is only required for device-specific OIDs that are not included in the standard Checkmk plugins.

Checkmk Editions Comparison

This guide applies to all editions. Deviations are explicitly indicated.

Processing workflow for SNMP devices

1. Host creation: The Didactum device is created as a host with SNMP parameters.
2. SNMP walk: Checkmk performs a full SNMP walk and stores the results in the cache.
3. Service discovery: Based on the data, Checkmk automatically detects available services.
4. Active checks: The Checkmk agent queries the SNMP OIDs at configured intervals.
5. Alerting: Notifications are triggered when thresholds are exceeded.

Important directories and files

• Checkmk 2.1.x or newer (Raw, Cloud, Standard, or Managed Edition)
• An active Checkmk site (omd create <sitename>)
• Linux server (Debian/Ubuntu or RHEL/CentOS) as Checkmk server
• Didactum monitoring device reachable in the network, SNMP enabled
• UDP port 161 open from the Checkmk server to the Didactum device
• UDP port 162 (for SNMP traps) open on the Checkmk server
• Known SNMP community string (default: public)
• Access to the Checkmk web interface as an administrator

Example network configuration

3. SNMP preparation on the Didactum device

3.1 Enable SNMP

1. Open the Didactum web interface: [http://192.168.1.100](http://192.168.1.100), log in with an admin account.
2. Navigate: Settings → Network → SNMP.
3. Set the following parameters:
   • SNMP enabled: Yes
   • SNMP version: v2c (recommended) or v3
   • Community string: public (change in production)
   • SNMP port: 161
   • Allowed Managers: enter the Checkmk server IP (192.168.1.60)
   • SNMP Trap Receiver: Checkmk server IP, port 162
4. Save the settings.

Caution: Change the default community string public in production environments. Use the same string in the Checkmk SNMP rules.

3.2 Test reachability from the Checkmk server

# Log in as site user:
su - <sitename>
 
# SNMP walk from the Checkmk server:
snmpwalk -v2c -c public 192.168.1.100 1.3.6.1.4.1.3854
 
# Query temperature sensor 1 directly:
snmpget -v2c -c public 192.168.1.100 1.3.6.1.4.1.3854.1.2.2.1.16.1.3.1
 
# Use Checkmk's own SNMP walk tool:
cmk --snmpwalk 192.168.1.100

Note: Didactum returns temperature and voltage values multiplied by 10 (235 = 23.5°C). This is taken into account in the Checkmk threshold rules and check plugins.

3.1 Enable SNMP

1. Open the Didactum web interface: [http://192.168.1.100](http://192.168.1.100), log in with an admin account.
2. Navigate: Settings → Network → SNMP.
3. Set the following parameters:
   • SNMP enabled: Yes
   • SNMP version: v2c (recommended) or v3
   • Community string: public (change in production)
   • SNMP port: 161
   • Allowed Managers: enter the Checkmk server IP (192.168.1.60)
   • SNMP Trap Receiver: Checkmk server IP, port 162
4. Save the settings.

Caution: Change the default community string public in production environments. Use the same string in the Checkmk SNMP rules.

3.2 Test reachability from the Checkmk server

# Log in as site user:
su - <sitename>
 
# SNMP walk from the Checkmk server:
snmpwalk -v2c -c public 192.168.1.100 1.3.6.1.4.1.3854
 
# Query temperature sensor 1 directly:
snmpget -v2c -c public 192.168.1.100 1.3.6.1.4.1.3854.1.2.2.1.16.1.3.1
 
# Use Checkmk's own SNMP walk tool:
cmk --snmpwalk 192.168.1.100

Note: 

Didactum returns temperature and voltage values multiplied by 10 (235 = 23.5°C). This is taken into account in the Checkmk threshold rules and check plugins.

4.1 Create host via the web interface

1. Open the Checkmk web interface: [http://192.168.1.60/<](http://192.168.1.60/<);sitename>/.
2. Navigate: Setup → Hosts → Add host.
3. Fill in the following fields:
   • Hostname: didactum-rack01
   • IP address: 192.168.1.100
   • Alias: Didactum Rack Monitoring – Server Room A
4. Under Monitoring agents:
   • Checkmk agent / API integrations: No API integrations, no Checkmk agent
   • SNMP: select SNMP v2c
   • SNMP credentials: enter the community string public
5. Under Custom attributes:
   • Labels: device_type:didactum, location:serverraum-a
6. Click Save & run service discovery.

4.2 Recommended host tag and folder structure

1. Navigate: Setup → Hosts → Folders → Add subfolder.
2. Create folder: Rack-Monitoring / Didactum
3. Set folder attribute: SNMP communities → public for all hosts in the folder.
4. Place all Didactum hosts in this folder – SNMP settings are inherited.

4.3 Configure host for SNMP v3

1. When creating the host, under SNMP: select SNMP v3.
2. Additional fields:
   • Security name: SNMP-v3 username from the Didactum device
   • Authentication protocol: SHA
   • Authentication password: authentication password
   • Privacy protocol: AES
   • Privacy password: encryption password

5.1 Store SNMP community globally or per host

Via Setup → Hosts → SNMP credentials of monitored hosts community strings can be stored for individual IPs or IP ranges without manually editing the host:

1. Navigate: Setup → Global settings → SNMP → SNMP communities or Setup → Hosts → Rulesets → SNMP credentials.
2. Create a new rule:
   • Conditions → Explicit hosts: didactum-rack01
   • SNMP community: public
   • SNMP version: v2c
3. Save and activate.

5.2 Enable SNMP bulk walk (performance optimization)

# In the site configuration:
# Setup → Global settings → SNMP → Use SNMP bulk walk
# Enable for better performance when handling many OIDs.

5.3 Integrate the Didactum MIB file into Checkmk

# As site user:
su - <sitename>
 
# Copy the MIB into the site MIB directory:
cp DIDACTUM-RACKMONI2-MIB.mib ~/local/share/check_mk/mibs/
 
# Check the MIB directory:
ls ~/local/share/check_mk/mibs/
 
# MIBs are used automatically in the next SNMP walk.

6.1 Start service discovery

1. Navigate: Setup → Hosts → didactum-rack01 → Run service discovery.
2. Checkmk performs an SNMP walk and displays all detected services.
3. Typically detected standard services:
   • SNMP Info (system description, uptime)
   • Interface status (network interface)
   • SNMP uptime
4. Accept all desired services with Accept all.
5. Activate changes: Activate changes (yellow button in the top right).

Note: 

Didactum-specific sensor OIDs are only recognized by the automatic service discovery if a matching Checkmk plugin is available. For device-specific sensors, manual SNMP checks are required (see section 7).

6.2 Enable periodic service discovery

1. Navigate: Setup → Hosts → Rulesets → Periodic service discovery.
2. Create a new rule:
   • Conditions: Label device_type:didactum
   • Perform service discovery every: 4 hours
   • Severity of unmonitored services: Warning
3. Save – new sensors will be detected automatically as soon as they are connected.

For Didactum-specific OIDs that are not recognized by automatic discovery, Checkmk offers two approaches: the SNMP check via rules in the web interface or a custom check plugin written in Python.

7.1 Method 1: SNMP checks via the web interface (recommended for beginners)

1. Navigate: Setup → Services → Service monitoring rules → SNMP checks or directly: Setup → Hosts → Rulesets → SNMP checks for custom values.
2. Click Add rule.
3. Enter the following parameters for temperature sensor 1:
   • Service description: Temperature Sensor 1 – Rack Front
   • OID: .1.3.6.1.4.1.3854.1.2.2.1.16.1.3.1
   • SNMP data type: Integer
   • Warning above: 300 (= 30.0 °C × 10)
   • Critical above: 350 (= 35.0 °C × 10)
   • Unit: x10=°C
4. Under Conditions: restrict explicitly to didactum-rack01.
5. Save and run service discovery again – the new service will appear.

7.2 Method 2: Custom Checkmk plugin in Python

For a clean, reusable integration a custom Checkmk plugin is recommended. Create it as a site user:

su - <sitename>
mkdir -p ~/local/lib/check_mk/base/plugins/agent_based/
nano ~/local/lib/check_mk/base/plugins/agent_based/didactum_sensors.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Checkmk check plugin for Didactum monitoring devices
Monitors temperature, leak and humidity sensors via SNMP.
"""
 
from cmk.base.plugins.agent_based.agent_based_api.v1 import (
    SNMPTree, OIDEnd, register, Service, Result, State,
    check_levels, startswith, contains
)
 
# ── OID DEFINITIONS ───────────────────────────────────────────────────────────
 
DIDACTUM_BASE = ".1.3.6.1.4.1.3854.1.2.2.1"
 
OID_TEMP_NAME   = DIDACTUM_BASE + ".16.1.2"
OID_TEMP_VALUE  = DIDACTUM_BASE + ".16.1.3"
OID_TEMP_STATUS = DIDACTUM_BASE + ".16.1.4"
OID_TEMP_HI     = DIDACTUM_BASE + ".16.1.7"
OID_TEMP_LO     = DIDACTUM_BASE + ".16.1.8"
 
OID_HUM_NAME    = DIDACTUM_BASE + ".17.1.2"
OID_HUM_VALUE   = DIDACTUM_BASE + ".17.1.3"
OID_HUM_STATUS  = DIDACTUM_BASE + ".17.1.4"
 
OID_LEAK_NAME   = DIDACTUM_BASE + ".18.1.2"
OID_LEAK_STATUS = DIDACTUM_BASE + ".18.1.4"
 
# ── SNMP SECTION: TEMPERATURE ─────────────────────────────────────────────────
 
register.snmp_section(
    name="didactum_temperature",
    detect=contains(".1.3.6.1.2.1.1.1.0", "didactum"),
    fetch=SNMPTree(
        base=DIDACTUM_BASE + ".16.1",
        oids=[OIDEnd(), "2", "3", "4"],
    ),
    parse_function=lambda string_table: {
        idx: {"name": name, "value": int(value), "status": int(status)}
        for idx, name, value, status in string_table
        if value.isdigit()
    },
)
 
# ── CHECK: TEMPERATURE ────────────────────────────────────────────────────────
 
def discover_didactum_temperature(section):
    for idx, data in section.items():
        yield Service(item=idx, parameters={"sensor_name": data["name"]})
 
def check_didactum_temperature(item, params, section):
    if item not in section:
        yield Result(state=State.UNKNOWN, summary="Sensor not found")
        return
 
    data = section[item]
    raw_value = data["value"]
    temp_celsius = raw_value / 10.0
    status_code = data["status"]
 
    # Evaluate device status:
    status_map = {0: (State.OK, "OK"), 1: (State.WARN, "Warning"), 2: (State.CRIT, "Alarm")}
    device_state, device_text = status_map.get(status_code, (State.UNKNOWN, "Unknown"))
 
    warn = params.get("warn", 30.0)
    crit = params.get("crit", 35.0)
 
    yield from check_levels(
        temp_celsius,
        levels_upper=(warn, crit),
        metric_name="temperature",
        label=f"Temperature {data['name']}",
        render_func=lambda v: f"{v:.1f} °C",
    )
 
    if device_state != State.OK:
        yield Result(state=device_state, summary=f"Device status: {device_text}")
 
register.check_plugin(
    name="didactum_temperature",
    service_name="Temperature %s",
    discovery_function=discover_didactum_temperature,
    check_function=check_didactum_temperature,
    check_default_parameters={"warn": 30.0, "crit": 35.0},
)
 
# ── SNMP SECTION: LEAK ────────────────────────────────────────────────────────
 
register.snmp_section(
    name="didactum_leak",
    detect=contains(".1.3.6.1.2.1.1.1.0", "didactum"),
    fetch=SNMPTree(
        base=DIDACTUM_BASE + ".18.1",
        oids=[OIDEnd(), "2", "4"],
    ),
    parse_function=lambda string_table: {
        idx: {"name": name, "status": int(status)}
        for idx, name, status in string_table
        if status.isdigit()
    },
)
 
def discover_didactum_leak(section):
    for idx, data in section.items():
        yield Service(item=idx, parameters={"sensor_name": data["name"]})
 
def check_didactum_leak(item, params, section):
    if item not in section:
        yield Result(state=State.UNKNOWN, summary="Leak sensor not found")
        return
 
    data = section[item]
    status = data["status"]
    name = data["name"]
 
    if status == 0:
        yield Result(state=State.OK, summary=f"{name}: Dry (no water)")
    else:
        yield Result(state=State.CRIT, summary=f"LEAK DETECTED: {name}! Immediate action required!")
 
register.check_plugin(
    name="didactum_leak",
    service_name="Leak %s",
    discovery_function=discover_didactum_leak,
    check_function=check_didactum_leak,
    check_default_parameters={},
)
 
# ── SNMP SECTION: HUMIDITY ────────────────────────────────────────────────────
 
register.snmp_section(
    name="didactum_humidity",
    detect=contains(".1.3.6.1.2.1.1.1.0", "didactum"),
    fetch=SNMPTree(
        base=DIDACTUM_BASE + ".17.1",
        oids=[OIDEnd(), "2", "3", "4"],
    ),
    parse_function=lambda string_table: {
        idx: {"name": name, "value": int(value), "status": int(status)}
        for idx, name, value, status in string_table
        if value.isdigit()
    },
)
 
def discover_didactum_humidity(section):
    for idx, data in section.items():
        yield Service(item=idx, parameters={"sensor_name": data["name"]})
 
def check_didactum_humidity(item, params, section):
    if item not in section:
        yield Result(state=State.UNKNOWN, summary="Humidity sensor not found")
        return
 
    data = section[item]
    humidity = data["value"]
 
    yield from check_levels(
        humidity,
        levels_upper=(params.get("warn_high", 70), params.get("crit_high", 80)),
        levels_lower=(params.get("crit_low", 10), params.get("warn_low", 20)),
        metric_name="humidity",
        label=f"Humidity {data['name']}",
        render_func=lambda v: f"{v:.0f} % rF",
    )
 
register.check_plugin(
    name="didactum_humidity",
    service_name="Humidity %s",
    discovery_function=discover_didactum_humidity,
    check_function=check_didactum_humidity,
    check_default_parameters={
        "warn_high": 70, "crit_high": 80,
        "warn_low": 20,  "crit_low": 10,
    },
)

7.3 Activate and test the plugin

# As site user:
su - <sitename>
 
# Check plugin syntax:
python3 ~/local/lib/check_mk/base/plugins/agent_based/didactum_sensors.py
 
# Load and test the check plugin in Checkmk:
cmk -v --detect-plugins=didactum_temperature didactum-rack01
 
# Run service discovery with the new plugin:
cmk -I didactum-rack01
 
# Run the check directly:
cmk -v didactum-rack01

7.4 SNMP check via ruleset for individual OIDs (without plugin)

As an alternative to the plugin, individual OIDs can be monitored via the SNMP checks for custom values ruleset:

# Navigation in the web interface:
# Setup → Service monitoring rules → SNMP → SNMP checks for custom values
 
# Example configuration for leak sensor 1:
# Service description: Leak Sensor 1 – Floor area
# OID:                 .1.3.6.1.4.1.3854.1.2.2.1.18.1.4.1
# Expected regex:      ^0$          (only value 0 is OK)
# Severity on failure: CRITICAL

All OIDs are based on the Didactum Enterprise OID root 1.3.6.1.4.1.3854. The placeholder {n} stands for the sensor index (1 = first sensor, etc.).

8.1 Temperature sensors

8.2 Leak sensors

8.3 Humidity sensors

8.4 Additional sensors

9.1 Define thresholds for the own plugin via ruleset

In order to maintain thresholds centrally via the web interface (instead of within the plugin code), a ruleset plugin is created:

su - <sitename>
nano ~/local/lib/check_mk/base/plugins/agent_based/didactum_rulesets.py

#!/usr/bin/env python3
from cmk.gui.plugins.wato.utils import (
    CheckParameterRulespecWithItem,
    rulespec_registry,
    RulespecGroupCheckParametersEnvironment,
)
from cmk.gui.valuespec import Dictionary, Tuple, Float, TextInput
 
def _parameter_valuespec_didactum_temperature():
    return Dictionary(
        title="Didactum temperature thresholds",
        elements=[
            ("warn", Float(title="Warning level (°C)", default_value=30.0)),
            ("crit", Float(title="Critical level (°C)", default_value=35.0)),
        ],
    )
 
rulespec_registry.register(
    CheckParameterRulespecWithItem(
        check_group_name="didactum_temperature",
        group=RulespecGroupCheckParametersEnvironment,
        match_type="dict",
        parameter_valuespec=_parameter_valuespec_didactum_temperature,
        title=lambda: "Didactum temperature sensor",
    )
)

9.2 Adjust thresholds via the web interface

1. Navigate: Setup → Service monitoring rules → Didactum temperature sensor.
2. Create a new rule:
   • Warning level: 30.0 °C
   • Critical level: 35.0 °C
   • Conditions: Host label device_type:didactum
3. Save and activate changes.

9.3 Recommended thresholds

10.1 Create notification rule

1. Navigate: Setup → Events → Notifications → Add rule.
2. General settings:
   • Rule description: Didactum sensor alarms
   • Notification method: HTML email
3. Under Conditions:
   • Match host labels: device_type:didactum
   • Service state: WARN, CRIT, UNKNOWN
   • Notification type: Problem, Recovery
4. Under Contacts:
   • Select contacts or contact groups
5. Save and activate.

10.2 Separate escalation rule for leak

1. Create a new notification rule.
2. Conditions → Match service groups: Leak sensors
3. Conditions → Service state: CRIT only
4. Notification method: HTML email + SMS via script
5. Throttling: First notification immediately, repeat every 5 minutes
6. Enter additional contacts (on‑call, management).

10.3 Maintenance window for Didactum devices

1. Navigate: Monitor → Schedule downtimes.
2. Select host didactum‑rack01, enter time range and comment.
3. No alarms are triggered during the maintenance window.

10.4 Acknowledgements

Immediately acknowledge a leak alarm to pause further notifications:

1. In the monitoring area: click the service.
2. Click the Acknowledge button.
3. Enter a comment (e.g., Technician alerted, en route on site).
4. Pause notifications until the problem is resolved.

Checkmk can receive and process SNMP traps via its built‑in Event Console (EC) module. The Event Console is a standalone component that evaluates traps as events and optionally converts them into Checkmk alerts.

11.1 Enable Event Console

# As site user:
su - <sitename>
 
# Enable Event Console:
omd config set MKEVENTD on
omd restart mkeventd

Alternatively in the web interface: Setup → Events → Event Console → Enable Event Console.

11.2 Configure SNMP trap receiver

# snmptrapd must run on the system and forward traps to the Event Console:
sudo nano /etc/snmp/snmptrapd.conf

# Accept all traps:
authCommunity log,execute,net public
 
# Forward traps to Checkmk Event Console:
traphandle default /omd/sites/<sitename>/bin/mkeventd_open514

# Open snmptrapd UDP port 162:
sudo ufw allow 162/udp
 
# Start snmptrapd:
sudo systemctl enable snmptrapd
sudo systemctl start snmptrapd

11.3 Create event rule for Didactum traps

1. Navigate: Setup → Events → Event Console → Event rules → Add rule.
2. Enter the following parameters for leak traps:
   • Description: Didactum leak alarm trap
   • Match syslog application / SNMP trap OID: 1.3.6.1.4.1.3854.1.7.2
   • State: CRITICAL
   • Service level: Gold
3. Under Actions:
   • Enable Create notification
   • Enter contact group
4. Save and activate.

11.4 Important Didactum trap OIDs for the Event Console

# Log in as site user:
su - <sitename>
 
# Perform SNMP walk for Didactum device:
cmk --snmpwalk didactum-rack01
 
# Show SNMP walk cache:
cat ~/var/check_mk/snmp_cache/didactum-rack01
 
# Run service discovery:
cmk -I didactum-rack01
 
# Check all services of the host:
cmk -v didactum-rack01
 
# Debug a single check:
cmk -v --detect-plugins=didactum_temperature didactum-rack01
 
# Reload Checkmk configuration (after changes):
cmk -O
 
# Activate all changes (command line):
cmk -R
 
# Test SNMP reachability directly:
snmpwalk -v2c -c public 192.168.1.100 1.3.6.1.4.1.3854
 
# Query a single OID:
snmpget -v2c -c public 192.168.1.100 1.3.6.1.4.1.3854.1.2.2.1.16.1.3.1
 
# Check Event Console logs:
tail -f ~/var/log/mkeventd.log
 
# Check notification log:
tail -f ~/var/log/notify.log
 
# Checkmk main log:
tail -f ~/var/log/cmc.log     # CMC (Standard/Managed Edition)
tail -f ~/var/log/nagios.log  # Nagios-Core (Raw Edition)
 
# Check site status:
omd status
 
# Restart site:
omd restart

Always consult the current Didactum device documentation for firmware‑specific OIDs and supported sensor types.