Sensorbox

Die MIGAL.CO Sensorbox ist eine modulare, mikrocontrollerbasierte Mess- und Kommunikationsplattform zur hochauflösenden Erfassung, Verarbeitung und Weiterleitung von Schweißprozessdaten für Lichtbogenschweißprozesse. Sie wurde für den rauen industriellen Schweißalltag entwickelt und bildet die technische Basis für Prozessüberwachung, datenbasierte Qualitätsanalyse und perspektivisch KI-gestützte Fehlererkennung.

Mit der Sensorbox erhält der Anwender Schweißdaten direkt aus dem Prozess – sauber zeitlich zugeordnet, strukturiert paketiert und sicher ins Netzwerk übertragen. So kann man:

• Schweißprozesse transparent machen (statt „Bauchgefühl“)

• Parameter pro Schweißnaht / Job / Arbeitsplatz nachvollziehen

• Daten in InfluxDB, Dashboards oder Cloud-Systeme einspeisen

• Echtzeit-Visualisierung (Oszilloskop/Spektrum) oder Edge-Analysen umsetzen

• die Grundlage für automatisierte Anomalie- und Fehlererkennung schaffen

• Einfach und schnell Schweißanweisungen (WPS) aus realen, gemessenen Schweißdaten erstellen

Systemarchitektur: Echtzeit-Messung trifft Netzwerk & Analyse

Im Inneren arbeitet ein STM32H7 Dual-Core (Cortex-M7 + Cortex-M4) mit klarer Aufgabenverteilung:

• Cortex-M4: übernimmt die zeitkritische Messung (hochfrequent, deterministisch)

• Cortex-M7: kümmert sich um Datenaufbereitung, Analyse, Protokolle, Netzwerkkommunikation und Systemsteuerung

Beide Kerne tauschen Daten über OpenAMP / RPMsg aus – mit geringer Latenz, klarer Sequenzierung und robuster Struktur.

Messgrößen: die wichtigsten Prozessparameter synchron erfasst

Aktuell erfasst die Sensorbox:

• Schweißstrom

• Schweißspannung

• Gasdurchfluss

• Drahtgeschwindigkeit

Strom & Spannung werden mit hoher zeitlicher Auflösung über die ADCs des STM32H7 erfasst, im DMA-Circular-Modus. 5 kHz Abtastrate sind realisiert.

Gasdurchfluss und Drahtgeschwindigkeit sind vollständig integriert und werden synchron zu den elektrischen Größen aufgenommen – damit stimmen Zeitbezug und Zuordnung über alle Parameter hinweg.

Jeder Messframe enthält zusätzlich zu den Rohdaten wichtige Metadaten wie:

• Zeitstempel

• Sequenznummer

• Statusflags

• Kalibrierparameter (Gain/Offset)

Damit können Rohdaten auch auf nachgelagerten Systemen exakt in physikalische Größen umgerechnet werden – reproduzierbar und nachvollziehbar.

Datenverarbeitung: Kennzahlen direkt auf dem Gerät

Auf dem Cortex-M7 werden die Daten bereits vorverarbeitet und analysiert. Aktuell verfügbar sind u. a.:

• RMS- und Mittelwertberechnung

• Wirkleistung aus Strom und Spannung

• Skalierung & Erfassung von Gasdurchfluss und Drahtgeschwindigkeit

Die Daten werden anschließend strukturiert paketiert und mit eindeutigen Kennungen versehen, sodass sie klar einem Job, einer Schweißnaht oder einem Arbeitsplatz zugeordnet werden können.

Kommunikation & Vernetzung: sicher in die IT – schnell in die Echtzeit

Die Sensorbox ist vollständig netzwerkfähig über Ethernet (LwIP TCP/IP-Stack) und bietet zwei zentrale Datenwege:

MQTT über TLS (mbedTLS) – für IT, Cloud & Datenbanken

Prozessdaten (Strom, Spannung, Gas, Draht) werden zyklisch übertragen (typisch 0,1 bis 5 Sekunden) – ideal für:

