Han am 2. Dezember 2014 um 11:27 Uhr

2014-12-02T11:27:08Z

Han am 2. Dezember 2014 um 11:19 Uhr

2014-12-02T11:19:41Z

Han am 2. Dezember 2014 um 10:51 Uhr

2014-12-02T10:51:07Z

Änderungen zeigen

Han am 2. Dezember 2014 um 09:51 Uhr

2014-12-02T09:51:47Z

Änderungen zeigen

Han am 1. Dezember 2014 um 19:25 Uhr

2014-12-01T19:25:04Z

Han: Die Seite wurde neu angelegt: „''Information: die folgenden Screenshots sind mit einer aktuellen Entwicklerversion der XERO erstellt worden. Es sind daher einige Bedienlemente eventue…“

2014-12-01T19:24:01Z

Die Seite wurde neu angelegt: „''<u>Information:</u> die folgenden Screenshots sind mit einer aktuellen Entwicklerversion der XERO erstellt worden. Es sind daher einige Bedienlemente eventue…“

Neue Seite

''<u>Information:</u> die folgenden Screenshots sind mit einer aktuellen Entwicklerversion der XERO erstellt worden.
Es sind daher einige Bedienlemente eventuell anders dargestellt - der Ablauf bzw. die Funktion sind jedoch unverändert!''

== Ein einfacher Temperatursensor ==

Ziel: Kennenlernen der grundsätzlichen Bedienung und Konzepte der XERO in einem "Step-by-Step" Beispiel!

=== Programstart ===

Nach dem Start (<tt>Xero.exe</tt>) wird der Arena-Auswahl Dialog angezeigt:

[[Datei:xero_example01_selectarena.png|800px|thumb|none|]]

Befindet sich (noch) keine Arena in .\Config\, wird der Ordner angelegt und die XERO im Design-Modus gestartet.�(zuvor sind mehrere Dialoge zu bestätigen)

Befindet sich genau eine Arena in .\Config\, so wird der Dialog nur kurz angezeigt und dann umgehend diese Arena geladen.

Sind mehrere Arenas vorhanden, so muss die zu ladende Arena mit einem Klick (bzw. Enter) ausgewählt werden. (Die zuletzt verwendete Arena ist vorselektiert)

Nach dem Laden der ausgewählten Arena befindet man sich am Startschirm [siehe Benutzeroberfläche]:

[[Datei:xero_example01_startscreen.png|800px|thumb|none|]]

Mittels der Taste {{button|Schema}} wird nun in den Design-Modus gewechselt, um Module hinzuzufügen bzw. zu bearbeiten.
Erkennbar ist dieser Modus am Karierten Hintergrund und den Ankern an den Modulen (siehe unten)

Um ein neues Modul hinzuzfügen, wird mit der Maus an der gewünschten Position ein Rahmen in der gewünschten Grösse aufgezogen.�(Die Position und Grösse kann später natürlich verändert werden)

[[Datei:xero_example01_addmodule.png|800px|thumb|none|]]

Nun wird der Modul-Auswahl-Dialog angezeigt:

[[Datei:xero_example01_selectmodule.png|800px|thumb|none|]]

Hier sind (nach Kategorien gruppiert) alle verfügbaren Module gelistet. Im Beispiel hier wählen wir aus der Gruppe "Schema" das Modul "ModuleSensor" aus.

Die allermeisten Module erfordern nun die Angabe einiger wichtiger Parameter - das Modul "ModuleSensor" zeigt z.B. Den folgenden Dialog an:

[[Datei:xero_example01_selectmodule_parameters.png|800px|thumb|none|]]

Um fortfahren zu können müssen eine oder mehrere Parameter ausgefüllt werden - erst dann wird der {{button|OK}} angezeigt.
Im Beipiel hier wird angegeben, dass das "ReadModule" (also das Modul welches den Rohwert liefert) "AK_1_3" heisst; der Maximalwert des Sensors "250" sein soll und der Sensor einen Wert mit der Einheit (Unit) "°C" anzeigen soll. Sein Name wird mit "T_1" festgelegt.

Nach Bestätigen mit {{button|OK}} wird das neue Modul zum Schema hinzugefügt. (über die Taste {{button|Cancel}} kann der Vorgang jederzeit abgebrochen werden und es wird kein neues Modul hinzugefügt)

Module können in ihrer Position und Grösse jederzeit verändert werden:
• Position: Click-and-Drag im "freien" Bereich auf dem Modul
• Grösse: Click-and-Drag auf dem "Size-Anchor" rechts unten

[[Datei:xero_example01_moduleanchors.png|800px|thumb|none|]]

Wir haben oben als Quelle für den Sensor T_1 das Modul AK_1_3 angegeben. Da es dieses Modul nicht gibt, zeigt T_1 auch keinen Wert an ('#' ist bei XERO das Symbol für kein oder undefinierter Wert)

