[Modem Request] Sercomm DM1000

[B0ndo2]

Modem Model

Sercomm DM1000

Manufacturer

Sercomm

Modem IP Address

192.168.100.1

Authentication Required

Yes - requires username/password

Authentication Details (if required)

Form based login
username: technician
/login.html

How are you providing data?

HAR Capture - Used playwright script (for auth issues)

Files Attached

modem_20260105_165923.sanitized.har.gz

Additional Information

Firmware Name: DM1000-V1.21.04.025
Firmware Build Time: Fri Jul 12 12:58:34 2024
ISP: Koodo
Status page: http://192.168.100.1/status.html

Checklist

• I have used Fallback Mode + Capture HTML, OR sanitized my files to remove PII
• I have searched my capture file for my WiFi SSID and password to verify they're not present
• I understand this may take time as it requires developing a custom parser
• I'm willing to test the parser once it's developed

[kwschulz]

Thanks for this - really solid submission. The HAR capture has everything I need: auth flow, all the channel data pages, OFDM/OFDMA for DOCSIS 3.1, version info. Nothing missing.

Sercomm is a new manufacturer for CMM, but the data format is clean (base64-encoded JSON) so it should be straightforward to build.

One thing to note: this is a one-person project, so new modems get worked in as I can. Your request is queued and ready to go - I'll ping you when I pick it up.

Thanks for the thorough capture, makes a big difference.

[B0ndo2]

I really appreciate your work. I do have some coding experience so if there is a way I could help please let me know

[kwschulz]

Thanks for offering! Good timing actually - I'm in the middle of some architecture changes that will make adding new modems mostly configuration rather than custom code.

If you want to follow along, the work-in-progress is on the feature/v3.12.0 branch - though I still have a lot of local changes that haven't been pushed yet.

Once I have the Sercomm parser working, I'd love to have you test it on your hardware. If you're interested in reviewing the code as it develops, you're welcome to - I can ping you when there's a PR to look at.

[B0ndo2]

I would be happy to test the new parser and also reviewing any new code.

[B0ndo2]

Hi, have you had time to look at the parser for this modem ?

[B0ndo2]

If it helps, here is python code to read the uptime from the status page

import requests
from bs4 import BeautifulSoup
import sys

# ===== CONFIGURATION =====
MODEM_IP = "192.168.xx.xx"          # Default IP for many cable modems
USERNAME = "technician"                   # Default username (often admin)
PASSWORD = "xxxxx"                # Default password (often "password" or "admin")
STATUS_PAGE = f"http://{MODEM_IP}/status.html"
# =========================
def main():
    # Create a session to persist cookies/auth
    session = requests.Session()
    # Set Basic Authentication (if your modem uses it)
    session.auth = (USERNAME, PASSWORD)

    try:
        # Fetch the status page
        response = session.get(STATUS_PAGE, timeout=10)
        response.raise_for_status()  # Raise an error for bad status codes
    except requests.exceptions.RequestException as e:
        print(f"Error fetching the status page: {e}")
        sys.exit(1)

    # Parse the HTML
    soup = BeautifulSoup(response.text, 'html.parser')

    # Find the table containing system status
    sys_status_table = soup.find('table', id='sys_status')
    if not sys_status_table:
        print("Could not find the system status table.")
        sys.exit(1)

    # Get the first row (which contains uptime)
    first_row = sys_status_table.find('tr')
    if not first_row:
        print("No rows found in system status table.")
        sys.exit(1)

    # Get the <td> in that row (the value cell)
    uptime_td = first_row.find('td')
    if not uptime_td:
        print("Could not find uptime value cell.")
        sys.exit(1)

    uptime = uptime_td.get_text(strip=True)
    print(f"System Uptime: {uptime}")

if __name__ == "__main__":
    main()

[kwschulz]

Thanks for checking back in, and for the Python script — that's a useful data point.

One thing I noticed: the HAR capture shows a form POST login to /setup.cgi, but your script uses HTTP Basic Auth. Does the Basic Auth approach actually work on your modem? Curious if it accepts both.

Either way, the HAR capture is what I'll be building from — it has the complete auth flow and all the channel data. The DM1000's base64-encoded JSON API is one of the cleanest data formats I've seen across 20+ modems.

I've been working on har-capture improvements and the v3.14 architecture, which is my target release for this modem. The goal with v3.14 is to make adding new modems largely configuration-driven rather than custom parser code, and the DM1000 should be a good fit for that approach. Still a few weeks away but making progress.

[B0ndo2]