• Cloud-/Server-Anbindungen

• Prozessmonitoring & Reporting

• Speicherung in Zeitreihensystemen (z. B. InfluxDB)

• sichere Integration in bestehende IT-Infrastruktur

UDP-Echtzeitstream – für hochfrequente Live-Daten

Für hochfrequente und latenzkritische Anwendungen gibt es zusätzlich einen UDP-Datenstream. Darüber können rohe Messframes (Strom/Spannung) nahezu verzögerungsfrei an externe Systeme geschickt werden.

Die UDP-Pakete enthalten strukturierte Header (u. a. Magic Number, Sequenznummern, Zeitstempel, Payload-Beschreibung) – damit bleiben Synchronisation, Validierung und Nachverfolgung auch bei Paketverlust robust.

Typische Einsatzfälle:

• Live-Visualisierung (Oszilloskop- oder Spektraldarstellung)

• schnelle Regel-/Assistenzsysteme

• Edge- oder PC-basierte Online-Analyse

Zusätzlich ist ein integrierter Webserver (Mongoose) an Bord – für Diagnose, Konfiguration und künftige Visualisierungen.

OPC UA Server – standardisierte Schnittstelle für Industrie-Integration

Für die einfache Anbindung an SCADA/MES/IIoT-Plattformen bietet die Sensorbox einen OPC UA Server (opc.tcp). Dadurch können Schweißdaten herstellerneutral und ohne proprietäre Gateways von OPC UA Clients wie z. B. UaExpert oder Node-RED ausgelesen werden.

Bereitgestellte Messwerte (Read-only):

• Strom (RMS) [A]

• Spannung (RMS) [V]

• Leistung [W]

• Gasfluss [l/min]

• Drahtgeschwindigkeit [m/min]

Die Werte werden zyklisch aktualisiert und stehen im Namespace ns=1 zur Verfügung – ideal für Live-Monitoring, Datenlogging oder die Weiterverarbeitung in übergeordneten Systemen.

Zeitbasis & Synchronisation: Daten mit absolutem Zeitbezug

Zur präzisen zeitlichen Einordnung unterstützt die Sensorbox SNTP/NTP-Zeitsynchronisation. Alle Messwerte werden mit absoluten Zeitstempeln versehen – wichtig für:

• Korrelation mehrerer Sensorboxen

• saubere Zeitreihenanalyse

• spätere Auswertung in InfluxDB & Co.

Persistenz & Konfiguration: robust gespeichert, auch bei Spannungseinbruch

Geräte-, Netzwerk- und Sicherheitsparameter (z. B. IP-Konfiguration, MQTT-Zugangsdaten, UDP-Zieladresse, TLS-Zertifikate) werden persistent im internen Flash gespeichert.

Eine robuste Speicherstrategie mit:

• Magic Number

• Prüfsummen

• klar definierten Flash-Sektoren

stellt sicher, dass Konfigurationen auch bei unerwartetem Spannungsverlust erhalten bleiben.

Kurz gesagt

Die MIGAL.CO Sensorbox ist die Brücke zwischen Schweißprozess und Datenwelt:

präzise Messung, synchronisierte Prozessdaten, Vorverarbeitung auf dem Gerät und sichere bzw. echtzeitfähige Übertragung – bereit für Monitoring, Analyse und die nächste Stufe der Qualitätssicherung.

Messverfahren für Strom, Spannung und Leistung

Die MIGAL.CO Sensorbox berechnet aus hochfrequenten Rohdaten mit 5 kHz Abtastfrequenz präzise Prozesskennwerte für Spannung, Strom und Leistung. Dazu werden Spannung u(t) und Strom i(t) in kurzen Zeitfenstern erfasst und digital ausgewertet:

• RMS-Spannung (U_RMS) und RMS-Strom (I_RMS) sind die sogenannten Effektivwerte. Sie beschreiben die elektrische „wirksame“ Größe auch dann zuverlässig, wenn das Signal nicht sinusförmig ist – wie es beim Schweißen typisch ist.

