Erstelle deine erste App

Diese Anleitung führt durch den typischen Workflow zum Erstellen einer IronFlock-App, die Daten von Edge-Geräten sammelt und auf Echtzeit-Dashboards anzeigt. Am Ende hast du ein Datenmodell, Edge-Logik, ein Konfigurationsformular für Benutzer und Live-Diagramme — alles verbunden über die Projektdatenbank.

1. Datenmodell entwerfen

Beginne in der Datei .ironflock/data-template.yml. Denke an zwei Kategorien von Tabellen:

• Entity-Tabellen — verfolgen den aktuellen Zustand von Dingen (Geräte, Maschinen, Verbindungen). Zeilen werden bei jeder Änderung angehängt; maintainLatestFlagFor deklariert, welche Spalten eine Entität identifizieren, sodass die neueste Zeile pro Entität bei Bedarf gelesen werden kann.
• Zeitreihentabellen — sammeln Messwerte über die Zeit (Sensorwerte, Metriken). Jede Zeile ist ein neuer Datenpunkt mit Zeitstempel.

data:
  tables:
    # Entity-Tabelle: eine Zeile pro Gerät, aktueller Zustand immer abfragbar
    - tablename: devices
      maintainLatestFlagFor: ['device_key']
      columns:
        - id: tsp
          dataType: timestamp
        - id: device_key
          dataType: string
        - id: status
          dataType: string
        - id: device_name
          dataType: string
        - id: deleted
          dataType: boolean
 
    # Entity-Tabelle: benutzerkonfigurierte Modbus-Server
    - tablename: modbus_servers
      maintainLatestFlagFor: ['server_id']
      columns:
        - id: tsp
          dataType: timestamp
        - id: server_id
          dataType: string
        - id: host
          dataType: string
        - id: port
          dataType: numeric
        - id: deleted
          dataType: boolean
 
    # Zeitreihentabelle: periodische Messwerte von verbundener Hardware
    - tablename: readings
      columns:
        - id: tsp
          dataType: timestamp
        - id: server_id
          dataType: string
        - id: metric
          dataType: string
        - id: value
          dataType: numeric

2. Testumgebung einrichten

Um deine App zu testen, brauchst du eine Entwicklungsumgebung in einem Projekt mit mindestens einem Online-Gerät:

1. Klicke auf Develop auf der App-Detailseite, um die Cloud IDE zu öffnen.

2. Wähle ein Online-Gerät aus einem beliebigen Projekt, auf das du Zugriff hast.

3. Klicke auf Create Backend im Seitenpanel, um eine Entwicklungsumgebung in der Projektdatenbank zu erstellen.

Dadurch werden die in deiner data-template.yml definierten Tabellen in der Projektdatenbank angelegt. Du kannst sie in der Fleet-Database-Ansicht des Projekts einsehen.

Die Cloud IDE bietet dir eine vollständige VS Code Umgebung mit Datei-Explorer, Editor, Terminal und dem Edge Development Panel zum Erstellen und Bereitstellen auf deinem Gerät.

3. Edge-Code schreiben

Dein Docker-Container läuft auf dem Gerät und nutzt das IronFlock SDK, um mit der Projektdatenbank zu interagieren.

Gerät beim Start registrieren

Wenn die Edge-Komponente startet, füge eine Zeile in die devices-Entity-Tabelle ein, damit das Dashboard weiß, dass das Gerät online ist:

import asyncio
from ironflock import IronFlock
 
async def main():
    # Dieses Gerät als online registrieren
    await flock.append_to_table("devices", {
        "device_key": os.environ.get('DEVICE_KEY'),
        "tsp": now,
        "status": "online",
        "device_name": os.environ.get('DEVICE_NAME'),
        "deleted": False
    })
 
    # ... restliche Logik
 
flock = IronFlock(mainFunc=main)
flock.run()

import { IronFlock } from "ironflock";
 
const flock = new IronFlock();
await flock.start();
 
// Dieses Gerät als online registrieren
await flock.appendToTable("devices", [{
    device_key: process.env.DEVICE_KEY,
    tsp: new Date().toISOString(),
    status: "online",
    device_name: process.env.DEVICE_NAME,
    deleted: false
}]);

Da devices maintainLatestFlagFor: ['device_key'] verwendet, wird die vorherige Statuszeile für dieses Gerät automatisch abgelöst. Widgets mit aktiviertem latest-Filter zeigen immer den aktuellen Zustand an.

Auf Benutzerkonfiguration reagieren

Benutzer können Modbus-Server über ein Formular auf dem Board hinzufügen (siehe Schritt 4). Dein Edge-Code abonniert die modbus_servers-Tabelle und reagiert auf neue Einträge:

async def main():
    # ... Geräteregistrierung ...
 
    # Bestehende Modbus-Server lesen
    existing = await flock.getHistory("modbus_servers", {
        "limit": 1000,
        "filterAnd": [
            # "latest": True gibt nur die neueste Zeile pro server_id zurück
            {"latest": True},
            {"column": "deleted", "operator": "IS", "value": None}
        ]
    })
    for server in existing:
        create_modbus_connection(server)
 
    # In Echtzeit auf neue Server reagieren
    def on_server_change(*args, **kwargs):
        server = args[0] if args else kwargs
        if server.get("deleted"):
            delete_modbus_connection(server["server_id"])
        else:
            create_modbus_connection(server)
 
    await flock.subscribe_to_table("modbus_servers", on_server_change)