Da angenommen wird, dass beim Abarbeiten dieses Tutorials kein physikalischer Sensor zur Verfügung steht um Messwerte einzulesen, werden wir einen Rohwert simulieren.
Eine einfache Möglichkeit hierzu ist die Verwendung eines Counters.
Dazu fügen wir ein Modul Counter ein (Timer --> Counter) und geben ihm den Namen "AK_1_3".

Um nun ein Modul detaillierter konfigurieren zu können muss man den Designmodus durch abermaliges Betätigen der Taste {{button|Schema}} wieder verlassen.

Klickt man nun bei einem Modul auf das Symbol im linken Bereich,

[[Datei:xero_example01_moduleclicksymbol.png|800px|thumb|none|]]

kann man das betreffende Modul im Detail konfigurieren - es öffnet sich folgender Dialog:

[[Datei:xero_example01_moduleconfiguration.png|800px|thumb|none|]]

Um den Zähler zu starten müssen wir ihm einen Startwert zuweisen: dazu klicken wir in das grüne Status-Fenster oben und geben in dem sich öffnenden Numerischen Eingabedialog den Wert "1" ein:

[[Datei:xero_example01_numberdialog.png|800px|thumb|none|]]

Nach der Bestätigung mit "Enter" bzw. "OK" beginnt der Zähler zu laufen. In ein-Sekunden-Intervallen von 0 bis 100.

Wir wollen für unser Beispiel einen Sensor simulieren, welcher Temperaturen in 1/10 Kelvin in einem Bereich von ca. 30-200°C liefert. Dazu müssen wir das Modul detaillierter konfigurieren.�Sehen wir und deshalb den Modul-Konfigurations-Dialog genauer an:

[[Datei:xero_example01_moduleconfiguration2.png|800px|thumb|none|]]

Der Dialog ist aufgeteilt in
• den Statusbereich (oben)
• den Hauptbereich (mitte)
• den Parameter-Bereich (unten; weitere Parameter können auch rechts angezeigt werden - siehe unten)
• den Steuerungs-Bereich (die Tasten ganz rechts)

Alle Parameter die allen Modulen gemeinsam sind sind über die Taste {{button|Setup}} erreichbar (Hauptparameter):

[[Datei:xero_example01_moduleconfiguration_setup.png|800px|thumb|none|]]

INFO: Die Bedeutung dieser Parameter ist in [...setup...] beschrieben!

Wir konfigurieren wir das Modul nun folgendermassen - jeweils mit Klick auf den betreffenden Parameter:
• .Min = 3000
• .Max = 5000
• .Timer = 0.2s

Und nach dem Schliessen des Haupparameter-Dialogs ändern wir noch den Parameter
• .Increment = 11.3
im Modul-Dialog im Parameter-Bereich unten.

Somit zählt unser Zähler nun von 3000 bis 5000. Und zwar alle 0.2 Sekunden um einen Wert von 11.3.
(Hintergrund: der Zähler simuliert also einen Temperatur-Sensor mit Werten zwischen von 28 bis 228°C in 1/10 Kelvin; das Ganze mit einer linearen Rampe von 11.3/10 Kelvin pro 0.2 Sekunden)

Danach schließen wir den Modul-Konfigurationsdialog.

Nun sollte unser ModuleSensor "T_1" statt dem "#" einen Wert anzeigen.
(ACHTUNG: es kann mehrere Sekunden dauern bis der Wert das erste Mal angezeigt wird)

Wir müssen nun unser Temperatur-Modul "T_1" so konfigurieren, dass der Wert des (simulierten) Sensors vernünftig (richtig) dargestellt wird - dazu klicken wir wieder in den Symbol-Bereich des Moduls:

[[Datei:xero_example01_moduleclicksymbol2.png|800px|thumb|none|]]

- es öffnet sich folgender Dialog:

[[Datei:xero_example01_moduleconfiguration_t1.png|800px|thumb|none|]]

Oben in der Statuszeile wird statt dem Gesamt-System-Status nun der Status dieses einen Moduls angezeigt.
In diesem Beispiel ist am Modul selbst (wie auch im Modul-Konfigurations-Dialog oben) ist zusätzlich das Symbol "(OL)" (kleiner Kreis mit violettem Hintergrund) dargestellt. "OR" bedeutet z.B. "Over-Range", d.h. der aktuelle Modulwert (1813) ist höher als der als ".Max" definierte (250)...

Im Hauptbereich des Modul-Dialogs befindet sich ein [Chart].
Jedes Modul speichert seine Messwerte für eine in ".History" definierte Zeit. Der Messwert-Verlauf wird in diesem Chart dargestellt.
Unterhalb bzw. rechts davon sind einige "Interne" (Sub-)Module dieses Moduls dargestellt (in diesem Fall: ".Command", ".Set", ".Raw" und ".ReadModule"). Bei manchen (komplexeren) Modulen sind hier mehr Sub-Module vorhanden. Diese können sich auch im Hauptbereich befinden.
In der XERO ist alles aus Modulen modelliert. Ein Modul ist gleichzeitig auch die kleinste Einheit. Das einfachste Modul ist das Modul "Sensor" (in der Gruppe "Register").
Komplexere Module bestehen aus vielen Modulen die jeweils selbst wieder aus Modulen bestehen.
Oder anders Ausgedrückt: eine Menge/Gruppe von "Sensor" Modulen bildet ein neues Modul. Dieses komplexere Modul kann wieder Verwendet werden um wiederum komplexere Module zu bilden.
Und: eine Gruppe von - mehr oder weniger komplexen - Modulen bildet eine Arena (=Schema)