• Leistung (P) wird als Mittelwert der Momentanleistung berechnet: Für jedes Sample wird u * i gebildet und anschließend über das Zeitfenster gemittelt. So entsteht ein stabiler Leistungswert, der reale Prozessänderungen (z. B. Kurzschlussphasen, Lichtbogeninstabilität, Draht-/Gas-Einflüsse) sauber abbildet.

Diese Kennwerte bilden die Grundlage für Live-Überwachung, Trendanalysen, Qualitätsauswertung und spätere KI-gestützte Fehlererkennung.

MQTT-Message

Die Sensorbox sendet ihre Mess- und Statusdaten in einem kompakten JSON(JavaScript Object Notation)-Format. Jede Nachricht entspricht einem zeitlich eindeutig zuordenbaren Snapshot des Schweißprozesses und enthält sowohl Prozesskennwerte als auch Systemzustände und Firmware-Versionen.

Zeit & Sequenz

→ Dient zur Synchronisation mit anderen Systemen (InfluxDB, Dashboard, RoboScope, MES).

→ Erlaubt das Erkennen von Aussetzern, Paketverlust oder Lücken in der Aufzeichnung.

Elektrische Kenngrößen

→ Diese Größen ermöglichen Last-/Energieanalyse, Prozessstabilitätsbewertung und Vergleich von Jobs/Parametern.

Draht & Gas

→ Basis für Prozessüberwachung (z. B. zu geringer Vorschub, Drahtstau, Fehlererkennung).

→ Wird bereits in der Sensorbox korrigiert, sodass der Anwender direkt einen praxisrelevanten Wert erhält.

→ Transparenz, wie stark Rohwerte aufgrund Kalibrierung/Umgebungseinfluss angepasst wurden.

Statusobjekt (Gesundheit & Diagnose)

Unter status werden wichtige Diagnoseflags als Booleans mitgeliefert:

→ Dadurch ist Remote-Diagnose möglich, ohne dass der Anwender direkt an die Hardware muss.

Firmware-Versionen (Traceability)

Beispiel:

{
  "ts": "2026-01-21T10:15:23.123Z",
  "seq": 4711,
  "u_rms": 23.45,
  "i_rms": 156.78,
  "p_rms": 3680.2,
  "wire_m_min": 8.50,
  "gas_l_min": 12.30,
  "gas_cf": 1.07,
  "status": {
    "openamp_ok": true,
    "adc_overrun": false,
    "encoder_timeout": false,
    "ntp_synced": true
  },
  "fw": {
    "m7": "1.0.3",
    "m4": "1.0.3"
  }
}

UDP High-Speed Stream (Rohdatenpaket)

Für hochauflösende Analyse (Oszilloskop-Ansicht, Histogramme, Ereigniserkennung) sendet die Sensorbox zusätzlich zur JSON-Telemetrie einen binären/CSV-ähnlichen UDP-Datenstrom. Jedes UDP-Paket enthält einen Header mit Metadaten und danach einen Block von ADC-Rohsamples für Spannung und Strom.

1) Paket-Header (Metadaten)

→ Damit kann der Empfänger Daten sicher als „Sensorbox-Frame“ erkennen und Fehl- oder Fremdpakete verwerfen.

Zeitstempel in Millisekunden.

→ Ermöglicht zeitkorrekte Darstellung (z. B. Live-Trace), Logging und Synchronisation mit anderen Quellen.

Fortlaufende Sequenznummer.

→ Paketverluste oder Reihenfolgefehler (UDP!) werden sofort sichtbar.

Anzahl der Samples pro Kanal in diesem Paket.

→ Ein Paket ist ein „Datenblock“ (Frame) mit genau definiertem Umfang.

Aktueller Gasdurchfluss (l/min) als Meta-Info zum Sampleblock.

→ Praktisch, um Oszi-Daten direkt mit Prozessparametern zu verknüpfen.

Drahtvorschub (m/min) zum selben Zeitpunkt.

