ust-format-checker 0.1.0__py3-none-any.whl

ust_format_checker/__init__.py

@@ -0,0 +1,16 @@
+from .checks import check_log
+from .findings import Finding, Level, counts_by_level, has_errors
+from .parser_layer import check_with_parser
+from .report import render
+from .schema import load_schema
+
+__all__ = [
+    "Finding",
+    "Level",
+    "check_log",
+    "check_with_parser",
+    "counts_by_level",
+    "has_errors",
+    "load_schema",
+    "render",
+]

ust_format_checker/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

ust_format_checker/build.py

@@ -0,0 +1,34 @@
+import argparse
+import sys
+from pathlib import Path
+
+from .scenario import build, load_board, load_scenario, write_stimulus
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="xdos-build",
+        description="Sestaví z board.yaml a scénáře vstup pro simulátor.",
+    )
+    parser.add_argument("--board", type=Path, required=True)
+    parser.add_argument("--scenario", type=Path, help="bez něj se použije výchozí scénář z osazení desky")
+    parser.add_argument("--out", type=Path, required=True, help="kam uložit direktivy pro runner")
+    parser.add_argument("--stimulus-out", type=Path, help="kam uložit vyslané hodnoty pro kontrolu výstupu")
+    args = parser.parse_args(argv)
+
+    board = load_board(args.board)
+    scenario = load_scenario(args.scenario) if args.scenario else None
+    stimulus = build(board, scenario)
+
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    args.out.write_text(stimulus.directives, encoding="utf-8")
+    if args.stimulus_out:
+        args.stimulus_out.parent.mkdir(parents=True, exist_ok=True)
+        write_stimulus(stimulus, args.stimulus_out)
+
+    print(f"{board.device} / {stimulus.scenario}: {args.out} (seed {stimulus.seed})")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ust_format_checker/checks.py

