Codesys Rechnen Mit Zeiten

CODESYS Zeitrechner

Berechnen Sie präzise mit Zeiten in CODESYS – für Steuerungsprogrammierung und Automatisierung

Ergebnis in Millisekunden:
0
Ergebnis in Sekunden:
0
Ergebnis in Minuten:
0
Ergebnis in Stunden:
0
CODESYS TIME-Wert:
T#0MS
CODESYS LTIME-Wert:
LT#0MS

Umfassender Leitfaden: Rechnen mit Zeiten in CODESYS

CODESYS (Controller Development System) ist eine der führenden Entwicklungsumgebungen für die IEC 61131-3 Programmierung von Steuerungen in der industriellen Automatisierung. Ein zentraler Aspekt der SPS-Programmierung ist das präzise Rechnen mit Zeiten – sei es für Zeitsteuerungen, Ablaufketten oder die Verarbeitung von Prozessdaten.

1. Grundlagen der Zeitdarstellung in CODESYS

CODESYS bietet verschiedene Datentypen für die Zeitdarstellung, die jeweils spezifische Eigenschaften und Anwendungsbereiche haben:

  • TIME: Der Standard-Datentyp für Zeitdauern mit einer Auflösung von 1 Millisekunde und einem Bereich von -24,9 Tagen bis +24,9 Tagen.
  • LTIME: Erweitert den TIME-Datentyp auf 64 Bit mit einem Bereich von ±10.675 Tage.
  • TIME_OF_DAY (TOD): Repräsentiert eine Tageszeit (Stunden:Minuten:Sekunden:Millisekunden) ohne Datumsinformation.
  • DATE: Speichert nur das Datum ohne Zeitinformation.
  • DATE_AND_TIME (DT): Kombiniert Datum und Uhrzeit für vollständige Zeitstempel.

Die Wahl des richtigen Datentyps hängt von der benötigten Genauigkeit und dem Wertebereich ab. Für die meisten Steuerungsanwendungen reicht der TIME-Datentyp aus, während LTIME für langlaufende Prozesse oder historische Datenanalyse verwendet wird.

2. Zeitoperationen in CODESYS

CODESYS bietet umfassende Funktionen für Zeitberechnungen, die direkt in der IEC 61131-3 Programmierung genutzt werden können:

Operation Funktion Beispiel Rückgabewert
Addition ADD result := time1 + time2; TIME
Subtraktion SUB diff := time1 – time2; TIME
Multiplikation MUL scaled := time * factor; TIME
Division DIV ratio := time / factor; TIME oder REAL
Vergleich GT, LT, EQ IF time1 > time2 THEN… BOOL

Wichtig zu beachten ist, dass bei der Multiplikation und Division von TIME-Werten mit Faktoren der Rückgabewert wieder ein TIME-Wert ist. Für präzise Berechnungen sollte man die internen Millisekunden-Werte verwenden:

PROGRAM TimeCalculations
VAR
    time1, time2, result : TIME;
    factor : REAL;
    msValue : LINT;
END_VAR

// Umrechnung in Millisekunden für präzise Berechnungen
msValue := TIME_TO_LINT(time1);  // Konvertiert TIME in Millisekunden (LINT)
result := LINT_TO_TIME(msValue * 2);  // Verdoppelt die Zeit

3. Praktische Anwendungsbeispiele

In der industriellen Automatisierung gibt es zahlreiche Szenarien, in denen präzises Rechnen mit Zeiten entscheidend ist:

  1. Zeitgesteuerte Ablaufketten: Für sequentielle Prozessschritte mit definierten Wartezeiten zwischen den Schritten.
  2. Durchsatzberechnungen: Berechnung von Stückzahlen pro Zeiteinheit in Produktionslinien.
  3. Wartungsintervalle: Überwachung von Betriebsstunden für vorbeugende Instandhaltung.
  4. Ereignisprotokollierung: Zeitstempel für Prozessereignisse mit Millisekunden-Genauigkeit.
  5. Regelungsalgorithmen: Zeitbasierte PID-Regler oder Rampenfunktionen.