→ Kann 0 sein, wenn Draht steht oder ein Encoder-/Signalproblem vorliegt.

Bitmaske für Systemzustände/Fehlerflags (z. B. ADC Overrun, Encoder Timeout, OpenAMP OK, NTP Sync).

→ Diagnose ohne extra Abfrage – jedes Paket trägt seinen Gesundheitszustand mit.

Kalibrier-/Umrechnungsparameter

→ Damit kann der Empfänger Rohdaten zu physikalischen Größen umrechnen (oder bewusst Rohdaten speichern und später mit denselben Parametern rekonstruieren).

2) Sample-Daten (Payload)

Nach dem Header folgt eine Tabelle/Sequenz:

→ Der Empfänger kann daraus:

• Oszilloskop-Traces (u(t), i(t)) erzeugen

• RMS/Leistung/Arc-Stabilität berechnen

• Peaks, Kurzschlüsse, Spritzerereignisse erkennen

• Histogramme / Verteilungen erstellen (z. B. Stromverteilung pro Job)

Warum UDP?

UDP ist ideal für Live-Streaming großer Datenmengen:

• sehr geringe Latenz

• geringer Protokoll-Overhead

• „best effort“ (Paketverlust möglich) → deshalb: seq im Header

Für robuste Speicherung/Backfill nutzt man meist parallel die „langsamen“ Telemetriekanäle (z. B. JSON via MQTT/HTTP), während UDP für die Echtzeit-Ansicht dient (RoboScope).