@@ -0,0 +1,253 @@
+import re
+from dataclasses import dataclass, field
+
+from .findings import Finding, Level
+from .rules import RULES, LogState
+from .schema import FieldSpec, MessageSpec, Schema, load_schema
+
+_UINT_RE = re.compile(r"^\d+$")
+_INT_RE = re.compile(r"^-?\d+$")
+_TM_RE = re.compile(r"^(\d+)\.(\d{1,2})$")
+_DATETIME_RE = re.compile(r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$")
+
+TYPE_DESCRIPTIONS = {
+    "uint": "celé nezáporné číslo",
+    "int": "celé číslo (může být záporné)",
+    "float": "desetinné číslo",
+    "tm": "čas ve tvaru <tm>.<tm_s100>, kde tm_s100 je 0-99",
+    "datetime": "časové razítko ve tvaru YYYY-MM-DD HH:MM:SS",
+}
+
+
+@dataclass
+class ParsedMessage:
+    spec: MessageSpec
+    tokens: list[str]
+    values: dict[str, object] = field(default_factory=dict)
+    line_number: int = 0
+    line: str = ""
+
+
+def _validate(spec: FieldSpec, token: str) -> tuple[bool, object, str]:
+    """Return (ok, parsed value, human description of what was expected)."""
+    if spec.type == "text":
+        return True, token, "text"
+    if spec.type == "uint":
+        return (True, int(token), "") if _UINT_RE.match(token) else (False, None, TYPE_DESCRIPTIONS["uint"])
+    if spec.type == "int":
+        return (True, int(token), "") if _INT_RE.match(token) else (False, None, TYPE_DESCRIPTIONS["int"])
+    if spec.type == "float":
+        try:
+            return True, float(token), ""
+        except ValueError:
+            return False, None, TYPE_DESCRIPTIONS["float"]
+    if spec.type == "tm":
+        match = _TM_RE.match(token)
+        if not match or int(match.group(2)) > 99:
+            return False, None, TYPE_DESCRIPTIONS["tm"]
+        return True, (int(match.group(1)), int(match.group(2))), ""
+    if spec.type == "datetime":
+        if not _DATETIME_RE.match(token):
+            return False, None, TYPE_DESCRIPTIONS["datetime"]
+        return True, token, ""
+    if spec.type == "hex":
+        pattern = rf"^[0-9a-fA-F]{{{spec.length}}}$"
+        if not re.match(pattern, token):
+            return False, None, f"{spec.length} hexadecimálních znaků"
+        return True, token, ""
+    if spec.type == "enum":
+        if token not in spec.values:
+            return False, None, " nebo ".join(spec.values)
+        return True, token, ""
+    if spec.type == "labeled_hex":
+        if not re.match(rf"^{re.escape(spec.label)}=0x[0-9a-fA-F]+$", token):
+            return False, None, f"{spec.label}=0x<hex>"
+        return True, token.split("=", 1)[1], ""
+    raise ValueError(f"unknown field type: {spec.type}")
+
+
+def _check_fields(message: ParsedMessage) -> list[Finding]:
+    findings = []
+    for index, spec in enumerate(message.spec.fields, start=1):
+        if index >= len(message.tokens):
+            break
+        token = message.tokens[index]
+        ok, value, expected = _validate(spec, token)
+        if not ok:
+            findings.append(
+                Finding(
+                    level=spec.level,
+                    code="FIELD_TYPE",
+                    title=f"{message.spec.prefix}: pole {index} ({spec.name}) je {token!r}, očekává se {expected}",
+                    line_number=message.line_number,
+                    line=message.line,
+                    shape=message.spec.shape,
+                    why="Konzumenti čtou pole podle pozice a typu. Neplatná hodnota se buď "
+                    "zahodí, nebo se přečte jako něco jiného.",
+                    help=f"Vypisuj {spec.name} jako {expected}.",
+                )
+            )
+            continue
+
+        message.values[spec.name] = value
+
+        if spec.max is not None and isinstance(value, int) and value > spec.max:
+            findings.append(
+                Finding(
+                    level=Level.ERROR,
+                    code="FIELD_MAX",
+                    title=f"{message.spec.prefix}: {spec.name} = {value} přesahuje maximum {spec.max}",
+                    line_number=message.line_number,
+                    line=message.line,
+                    shape=message.spec.shape,
+                    why="Hodnota se nevejde do rozsahu, se kterým formát počítá.",
+                    help=f"Zkontroluj zdroj hodnoty {spec.name}.",
+                )
+            )
+        if spec.warn_min is not None and isinstance(value, (int, float)) and not (
+            spec.warn_min <= value <= spec.warn_max
+        ):
+            unit = f" {spec.unit}" if spec.unit else ""
+            findings.append(
+                Finding(
+                    level=Level.WARNING,
+                    code="FIELD_RANGE",
+                    title=f"{message.spec.prefix}: {spec.name} = {value}{unit} je mimo očekávaný "
+                    f"rozsah {spec.warn_min} až {spec.warn_max}{unit}",
+                    line_number=message.line_number,
+                    line=message.line,
+                    shape=message.spec.shape,
+                    why="Hodnota mimo rozsah senzoru obvykle znamená prohozená nebo posunutá pole.",
+                    help=f"Ověř, že na pozici {index} je opravdu {spec.name}.",
+                )
+            )
+    return findings
+
+
+def _check_trailing(message: ParsedMessage) -> list[Finding]:
+    spec = message.spec.trailing
+    findings = []
+    values = []
+    for index in range(message.spec.known_tokens, len(message.tokens)):
+        ok, value, expected = _validate(spec, message.tokens[index])
+        if not ok:
+            findings.append(
+                Finding(
+                    level=Level.ERROR,
+                    code="FIELD_TYPE",
+                    title=f"{message.spec.prefix}: {spec.name}[{index - message.spec.known_tokens}] "
+                    f"je {message.tokens[index]!r}, očekává se {expected}",
+                    line_number=message.line_number,
+                    line=message.line,
+                    shape=message.spec.shape,
+                    why="Neplatná hodnota v histogramu posune odečet ostatních kanálů.",
+                    help=f"Vypisuj {spec.name} jako {expected}.",
+                )
+            )
+        else:
+            values.append(value)
+    message.values[spec.name] = values
+    return findings
+
+
+def _check_token_count(message: ParsedMessage) -> list[Finding]:
+    spec = message.spec
+    count = len(message.tokens)
+    if count < spec.required_tokens:
+        missing = [f.name for f in spec.fields[count - 1:] if not f.optional]
+        return [
+            Finding(
+                level=Level.ERROR,
+                code="MISSING_FIELDS",
+                title=f"{spec.prefix} má {count - 1} polí, očekává se aspoň {spec.required_tokens - 1}",
+                line_number=message.line_number,
+                line=message.line,
+                shape=spec.shape,
+                why="Konzumenti čtou pole podle pozice. Chybějící pole posune význam všech dalších "
+                "a zprávu obvykle zahodí celou.",
+                help=f"Doplň chybějící pole ({', '.join(missing)}) a zachovej pořadí.",
+            )
+        ]
+    if spec.trailing is None and spec.extra_tokens and count > spec.known_tokens:
+        extra = count - spec.known_tokens
+        return [
+            Finding(
+                level=spec.extra_tokens,
+                code="EXTRA_FIELDS",
+                title=f"{spec.prefix} má {extra} pole navíc oproti schématu",
+                line_number=message.line_number,
+                line=message.line,
+                shape=spec.shape,
+                why="Rozšiřování na konec je povolené, ale konzumenti o nových polích nevědí, "
+                "dokud se nepřidají do schématu a dokumentace.",
+                help="Pokud je rozšíření záměrné, přidej pole do schématu a do dokumentace formátu.",
+            )
+        ]
+    return []
+
+
+def check_log(text: str, schema: Schema | None = None) -> list[Finding]:
+    """Check one captured log against the message schema (layer 1 of docs/CHECKS.md)."""
+    schema = schema or load_schema()
+    state = LogState()
+    findings: list[Finding] = []
+    unknown: dict[str, int] = {}
+    deferred: dict[str, int] = {}
+
+    for line_number, raw_line in enumerate(text.splitlines(), start=1):
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+
+        tokens = line.split(",")
+        prefix = tokens[0]
+        if prefix in schema.deferred_prefixes:
+            deferred[prefix] = deferred.get(prefix, 0) + 1
+            continue
+        spec = schema.messages.get(prefix)
+        if spec is None:
+            unknown[prefix] = unknown.get(prefix, 0) + 1
+            continue
+
+        message = ParsedMessage(spec=spec, tokens=tokens, line_number=line_number, line=line)
+        count_findings = _check_token_count(message)
+        findings.extend(count_findings)
+        if any(f.code == "MISSING_FIELDS" for f in count_findings):
+            continue
+
+        findings.extend(_check_fields(message))
+        if spec.trailing is not None:
+            findings.extend(_check_trailing(message))
+        for rule_name in spec.rules:
+            findings.extend(RULES[rule_name](message, state))
+        state.observe(message)
+
+    findings.extend(_summarize_prefixes(deferred, unknown))
+    return findings
+
+
+def _summarize_prefixes(deferred: dict[str, int], unknown: dict[str, int]) -> list[Finding]:
+    findings = []
+    if deferred:
+        listed = ", ".join(f"{prefix} ({count}x)" for prefix, count in sorted(deferred.items()))
+        findings.append(
+            Finding(
+                level=Level.INFO,
+                code="DEFERRED_PREFIX",
+                title=f"Zprávy zatím mimo schéma: {listed}",
+                why="Tyhle zprávy zná parser nebo firmware, ale dokumentace formátu je nepopisuje.",
+                help="Doplnění schématu je fáze F7, viz docs/DOC_DEVIATIONS.md (D2, D3).",
+            )
+        )
+    if unknown:
+        listed = ", ".join(f"{prefix} ({count}x)" for prefix, count in sorted(unknown.items()))
+        findings.append(
+            Finding(
+                level=Level.INFO,
+                code="UNKNOWN_PREFIX",
+                title=f"Neznámé zprávy: {listed}",
+                why="Zpráva není ve schématu, takže se nekontroluje.",
+                help="Pokud jde o novou zprávu formátu, přidej ji do messages.yaml a do dokumentace.",
+            )
+        )
+    return findings

ust_format_checker/cli.py

@@ -0,0 +1,90 @@
+import argparse
+import sys
+from pathlib import Path
+
+from .checks import check_log
+from .compat import compare_to_golden, unchecked_messages
+from .findings import Finding, Level, has_errors
+from .parser_layer import check_with_parser
+from .report import render
+from .scenario import read_stimulus
+from .stimulus_checks import check_against_stimulus
+
+
+def run(
+    path: Path,
+    with_parser: bool = True,
+    golden: Path | None = None,
+    stimulus: Path | None = None,
+    summary: bool = True,
+) -> list[Finding]:
+    raw = path.read_bytes()
+    text = raw.decode("utf-8", errors="replace")
+
+    golden_text = golden.read_text(encoding="utf-8", errors="replace") if golden else None
+
+    findings = check_log(text)
+    if stimulus is not None:
+        findings.extend(check_against_stimulus(text, read_stimulus(stimulus)))
+    if golden_text is not None:
+        findings.extend(compare_to_golden(text, golden_text))
+    if with_parser:
+        findings.extend(check_with_parser(raw))
+    if summary:
+        not_emitted = unchecked_messages(text, golden_text)
+        if not_emitted is not None:
+            findings.append(not_emitted)
+    return findings
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="xdos-check",
+        description="Zkontroluje zachycený log xDOS zařízení proti schématu formátu.",
+    )
+    parser.add_argument("log", type=Path, help="soubor se zachyceným výstupem zařízení")
+    parser.add_argument("--golden", type=Path, help="referenční záznam z posledního release")
+    parser.add_argument(
+        "--stimulus", type=Path, help="JSON s vyslanými hodnotami (výstup xdos-build)"
+    )
+    parser.add_argument(
+        "--accept",
+        action="store_true",
+        help="uloží tenhle záznam jako nový referenční (vyžaduje --golden)",
+    )
+    parser.add_argument("--no-parser", action="store_true", help="vynechá kontrolu parserem DOSPORTAL")
+    parser.add_argument("--warnings-as-errors", action="store_true", help="režim CI: varování blokují")
+    args = parser.parse_args(argv)
+
+    # a console that cannot encode the report (Windows cp1252) must not crash on it; the
+    # encoding itself is left alone so report.marks() can fall back to ASCII
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(errors="replace")
+
+    if args.accept:
+        if args.golden is None:
+            parser.error("--accept vyžaduje --golden s cestou, kam se má záznam uložit")
+        args.golden.parent.mkdir(parents=True, exist_ok=True)
+        args.golden.write_bytes(args.log.read_bytes())
+        print(f"Referenční záznam uložen: {args.golden}")
+        return 0
+
+    golden = args.golden if args.golden and args.golden.exists() else None
+    findings = run(
+        args.log, with_parser=not args.no_parser, golden=golden, stimulus=args.stimulus
+    )
+    print(render(findings, source=args.log.name))
+
+    if args.golden and golden is None:
+        print(f"Referenční záznam {args.golden} zatím neexistuje, kompatibilita se nekontrolovala.")
+        print(f"Vytvoříš ho: xdos-check {args.log} --golden {args.golden} --accept")
+
+    if has_errors(findings):
+        return 1
+    if args.warnings_as_errors and any(f.level is Level.WARNING for f in findings):
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ust_format_checker/compat.py