Ein typisches Beispiel ist die Implementierung einer Zeitverzögerung mit dem TON (Timer On-Delay) Baustein:

PROGRAM DelayExample
VAR
    StartDelay : BOOL;
    DelayActive : BOOL;
    Timer : TON;
    DelayTime : TIME := T#5S;  // 5 Sekunden Verzögerung
END_VAR

Timer(IN := StartDelay, PT := DelayTime);
DelayActive := Timer.Q;

4. Umrechnung zwischen Zeitformaten

Für die Interoperabilität mit anderen Systemen oder zur Anzeige in HMIs ist oft eine Umrechnung zwischen verschiedenen Zeitformaten notwendig. CODESYS bietet hierfür spezielle Funktionen:

Funktion Beschreibung Beispiel
TIME_TO_LINT Konvertiert TIME in Millisekunden (LINT) ms := TIME_TO_LINT(myTime);
LINT_TO_TIME Konvertiert Millisekunden in TIME myTime := LINT_TO_TIME(5000); // 5 Sekunden
TIME_TO_TOD Konvertiert TIME in TIME_OF_DAY tod := TIME_TO_TOD(myTime);
TOD_TO_TIME Konvertiert TIME_OF_DAY in TIME myTime := TOD_TO_TIME(myTOD);
TIME_TO_STRING Formatiert TIME als String str := TIME_TO_STRING(myTime);

Für komplexere Umrechnungen, wie die Konvertierung in Kalenderdaten, können die Funktionen DATE_AND_TIME_TO_DATE und DATE_AND_TIME_TO_TOD verwendet werden.

5. Leistungsoptimierung bei Zeitberechnungen

In Echtzeit-Systemen ist die Performance von Zeitberechnungen kritisch. Folgende Praktiken helfen, die Effizienz zu steigern:

  • Vermeiden Sie häufige Umrechnungen zwischen Datentypen im Hauptzyklus
  • Nutzen Sie vorberechnete Zeitkonstanten statt wiederholter Berechnungen
  • Für hochpräzise Zeitmessungen verwenden Sie die SYSTEM.RTC Funktionen
  • Bei langlaufenden Timern bevorzugen Sie LTIME statt TIME
  • Nutzen Sie die TIME# Literale für konstante Zeiten (z.B. TIME#100MS)

Ein Beispiel für optimierte Zeitberechnung:

PROGRAM OptimizedTimeCalc
VAR CONSTANT
    CYCLE_TIME : TIME := T#10MS;  // Zykluszeit als Konstante
    MAX_DELAY : TIME := T#1H;    // Maximale Verzögerung
END_VAR
VAR
    CurrentTime, LastTime : LTIME;
    Elapsed : TIME;
    Counter : UINT;
END_VAR

// Effiziente Zeitmessung mit LTIME
CurrentTime := SYSTEM.RTC.TOD_TO_LTIME(SYSTEM.RTC);
Elapsed := LINT_TO_TIME(TIME_TO_LINT(CurrentTime) - TIME_TO_LINT(LastTime));
LastTime := CurrentTime;

// Verwendung von Zeitkonstanten
IF Elapsed >= CYCLE_TIME THEN
    Counter := Counter + 1;
END_IF

6. Häufige Fehler und Lösungen