Beispiel eines Python-Codes zur Ausgabe des UDP-Streams im Terminal (Aufruf z.B. mit python3 udp_dump.py 9000:

#!/usr/bin/env python3
import argparse
import socket
import struct
import math
MAGIC_OSCI = 0x3143534F  # "OSCI"
FLAG_STATUS = 0x0001
FLAG_CAL    = 0x0002
BASE_HDR_FMT = "<IHHII"              # magic, header_len, flags, seq, sample_cnt
BASE_HDR_LEN = struct.calcsize(BASE_HDR_FMT)  # 16
def parse_packet(buf: bytes):
    if len(buf) < BASE_HDR_LEN:
        return None
    magic, header_len, flags, seq, sample_cnt = struct.unpack_from(BASE_HDR_FMT, buf, 0)
    if magic != MAGIC_OSCI:
        return None
    # Minimaler Header: base + ts + meta
    if header_len < (BASE_HDR_LEN + 8 + 8) or header_len > len(buf):
        return None
    off = BASE_HDR_LEN
    ts_ms, = struct.unpack_from("<Q", buf, off)
    off += 8
    gas_l_min, wire_m_min = struct.unpack_from("<ff", buf, off)
    off += 8
    status = None
    if flags & FLAG_STATUS:
        if off + 4 > header_len:
            return None
        status, = struct.unpack_from("<I", buf, off)
        off += 4
    # Default Cal (falls nicht mitgesendet)
    u_gain = 1.0
    u_offset = 0.0
    i_gain = 1.0
    i_offset = 0.0
    if flags & FLAG_CAL:
        if off + 16 > header_len:
            return None
        u_gain, u_offset, i_gain, i_offset = struct.unpack_from("<ffff", buf, off)
        off += 16
    # Payload beginnt bei header_len
    payload_off = header_len
    payload_bytes = len(buf) - payload_off
    available_samples = min(sample_cnt, payload_bytes // 4)
    return {
        "ts_ms": ts_ms,
        "seq": seq,
        "sample_cnt": sample_cnt,
        "available_samples": available_samples,
        "gas_l_min": gas_l_min,
        "wire_m_min": wire_m_min,
        "flags": flags,
        "status": status,
        "u_gain": u_gain,
        "u_offset": u_offset,
        "i_gain": i_gain,
        "i_offset": i_offset,
        "payload_off": payload_off,
    }
def main():
    ap = argparse.ArgumentParser(description="Simple UDP dump for MIGAL.CO Sensorbox OSCI stream")
    ap.add_argument("port", type=int, help="UDP port to listen on, e.g. 9000")
    ap.add_argument("--bind", default="0.0.0.0", help="Bind address (default: 0.0.0.0)")
    ap.add_argument("--n", type=int, default=16, help="How many samples to print (default: 16)")
    ap.add_argument("--rms", action="store_true", help="Compute simple U_rms/I_rms/P_mean from printed samples")
    args = ap.parse_args()
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.bind((args.bind, args.port))
    print(f"Listening on {args.bind}:{args.port} ... (Ctrl+C to stop)")
    while True:
        buf, addr = sock.recvfrom(65535)
        info = parse_packet(buf)
        if info is None:
            # Unbekanntes Paket – leise ignorieren oder kurz melden:
            continue
        ts_ms = info["ts_ms"]
        seq = info["seq"]
        sc = info["sample_cnt"]
        av = info["available_samples"]
        gas = info["gas_l_min"]
        wire = info["wire_m_min"]
        flags = info["flags"]
        status = info["status"]
        u_gain = info["u_gain"]
        u_offset = info["u_offset"]
        i_gain = info["i_gain"]
        i_offset = info["i_offset"]
        print("\n" + "-" * 80)
        print(f"from {addr[0]}:{addr[1]}  ts_ms={ts_ms}  seq={seq}  samples={sc}  (in packet: {av})")
        print(f"gas_l_min={gas:.3f}  wire_m_min={wire:.3f}  flags=0x{flags:04x}", end="")
        if status is not None:
            print(f"  status=0x{status:08x}")
        else:
            print()
        if (flags & FLAG_CAL) != 0:
            print(f"cal: u_gain={u_gain} u_offset={u_offset} i_gain={i_gain} i_offset={i_offset}")
        # Samples ausgeben
        nprint = min(args.n, av)
        off = info["payload_off"]
        u_vals = []
        i_vals = []
        for i in range(nprint):
            w, = struct.unpack_from("<I", buf, off)
            u_raw = w & 0xFFFF
            i_raw = (w >> 16) & 0xFFFF
            off += 4
            # physikalisch (falls Gain/Offset gesetzt)
            u = u_raw * u_gain + u_offset
            cur = i_raw * i_gain + i_offset
            u_vals.append(u)
            i_vals.append(cur)
            print(f"{i:4d}: u_raw={u_raw:5d} i_raw={i_raw:5d}   u={u:.3f}  i={cur:.3f}")
        if args.rms and nprint > 0:
            u2 = sum(x*x for x in u_vals) / nprint
            i2 = sum(x*x for x in i_vals) / nprint
            p  = sum(u_vals[j] * i_vals[j] for j in range(nprint)) / nprint
            print(f"-> U_rms={math.sqrt(u2):.3f}  I_rms={math.sqrt(i2):.3f}  P_mean={p:.3f}  (über {nprint} Samples)")
if __name__ == "__main__":
    main()
  

OPC UA Variable Nodes

Der Server exponiert 5 Read-Only Variablen im Namespace ns=1:

Variable	NodeID	Typ	Einheit	Beschreibung
Strom	ns=1;i=6001	Double	A	Effektivwert (RMS)
Spannung	ns=1;i=6002	Double	V	Effektivwert (RMS)
Leistung	ns=1;i=6003	Double	W	Momentanleistung
Gasfluss	ns=1;i=6004	Double	l/min	Korrigierter Volumenstrom
Drahtgeschwindigkeit	ns=1;i=6005	Double	m/min	Encoder-basiert

Lieferumfang

• Sensorbox mit Mikrocontroller und Anschlüssen für Ethernet, Spannungsversorgung (9–12 V DC) und Encoder, 12 V-Steckernetzteil sowie PoE-Adapter, 3-poliger Kabelstecker für die Spannungsmessung mit 5 m verdrillter Messleitung.
• Drahtsensor (Encoder) mit 1,5 m Kabel und 5-poligem Kabelstecker.
• Gassensor mit 2 m Kabel und 7-poligem Kabelstecker.