@@ -0,0 +1,229 @@
+"""Layer 2 of docs/CHECKS.md: compare a capture against a golden capture from the last release.
+
+The reference is a plain captured log, not a derived file, so a format change shows up as a
+readable diff in the device repository.
+"""
+
+import re
+from dataclasses import dataclass
+
+from .findings import Finding, Level
+from .schema import Schema, load_schema
+
+_UINT_RE = re.compile(r"^\d+$")
+_INT_RE = re.compile(r"^-?\d+$")
+_DATETIME_RE = re.compile(r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$")
+_HEX_RE = re.compile(r"^[0-9a-fA-F]+$")
+_LABELED_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*=0x[0-9a-fA-F]+$")
+
+TYPE_NAMES = {
+    "uint": "celé nezáporné číslo",
+    "int": "celé číslo",
+    "float": "desetinné číslo",
+    "datetime": "časové razítko",
+    "hex": "hexadecimální řetězec",
+    "labeled": "pojmenovaná hodnota (název=0x…)",
+    "text": "text",
+    "empty": "prázdná hodnota",
+}
+
+
+def classify(token: str) -> str:
+    """A time <tm>.<tm_s100> has no type of its own here: it looks exactly like any other
+    decimal number, so telling them apart would only invent differences. The schema layer
+    checks tm where the schema says a field is one."""
+    if token == "":
+        return "empty"
+    if _UINT_RE.match(token):
+        return "uint"
+    if _INT_RE.match(token):
+        return "int"
+    if _DATETIME_RE.match(token):
+        return "datetime"
+    if _LABELED_RE.match(token):
+        return "labeled"
+    try:
+        float(token)
+        return "float"
+    except ValueError:
+        pass
+    if _HEX_RE.match(token):
+        return "hex"
+    return "text"
+
+
+@dataclass
+class MessageProfile:
+    prefix: str
+    occurrences: int = 0
+    min_tokens: int | None = None
+    max_tokens: int = 0
+    types: list[set[str]] = None
+
+    def observe(self, tokens: list[str]) -> None:
+        self.occurrences += 1
+        count = len(tokens)
+        self.min_tokens = count if self.min_tokens is None else min(self.min_tokens, count)
+        self.max_tokens = max(self.max_tokens, count)
+        if self.types is None:
+            self.types = []
+        while len(self.types) < count:
+            self.types.append(set())
+        for index, token in enumerate(tokens):
+            self.types[index].add(classify(token))
+
+
+def profile_log(text: str) -> dict[str, MessageProfile]:
+    profiles: dict[str, MessageProfile] = {}
+    for raw_line in text.splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#") or not line.startswith("$"):
+            continue
+        tokens = line.split(",")
+        profile = profiles.setdefault(tokens[0], MessageProfile(prefix=tokens[0]))
+        profile.observe(tokens)
+    return profiles
+
+
+def compare_to_golden(current: str, golden: str, schema: Schema | None = None) -> list[Finding]:
+    schema = schema or load_schema()
+    now = profile_log(current)
+    before = profile_log(golden)
+    findings: list[Finding] = []
+
+    for prefix, reference in sorted(before.items()):
+        spec = schema.messages.get(prefix)
+        shape = spec.shape if spec else None
+        observed = now.get(prefix)
+        if observed is None:
+            findings.append(
+                Finding(
+                    level=Level.ERROR,
+                    code="MESSAGE_DISAPPEARED",
+                    title=f"{prefix} je v referenčním záznamu ({reference.occurrences}x), "
+                    "ale v novém výstupu chybí",
+                    shape=shape,
+                    why="Konzumenti, kteří zprávu čtou, o data přijdou. Odstranění zprávy je "
+                    "nekompatibilní změna formátu.",
+                    help="Pokud má zpráva zmizet, vyžaduje to novou verzi formátu a úpravu "
+                    "parseru v DOSPORTAL. Jinak ji vypisuj dál.",
+                )
+            )
+            continue
+        findings.extend(_compare_message(prefix, reference, observed, spec, shape))
+
+    for prefix, observed in sorted(now.items()):
+        if prefix not in before:
+            findings.append(
+                Finding(
+                    level=Level.INFO,
+                    code="MESSAGE_ADDED",
+                    title=f"{prefix} je nová oproti referenčnímu záznamu ({observed.occurrences}x)",
+                    why="Nová zpráva je zpětně kompatibilní, konzumenti neznámý prefix ignorují.",
+                    help="Popiš ji v dokumentaci formátu a přidej do messages.yaml.",
+                )
+            )
+    return findings
+
+
+def _compare_message(prefix, reference, observed, spec, shape) -> list[Finding]:
+    has_tail = spec is not None and spec.trailing is not None
+    fixed = spec.known_tokens if has_tail else None
+    findings = _compare_types(prefix, reference, observed, shape, fixed if has_tail else None)
+
+    # a field inserted in the middle also lengthens the message; reporting the length on top of
+    # the type change would just repeat the same finding
+    if findings:
+        return findings
+
+    if not has_tail:
+        if observed.min_tokens < reference.min_tokens:
+            findings.append(
+                Finding(
+                    level=Level.ERROR,
+                    code="FIELDS_REMOVED",
+                    title=f"{prefix} má nově jen {observed.min_tokens - 1} polí, referenční "
+                    f"záznam měl {reference.min_tokens - 1}",
+                    shape=shape,
+                    why="Formát se smí rozšiřovat jen na konec. Ubrané pole posune význam "
+                    "všech následujících.",
+                    help="Vrať pole zpět. Když má opravdu zmizet, je to nová verze formátu.",
+                )
+            )
+        elif observed.max_tokens > reference.max_tokens:
+            findings.append(
+                Finding(
+                    level=Level.INFO,
+                    code="FIELDS_APPENDED",
+                    title=f"{prefix} má nově až {observed.max_tokens - 1} polí, referenční "
+                    f"záznam měl {reference.max_tokens - 1}",
+                    shape=shape,
+                    why="Rozšíření na konec je povolené, ale konzumenti o novém poli nevědí.",
+                    help="Přidej pole do dokumentace formátu a do messages.yaml.",
+                )
+            )
+    elif observed.max_tokens != reference.max_tokens:
+        findings.append(
+            Finding(
+                level=Level.INFO,
+                code="TRAILING_LENGTH_CHANGED",
+                title=f"{prefix}: délka části s proměnným počtem polí se změnila "
+                f"({reference.max_tokens - fixed} → {observed.max_tokens - fixed})",
+                shape=shape,
+                why="Histogram na konci zprávy nemá pevnou délku, takže tuhle změnu nejde "
+                "odlišit od přidaného pole.",
+                help="Až se délka histogramu popíše v dokumentaci, začne se kontrolovat "
+                "(viz docs/DOC_DEVIATIONS.md, D6).",
+            )
+        )
+
+    return findings
+
+
+def _compare_types(prefix, reference, observed, shape, fixed: int | None) -> list[Finding]:
+    limit = min(len(reference.types), len(observed.types))
+    if fixed is not None:
+        limit = min(limit, fixed)
+    findings = []
+    for index in range(1, limit):
+        was, now_types = reference.types[index], observed.types[index]
+        if was & now_types:
+            continue
+        findings.append(
+            Finding(
+                level=Level.ERROR,
+                code="FIELD_TYPE_CHANGED",
+                title=f"{prefix}: pole {index} bylo {_names(was)}, nově je {_names(now_types)}",
+                shape=shape,
+                why="Změna typu na dané pozici znamená, že se pole přesunulo nebo změnilo "
+                "význam. Konzumenti čtou pozice, ne názvy.",
+                help="Nové údaje přidávej na konec zprávy, stávající pozice nech beze změny.",
+            )
+        )
+    return findings
+
+
+def _names(types: set[str]) -> str:
+    return " / ".join(sorted(TYPE_NAMES.get(name, name) for name in types))
+
+
+def unchecked_messages(
+    text: str, golden: str | None = None, schema: Schema | None = None
+) -> Finding | None:
+    """R8: a message the device never emits is not an error, but it must not be passed over
+    in silence either. One the reference did emit is already reported as a regression."""
+    schema = schema or load_schema()
+    seen = set(profile_log(text))
+    if golden is not None:
+        seen |= set(profile_log(golden))
+    missing = sorted(set(schema.messages) - seen)
+    if not missing:
+        return None
+    return Finding(
+        level=Level.INFO,
+        code="MESSAGES_NOT_EMITTED",
+        title=f"Zařízení nevypisuje: {', '.join(missing)}, kontroly těchto zpráv se přeskočily",
+        why="Zpráva, kterou hardware nemá čím naplnit, není chyba formátu.",
+        help="Jestli některá z nich chybí omylem, porovnej výstup s referenčním záznamem "
+        "(--golden).",
+    )

ust_format_checker/components/gnss.yaml

@@ -0,0 +1,12 @@
+name: gnss
+summary: přijímač GNSS - věty NMEA na UART a sekundový pulz 1PPS na pinu
+bus: uart
+pins: [pps]
+directive: pps {pps_port} {pps_pin} {pps_start} {pps_count}
+params:
+  pps_start: {type: float, default: 0.9}
+  # musí vydržet po celou dobu, kterou smí simulace běžet: až pulzy dojdou, hodiny zařízení
+  # se zastaví, zatímco millis běží dál, a vypadá to jako zamrzlý čas ve firmwaru
+  pps_count: {type: int, default: 45}
+stimulus: nmea
+emits: [$TIME]

ust_format_checker/components/i2c_eeprom.yaml

@@ -0,0 +1,8 @@
+name: i2c_eeprom
+summary: I2C paměť s adresou registru, ze které firmware čte sériová čísla a konfiguraci
+bus: i2c
+params:
+  reg_bytes: {type: int, default: 2}
+  offset: {type: hex, default: "0000"}
+  data: {type: hex, default: FFFFFFFFFFFFFFFF}
+directive: i2c_memory {addr_hex} {reg_bytes} {offset} {data}

ust_format_checker/components/sht31.yaml

@@ -0,0 +1,9 @@
+name: sht31
+summary: teploměr a vlhkoměr SHT31-DIS na I2C
+bus: i2c
+params:
+  temp_c: {type: float, default: 21.5, min: -45, max: 130, unit: °C}
+  humidity: {type: float, default: 40.0, min: 0, max: 100, unit: "%"}
+directive: sht31 {addr_hex} {temp_c} {humidity}
+provides: [temperature, humidity]
+emits: [$ENV]

ust_format_checker/components/spi_adc_pulse.yaml

@@ -0,0 +1,9 @@
+name: spi_adc_pulse
+summary: >
+  analogová část detektoru z pohledu MCU - pin CONV oznámí hotovou konverzi, hodnota přijde
+  dvěma bajty po SPI a firmware ji potvrdí pulzem na DRESET
+bus: spi
+pins: [conv, reset]
+directive: adc {conv_port} {conv_pin} {reset_port} {reset_pin}
+stimulus: pulses
+emits: [$E, $STOP]