// Bestehende Modbus-Server lesen
const existing = await flock.getHistory("modbus_servers", {
    limit: 1000,
    filterAnd: [
        // latest: true gibt nur die neueste Zeile pro server_id zurück
        { latest: true },
        { column: "deleted", operator: "IS", value: null }
    ]
});
existing.forEach(server => createModbusConnection(server));
 
// In Echtzeit auf neue Server reagieren
await flock.subscribeToTable("modbus_servers", (...args) => {
    const server = args[0];
    if (server.deleted) {
        deleteModbusConnection(server.server_id);
    } else {
        createModbusConnection(server);
    }
});

Zeitreihendaten sammeln

Sobald eine Modbus-Verbindung hergestellt ist, frage regelmäßig Messwerte ab und schreibe sie in die readings-Tabelle:

async def modbus_poll_loop(server_id, client):
    while True:
        values = client.read_registers()
        for metric, value in values.items():
            await flock.publish_to_table("readings", {
                "server_id": server_id,
                "metric": metric,
                "value": value
            })
        await asyncio.sleep(5)

async function modbusPollingLoop(serverId, client) {
    setInterval(async () => {
        const values = client.readRegisters();
        for (const [metric, value] of Object.entries(values)) {
            await flock.publishToTable("readings", [{
                server_id: serverId,
                metric,
                value
            }]);
        }
    }, 5000);
}

4. Board erstellen

Öffne den Board Editor und füge Widgets hinzu, die mit deinen Data-Backend-Tabellen verbunden sind.

Gerätestatus anzeigen

Füge ein Table-Widget hinzu, das mit der devices-Tabelle verbunden ist. Aktiviere den latest-Schalter in den Filtereinstellungen des Widgets, damit immer der aktuelle Zustand jedes Geräts angezeigt wird. Die Tabelle aktualisiert sich automatisch, wenn ein Gerät online oder offline geht.

Benutzer Modbus-Server konfigurieren lassen

Füge ein Form-Widget hinzu, das mit der modbus_servers-Tabelle verbunden ist. Konfiguriere Felder für host und port. Wenn ein Benutzer das Formular ausfüllt und absendet, wird automatisch eine neue Zeile in die modbus_servers-Tabelle eingefügt — kein Backend-Code nötig, um die Formularübermittlung zu verarbeiten.

Dein Edge-Code nimmt die neue Zeile über subscribeToTable auf (siehe Schritt 3) und stellt die Modbus-Verbindung her.

Zeitreihendaten visualisieren

Füge ein Line Chart-Widget hinzu, das mit der readings-Tabelle verbunden ist. Ordne tsp der X-Achse und value der Y-Achse zu. Das Diagramm aktualisiert sich in Echtzeit, wenn neue Messwerte von den Geräten eintreffen — kein Polling oder manuelles Aktualisieren nötig.

So fügt sich alles zusammen

┌─────────────────────────────────────────────────────────┐
│  Board (Dashboard)                                      │
│  ┌──────────┐  ┌──────────────┐  ┌───────────────────┐  │
│  │ Table    │  │ Form            │  │ Line Chart        │  │
│  │ devices  │  │ modbus_servers  │  │ readings          │  │
│  └────┬─────┘  └──────┬───────┘  └────────┬──────────┘  │
│       │               │                   │              │
└───────┼───────────────┼───────────────────┼──────────────┘
        │               │                   │
   ┌────▼───────────────▼───────────────────▼────┐
   │           Projektdatenbank                   │
   │  devices  │  modbus_servers  │  readings     │
   └────▲───────────────▲───────────────────▲────┘
        │               │                   │
   ┌────┴───────────────┴───────────────────┴────┐
   │           Edge-Code (auf dem Gerät)           │
   │  Gerät registrieren → Konfig lesen → Daten   │
   └──────────────────────────────────────────────┘

Die Projektdatenbank ist die einzige Quelle der Wahrheit. Der Edge-Code schreibt hinein, das Board liest in Echtzeit daraus, und Benutzeraktionen über Formulare schreiben zurück. Dein Edge-Code kann diese Änderungen abonnieren, um den Kreislauf zu schließen — keine eigenen API-Endpunkte erforderlich.

Tipps

• Beginne mit Entity-Tabellen. Bringe zuerst die Geräteregistrierung und eine Statustabelle zum Laufen, bevor du Zeitreihenerfassung hinzufügst.
• Verwende maintainLatestFlagFor bei jeder Tabelle, in der du den aktuellen Zustand abfragen musst. So kannst du Verlaufsdaten anhängen und die neueste Zeile pro Entität ohne zusätzlichen Code zurücklesen — mit dem latest-Schalter an einem Widget oder mit {"latest": true} in einem SDK-Filter.
• Füge eine deleted-Spalte zu Entity-Tabellen hinzu, die Benutzer über Formulare verwalten, damit Einträge weich gelöscht werden können und der Verlauf erhalten bleibt.
• Verwende appendToTable für Schreibvorgänge, die Bestätigung brauchen (z.B. initiale Geräteregistrierung). Verwende publishToTable für Hochfrequenz-Telemetrie, bei der Fire-and-Forget akzeptabel ist.
• Halte Zeitreihentabellen einfach. Ein Zeitstempel, eine Kennung für die Quelle und die Messwerte. Verwende Transform-Tabellen für Aggregationen.

Nächste Schritte

Wenn deine Hardware eine webbasierte HMI oder Konfigurationsoberfläche bietet, kannst du sie direkt in dein IronFlock-Board einbetten — mit dem Embed-Widget und Geräte-Tunneln. Siehe Externe HMIs einbetten für Details.