=== Der Aufbau des Minimal-Moduls "Sensor" ===

Fügt man zu einem Schema das Modul "Sensor" hinzu (Register-->Sensor), verlässt anschliessend den Designmodus und klickt links auf das Symbol des eingefügten Sensors, so öffnet sich der Konfigurations-Dialog des "Sensors":

[[Datei:xero_example01_moduleconfiguration_s1.png|800px|thumb|none|]]

Man sieht, dass der Sensor folgende Parameter (=Sub-Module) enthält:
• .Raw --> der Rohwert
• .Set --> der Ziel- oder Target-Wert, wird verwendet�Führungsgrösse bei Regler (Sollwert)
Alarmgrenzen
Bei Visualisierungen (Gauges, etc.)
• .Chart --> ein Spezial-Modul zur Anzeige der Messwert-Historie

Zusäzlich dazu enthält noch jedes Minimal-Modul ("Sensor") die folgenden Parameter die ersichtlich sind, wenn man auf {{button|Setup}} klickt:

[[Datei:xero_example01_moduleconfiguration_s1_setup.png|800px|thumb|none|]]

Die Bedeutung dieser Parameter ist in [...setup...] beschrieben!

...zurück zum ModuleSensor "T_1":
Dieses besitzt (wie weiter oben ersichtlich) zusätzlich zu den Minimal-Parametern des Moduls "Sensor" die beiden Parameter:
• .Command --> wird für allgemeine Funktionssteuerung benutzt. Ist für dieses Beispiel nicht relevant!
• .ReadValue --> das Modul, von dem der ".Raw" Wert dieses Moduls bezogen/gelesen wird.

Bei den meisten Modulen empfiehlt sich die Konfiguration von zumindest den folgenden Modul-Parametern:
• .Unit�die angezeigte Einheit�Wird auch zum automatischen Umrechnen verwendent. z.B. von [ppm] in [%] oder von [°C] in [K]�°C
• .Adjust�unter der Annahme, dass unser Module von welchem der Roh-Wert bezogen wird (AK_1_3) die Temperatur in 1/10° und in Kelvin liefert, müssen wir den Rohwert umrechnen, also: �°C = .Raw / 10 - 273.15�dazu:�.Adjust.Gain = 0.1�.Adjust.Offset = -273.15
• .Format�wir wollen den Wert mit einer Kommastelle anzeigen - also:�.Format = #.0
• .Type (Appearance-Type)�Der Sensor soll mit einem Temperatur-Symbol statt dem Standard-Symbol dargestellt werden:�.Type = TI
• Alert: Falls der Wert 200°C um mehr als 20 sec überrschreitet, soll ein Alarm ausgelöst werden:
.Alert-Max = 200�.Inhibit = 20s
• .Label�.Label = Temp Pumpe

Nachdem alle diese Parameter gesetzt wurden, schaut unser Modul-Dialog wie folgt aus:

[[Datei:xero_example01_moduleconfiguration_t1_setup.png|800px|thumb|none|]]

…und das Modul auf dem Haupt-Schema so:

[[Datei:xero_example01_module_t1.png|800px|thumb|none|]]

Somit zeigt unser ModuleSensor "T_1" nun den (simulierten) Sensorwert "AK_1_3" korrekt in °C an.

@@ Zeile 210: / Zeile 210: @@
 Bei den meisten Modulen empfiehlt sich die Konfiguration von zumindest den folgenden Modul-Parametern:
 *.Unit&rarr;die angezeigte Einheit
 :Wird auch zum automatischen Umrechnen verwendent. z.B. von [ppm] in [%] oder von [°C] in [K]

← Nächstältere Version		Version vom 2. Dezember 2014, 11:19 Uhr
Zeile 199:		Zeile 199:

	''INFO: Ob ein modulspezificher Parameter hier im {{button\|Setup}} in der Gruppe "Module Setup" oder im {{button\|Schema}} des Sensors dargestellt wird, ist konfigurierbar (aber nicht Teil dieses Beispiels).''		''INFO: Ob ein modulspezificher Parameter hier im {{button\|Setup}} in der Gruppe "Module Setup" oder im {{button\|Schema}} des Sensors dargestellt wird, ist konfigurierbar (aber nicht Teil dieses Beispiels).''
		+
		+	''INFO: Da wir Sensor "S_1" für unser Beispiel nicht benötigen, können wir ihn jetzt durch einen Klick auf den "Close-Anchor" (Kreuz rechts oben) im Schema-Designmodus wieder entfernen.''