Bei der Arbeit mit Zeiten in CODESYS treten einige typische Fehler auf, die zu unerwartetem Verhalten führen können:

  1. Überlauf von TIME-Werten: Bei Berechnungen, die den Bereich von ±24,9 Tagen überschreiten, kommt es zu Überläufen. Lösung: LTIME verwenden.
  2. Genauigkeitsverlust bei Division: Zeitdivision mit REAL-Faktoren kann Rundungsfehler verursachen. Lösung: Mit Millisekunden (LINT) arbeiten.
  3. Falsche Zeitbasis: Verwechslung von absoluten Zeiten (DATE_AND_TIME) mit Relativzeiten (TIME). Lösung: Klare Trennung der Datentypen.
  4. Timer-Reset Probleme: Nicht zurückgesetzte Timer können zu falschen Zeitmessungen führen. Lösung: Immer TON.R oder TOF.R verwenden.
  5. Zeitzonen-Ignoranz: TIME_OF_DAY berücksichtigt keine Zeitzonen. Lösung: Bei globalen Anwendungen UTC verwenden.

Ein besonders tückischer Fehler ist die implizite Typumwandlung:

// Falsch: Implizite Umwandlung kann zu Genauigkeitsverlust führen
realFactor := 1.5;
scaledTime := myTime * realFactor;  // Potenzieller Genauigkeitsverlust

// Richtig: Explizite Umwandlung über Millisekunden
msValue := TIME_TO_LINT(myTime) * 1.5;
scaledTime := LINT_TO_TIME(msValue);

7. Fortgeschrittene Techniken

Für komplexe Anwendungen bietet CODESYS erweiterte Möglichkeiten im Umgang mit Zeiten:

  • Zeitstempel-Protokollierung: Nutzung von DATE_AND_TIME für lückenlose Prozessdokumentation
  • Zeitsynchronisation: Abgleich mit NTP-Servern über SYSTEM.RTC.SYNC
  • Zeitbasierte Arrays: Speicherung von Prozessdaten mit Zeitstempeln in ARRAY OF STRUCT
  • Echtzeit-Analyse: Nutzung von SYSTEM.RTC.HIGHRES_TIMER für Mikrosekunden-Genauigkeit
  • Zeitzonen-Umrechnung: Implementierung von Zeitzonen-Offsets für globale Anwendungen

Ein Beispiel für die Implementierung eines Zeitstempel-Logs:

TYPE ProcessEvent :
STRUCT
    Timestamp : DATE_AND_TIME;
    EventType : (START, STOP, ERROR, WARNING);
    Value : REAL;
    Description : STRING(80);
END_STRUCT
END_TYPE

PROGRAM EventLogger
VAR
    EventLog : ARRAY[0..99] OF ProcessEvent;
    LogIndex : UINT;
    CurrentEvent : ProcessEvent;
END_VAR

// Neue Ereignis protokollieren
CurrentEvent.Timestamp := SYSTEM.RTC;
CurrentEvent.EventType := ProcessEvent#START;
CurrentEvent.Value := 23.45;
CurrentEvent.Description := 'Prozess gestartet';

// Zum Log hinzufügen (mit Ringpuffer)
EventLog[LogIndex] := CurrentEvent;
LogIndex := (LogIndex + 1) MOD 100;

8. Integration mit externen Systemen

Bei der Kommunikation mit anderen Systemen (z.B. MES, ERP) ist oft eine Konvertierung der CODESYS-Zeitformate notwendig. Typische Szenarien:

  • OPC UA: Zeitstempel werden als DateTime übertragen (UTC-basiert)
  • Datenbanken: TIMESTAMP-Felder erfordern oft spezielle Formatierung
  • Webservices: ISO 8601 Format (YYYY-MM-DDTHH:MM:SS.ZZZ)
  • Excel-Export: Umrechnung in serielle Datumswerte

Für die Konvertierung in ISO 8601 Format kann folgende Funktion verwendet werden:

FUNCTION ISO8601_From_DT : STRING
VAR_INPUT
    dt : DATE_AND_TIME;
END_VAR
VAR
    year, month, day, hour, minute, second : USINT;
    ms : UINT;
    isoString : STRING(24);
END_VAR