One thing I noticed: the HAR capture shows a form POST login to /setup.cgi, but your script uses HTTP Basic Auth. Does the Basic Auth approach actually work on your modem? Curious if it accepts both.
It doesn't it was my fault, I had a session logged in on the same computer I ran the code and that is why it worked. Here is the correct one

#!/usr/bin/env python3

import requests
from bs4 import BeautifulSoup
import base64
import sys

MODEM_IP = "192.168.xx.xx"

USERNAME = "technician"
PASSWORD = "xxxx"

LOGIN_URL = f"http://{MODEM_IP}/setup.cgi"
STATUS_PAGE = f"http://{MODEM_IP}/status.html"


def login(session):
    encoded = base64.b64encode(PASSWORD.encode()).decode()

    payload = {
        "login_user": USERNAME,
        "pws": encoded,
        "passwd": encoded,
        "todo": "login",
        "this_file": "login.html",
        "next_file": "",
        "language": "en",
        "is_parent_window": "1",
        "message": "",
        "cur_passwd": ""
    }

    try:
        r = session.post(LOGIN_URL, data=payload, timeout=10)
        r.raise_for_status()
    except requests.exceptions.RequestException as e:
        print(f"Login failed: {e}")
        sys.exit(1)


def fetch_status(session):
    try:
        r = session.get(STATUS_PAGE, timeout=10)
        r.raise_for_status()
    except requests.exceptions.RequestException as e:
        print(f"Error fetching status page: {e}")
        sys.exit(1)

    soup = BeautifulSoup(r.text, "html.parser")

    table = soup.find("table", id="sys_status")
    if not table:
        print("Could not find system status table")
        sys.exit(1)

    row = table.find("tr")
    uptime = row.find("td").get_text(strip=True)

    print("System Uptime:", uptime)


def main():
    session = requests.Session()

    login(session)
    fetch_status(session)


if __name__ == "__main__":
    main()

[B0ndo2]

Updated code that parses more data

import base64
import requests
from datetime import timedelta
import logging
import urllib3
import voluptuous as vol

from homeassistant.components.sensor import PLATFORM_SCHEMA, SensorEntity
from homeassistant.const import CONF_NAME
import homeassistant.helpers.config_validation as cv

from .const import DOMAIN, MODEM_IP, USERNAME, PASSWORD

_LOGGER = logging.getLogger(__name__)
SCAN_INTERVAL = timedelta(minutes=5)

# Suppress urllib3 warnings from malformed modem headers
urllib3.disable_warnings(urllib3.exceptions.HeaderParsingError)
logging.getLogger("urllib3.connection").setLevel(logging.ERROR)

PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
    {vol.Optional(CONF_NAME, default="Sercomm Modem"): cv.string}
)


def fetch_modem_data():
    """Fetch modem data via JSON endpoints."""
    encoded = base64.b64encode(PASSWORD.encode()).decode()

    payload = {
        "login_user": USERNAME,
        "pws": encoded,
        "passwd": encoded,
        "todo": "login",
        "this_file": "login.html",
        "next_file": "",
        "language": "en",
        "is_parent_window": "1",
        "message": "",
        "cur_passwd": "",
    }

    headers = {
        "User-Agent": "Mozilla/5.0",
        "Referer": f"http://{MODEM_IP}/login.html",
    }

    session = requests.Session()
    session.post(
        f"http://{MODEM_IP}/setup.cgi",
        data=payload,
        headers=headers,
        timeout=5,
        verify=False,
    )

    metrics = {}

    # -----------------------------
    # System status
    # -----------------------------
    r_status = session.get(
        f"http://{MODEM_IP}/status.html", headers=headers, timeout=5, verify=False
    )

    from bs4 import BeautifulSoup

    soup = BeautifulSoup(r_status.text, "html.parser")

    sys_table = soup.find("table", id="sys_status")

    uptime = sys_table.find("td").get_text(strip=True)

    metrics["uptime"] = uptime
    metrics["correcteds"] = 0
    metrics["uncorrectables"] = 0

    for row in sys_table.find_all("tr"):
        cells = row.find_all("td")

        if len(cells) < 2:
            continue

        label = cells[0].get_text(strip=True).lower()

        try:
            value = int(cells[1].get_text(strip=True))
        except ValueError:
            continue

        if "corrected" in label:
            metrics["correcteds"] = value

        elif "uncorrectable" in label:
            metrics["uncorrectables"] = value

    # -----------------------------
    # Downstream
    # -----------------------------
    r_ds = session.get(
        f"http://{MODEM_IP}/setup.cgi?todo=RF_DS_param",
        headers=headers,
        timeout=5,
        verify=False,
    )

    ds_json = r_ds.json()

    ds_power = [
        float(n.get("PowerD", 0))
        for n in ds_json.get("nodes", [])
        if n.get("PowerD") is not None
    ]

    ds_snr = [
        float(n.get("SNRD", 0))
        for n in ds_json.get("nodes", [])
        if n.get("SNRD") is not None
    ]

    metrics["downstream_power"] = ds_power
    metrics["downstream_snr"] = ds_snr
    metrics["downstream_power_avg"] = sum(ds_power) / max(len(ds_power), 1)
    metrics["downstream_snr_avg"] = sum(ds_snr) / max(len(ds_snr), 1)
    metrics["downstream_channels"] = len(ds_power)