// Extrahiere Komponenten
year := DATE_AND_TIME_TO_DATE(dt).YEAR;
month := DATE_AND_TIME_TO_DATE(dt).MONTH;
day := DATE_AND_TIME_TO_DATE(dt).DAY;
hour := DATE_AND_TIME_TO_TOD(dt).HOUR;
minute := DATE_AND_TIME_TO_TOD(dt).MIN;
second := DATE_AND_TIME_TO_TOD(dt).SEC;
ms := DATE_AND_TIME_TO_TOD(dt).MS;

// Formatiere als ISO 8601
isoString := CONCAT('',
    INT_TO_STRING(year), '-',
    INT_TO_STRING(month, 2), '-',
    INT_TO_STRING(day, 2), 'T',
    INT_TO_STRING(hour, 2), ':',
    INT_TO_STRING(minute, 2), ':',
    INT_TO_STRING(second, 2), '.',
    INT_TO_STRING(ms, 3));

ISO8601_From_DT := isoString;

9. Best Practices für die CODESYS-Zeitprogrammierung

Für robuste und wartbare Zeitberechnungen in CODESYS-Projekten sollten folgende Best Practices beachtet werden:

  1. Definieren Sie Zeitkonstanten zentral in einer globalen Bibliothek
  2. Dokumentieren Sie immer die verwendete Zeiteinheit (ms, s, min)
  3. Verwenden Sie für kritische Zeitmessungen Hardware-Timer statt Software-Timer
  4. Testen Sie Zeitberechnungen mit Grenzwerte (0, Maximalwerte, negative Zeiten)
  5. Berücksichtigen Sie bei langlaufenden Prozessen die Sommer/Winterzeit-Umstellung
  6. Nutzen Sie für komplexe Zeitlogik Funktionbausteine statt direkter Berechnungen
  7. Implementieren Sie Überlaufprüfungen bei Zeitoperationen
  8. Verwenden Sie für Benutzeroberflächen immer lokale Zeitzonen

10. Zukunftstrends in der industriellen Zeitverarbeitung

Die Anforderungen an Zeitberechnungen in der Automatisierungstechnik entwickeln sich ständig weiter:

  • Nanosekunden-Genauigkeit: Für Hochgeschwindigkeitsprozesse in der Halbleiterfertigung
  • Zeitsynchronisation über 5G: Präziser Abgleich verteilter Steuerungen
  • KI-basierte Zeitanalyse: Mustererkennung in Prozesszeiten für Predictive Maintenance
  • Blockchain-Zeitstempel: Unveränderliche Protokollierung von Prozessdaten
  • Edge-Computing Zeitverarbeitung: Dezentrale Zeitberechnungen mit lokaler Intelligenz

CODESYS reagiert auf diese Trends mit erweiterten Bibliotheken für Hochpräzisionszeitmessung und besserer Integration mit Cloud-Diensten für Zeitdatenanalyse.

Zusammenfassung und Fazit

Das Rechnen mit Zeiten in CODESYS ist ein fundamentales Element der SPS-Programmierung, das von einfachen Timer-Anwendungen bis zu komplexen zeitgesteuerten Automatisierungslösungen reicht. Durch das Verständnis der verschiedenen Datentypen, der verfügbaren Funktionen und der Best Practices können Entwickler robuste und präzise Zeitberechnungen implementieren.

Die richtige Wahl des Datentyps (TIME, LTIME, DATE_AND_TIME), die Beachtung von Genauigkeitsanforderungen und die Berücksichtigung von Performance-Aspekten sind entscheidend für erfolgreiche Anwendungen. Mit den in diesem Leitfaden vorgestellten Techniken und Beispielen sind Sie gut gerüstet, um auch komplexe Zeitberechnungen in Ihren CODESYS-Projekten umzusetzen.

Für vertiefende Informationen zu den IEC 61131-3 Zeitfunktionen empfiehlt sich die offizielle PLCopen-Spezifikation. Weitere Details zur Implementierung von Echtzeit-Systemen finden Sie in den IEEE-Standards für industrielle Steuerungssysteme.

Leave a Reply

Your email address will not be published. Required fields are marked *