# --- Upstream channels ---
    r_us = session.get(
        f"http://{MODEM_IP}/setup.cgi?todo=RF_US_param",
        headers=headers,
        timeout=5,
        verify=False
    )

    us_json = r_us.json()

    us_power = []

    for n in us_json.get("nodes", []):
        raw = n.get("rep_power")

        try:
            value = float(raw)

            # Ignore modem invalid values like -inf
            if -100 < value < 100:
                us_power.append(value)

        except Exception:
            pass

    metrics["upstream_power"] = us_power
    metrics["upstream_power_avg"] = (
        sum(us_power) / len(us_power) if us_power else None
    )
    metrics["upstream_channels"] = len(us_power)
    # --- Upstream diagnostics ---
    if us_power:
        spread = max(us_power) - min(us_power)
        metrics["upstream_power_spread"] = round(spread, 2)
        metrics["upstream_power_warning"] = spread > 3
    else:
        metrics["upstream_power_spread"] = None
        metrics["upstream_power_warning"] = False
    return metrics


async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
    """Set up the Sercomm Modem sensor platform."""
    name = config.get("name")
    sensor = SercommModemSensor(name)
    async_add_entities([sensor], True)


class SercommModemSensor(SensorEntity):
    """Representation of a Sercomm Modem Sensor."""

    def __init__(self, name):
        self._name = name
        self._state = None
        self._attr_extra_state_attributes = {}

        self._last_correcteds = 0
        self._last_uncorrectables = 0
        self._last_uptime = None

    @property
    def name(self):
        return f"{self._name} Uptime"

    @property
    def state(self):
        return self._state

    async def async_update(self):
        """Fetch new state from modem in executor."""
        try:
            data = await self.hass.async_add_executor_job(fetch_modem_data)

            correcteds = data.get("correcteds", 0)
            uncorrectables = data.get("uncorrectables", 0)
            uptime = data.get("uptime")

            delta_correcteds = correcteds - self._last_correcteds
            delta_uncorrectables = uncorrectables - self._last_uncorrectables

            fec_error_spike = delta_correcteds > 100
            fec_uncorrectable_spike = delta_uncorrectables > 0

            downstream_snr = data.get("downstream_snr_avg")
            upstream_power = data.get("upstream_power_avg")

            connection_unstable = False

            if downstream_snr and downstream_snr < 33:
                connection_unstable = True

            if upstream_power and upstream_power > 50:
                connection_unstable = True

            modem_restarted = False

            def uptime_to_seconds(u):
                try:
                    parts = u.split()
                    days = int(parts[0])
                    h, m, s = map(int, parts[2].split(":"))
                    return days * 86400 + h * 3600 + m * 60 + s
                except Exception:
                    return 0

            current_seconds = uptime_to_seconds(uptime)
            last_seconds = (
                uptime_to_seconds(self._last_uptime)
                if self._last_uptime
                else 0
            )

            if self._last_uptime and current_seconds < last_seconds:
                modem_restarted = True

            self._attr_extra_state_attributes = {
                "correcteds": correcteds,
                "uncorrectables": uncorrectables,
                "delta_correcteds": delta_correcteds,
                "delta_uncorrectables": delta_uncorrectables,
                "fec_error_spike": fec_error_spike,
                "fec_uncorrectable_spike": fec_uncorrectable_spike,
                "connection_unstable": connection_unstable,
                "modem_restarted": modem_restarted,
                **{
                    k: v
                    for k, v in data.items()
                    if k not in ["uptime"]
                },
            }

            self._last_correcteds = correcteds
            self._last_uncorrectables = uncorrectables
            self._last_uptime = uptime

            self._state = uptime

        except Exception as e:
            _LOGGER.error("Failed to fetch modem data: %s", e)

[kwschulz]

Thanks for the updated script. The field mappings and inactive channel filtering are useful reference.

Still targeting v3.14 for this. I wrote up the vision for that release if you're curious: #125

You're on the list to test when it's ready. Looking forward to getting this one built.