handbuch canape casl - vector...4.2.3 task-manager 53 4.2.4 aufruf von skripten 55 4.2.5...

Handbuch

CANape CASL Calculation and Scripting Language

Version 1.2 Deutsch

Impressum Vector Informatik GmbH Ingersheimer Straße 24

D-70499 Stuttgart Vector behält sich vor, die in diesen Dokumenten enthaltenen Angaben und Daten jederzeit ohne vorherige Ankündigung zu ändern. Ohne ausdrückliche schriftliche Zustimmung von Vector dürfen diese Dokumente, auch nicht teilweise, vervielfältigt oder übertragen werden, unabhängig davon, auf welche Weise oder mit welchen Mitteln dies geschieht. Alle technischen Angaben, Texte, Bilder und Grafiken einschließlich deren Anordnung unterliegen soweit gesetzlich zulässig den geltenden gesetzlichen Vorschriften zum Schutz des geistigen Eigentums, insb. dem Schutz des Urheberrechts. Jede nicht genehmigte Verwendung kann eine Verletzung dieser Vorschriften darstellen.

Copyright 2015, Vector Informatik GmbH. Printed in Germany. Alle Rechte vorbehalten.

Handbuch CANape CASL Inhaltsverzeichnis

© Vector Informatik GmbH Version 1.2 - I -

Inhaltsverzeichnis

1 Einführung 3

1.1 Ziel 4

1.2 Vector Produktbezug 4

1.3 Skriptsprache in CANape CASL 4

1.4 Vorkenntnisse 4

1.5 Allgemeines Vorgehen 5

1.6 Zu diesem Handbuch 5 1.6.1 Zertifizierung 6 1.6.2 Gewährleistung 6 1.6.3 Support 6 1.6.4 Marken 6

2 Grundlegendes 7

2.1 Anwendungsfälle für Funktionen und Skripte 8

2.2 Was sind Funktionen 8

2.3 Was sind Skripte 10

2.4 Unterschiede zwischen Funktionen und Skripte 11

2.5 Funktionseditor 12

2.6 Weitere Definitionen 14 2.6.1 Variablentypen 14 2.6.2 Argumente und Übergabeparameter (von Funktionen) 16 2.6.3 Kommentare 17 2.6.4 Beachtung der Groß- und Kleinschreibung 17 2.6.5 Vordefinierte Funktionsgruppen und Codebausteine von CANape 17

2.7 Allgemeine Systemgrenzen 19

3 Syntax 20

3.1 Unterschiede zwischen C-Programmierung und CASL 21

3.2 Zahlen und Zeichen 21 3.2.1 Datentypen und Wertebereiche 21 3.2.2 Parametertypen für vordefinierte Funktionen 22 3.2.3 Konstanten 22 3.2.4 Arrays 23 3.2.5 Strings 24 3.2.6 Platzhalter 24

3.3 Operatoren 26

3.4 Kontrollstrukturen (Anweisungen) 27

4 Funktionen, Skripte und Variablen in CANape 30

4.1 Funktionen 31 4.1.1 Funktionen schreiben 31 4.1.2 Funktionen speichern und weitergeben (exportieren/importieren) 32 4.1.3 Funktionen in Betrieb nehmen bzw. instanziieren 34 4.1.4 Beispielfunktionen 44 4.1.5 Globale Funktionsbibliothek 46 4.1.6 Externe Funktionsbibliotheken einbinden 47

Handbuch CANape CASL Inhaltsverzeichnis

© Vector Informatik GmbH Version 1.2 - II -

4.1.7 Debuggen von Funktionen 48

4.2 Skripte 51 4.2.1 Skripte schreiben 51 4.2.2 Skripte speichern und weitergeben (exportieren/importieren) 53 4.2.3 Task-Manager 53 4.2.4 Aufruf von Skripten 55 4.2.5 Skriptverhalten bei Ausführung von CANape 60 4.2.6 Debuggen von Skripten 60 4.2.7 Beispielskripte 61

4.3 Variablen 63 4.3.1 Erstellen einer globalen Variablen 63 4.3.2 Globale Variable auf definierten Wert setzen 63 4.3.3 Lokale Variable auf definierten Wert setzen 65 4.3.4 Gerätevariable einfügen 68

5 Allgemeine Tipps 69

5.1 Richtiges Beenden von Funktionen und Skripte 70

5.2 Zugriff auf Systeminformationen 70

6 Adressen 72

7 Glossar 73

8 Index 74

Handbuch CANape CASL Einführung

© Vector Informatik GmbH Version 1.2 - 3 -

1 Einführung

In diesem Kapitel finden Sie die folgenden Informationen:

1.1 Ziel Seite 4

1.2 Vector Produktbezug Seite 4

1.3 Skriptsprache in CANape CASL Seite 4

1.4 Vorkenntnisse Seite 4

1.5 Allgemeines Vorgehen Seite 5

1.6 Zu diesem Handbuch Seite 5

Zertifizierung

Gewährleistung

Support

Marken



1.1 Ziel

Grundlegendes Dieses Handbuch beginnt mit einer Einführung in die CANape Skriptsprache, wo alle damit zusammenhängenden Begrifflichkeiten ausführlich erklärt und abgegrenzt werden.

Syntax Das darauf folgende Kapitel beschäftigt sich mit der Syntax der CANape Skriptsprache. Dieses Kapitel dient außerdem als Nachschlagewerk.

Einbinden von Funktionen und Skripten

In einem weiteren Kapitel wird beschrieben, wie Sie Funktionen und Skripte in CANape einbinden und prüfen können.

Allgemeine Tipps Des Weiteren werden Hinweise zu allgemeinen Fragestellungen gegeben.

1.2 Vector Produktbezug

CANape Abhängig vom jeweiligen Vector Produkt (CANape oder vSignalyzer) sowie dem Typ (Funktion oder Skript) ist der Umfang der zur Verfügung stehenden Funktionen unterschiedlich. Das vorliegende Handbuch bezieht sich ausschließlich auf CANape. Ob die jeweiligen Funktionen auch in vSignalyzer zur Verfügung stehen, entnehmen Sie bitte ggf. der Hilfe.

1.3 Skriptsprache in CANape CASL

Eigene Skriptsprache CANape verwendet eine eigene Skriptsprache, im Folgenden CASL (Calculation and Scripting Language) genannt.

Syntax Die Syntax von CASL ist der C-Programmiersprache sehr ähnlich. Sie erlaubt dem Entwickler außerdem, eigenen C-Code oder Simulink-Modelle zu integrieren.

Hinweis: Verwechseln Sie CASL nicht mit der Programmiersprache CAPL, die im Umfeld von CANoe und CANalyzer verwendet wird.

CAPL arbeitet ereignisorientiert. Mit sogenannten CAPL-Programmknoten wird festgelegt, wann ein Ereignis ausgeführt und wie reagiert wird. CASL hingegen arbeitet signalorientiert.

1.4 Vorkenntnisse

Programmier-kenntnisse

Dieses Handbuch setzt voraus, dass Sie allgemeine Programmierkenntnisse in der C-Programmiersprache besitzen.



1.5 Allgemeines Vorgehen

Programmierprozess Es gibt fünf Schritte, die bei der Entwicklung eines Programms notwendig sind:

1. Überlegen Sie, welches die primäre Aufgabe des Programms sein soll.

2. Entscheiden Sie, wie und wann das Programm ausgeführt werden soll.

3. Entwickeln Sie einen geeigneten Code.

4. Kompilieren Sie das Programm.

5. Testen Sie das Programm in CANape.

1.6 Zu diesem Handbuch

Informationen schnell finden

Diese Zugriffshilfen bietet Ihnen das Handbuch:

> Zu Beginn eines Kapitels finden Sie eine Zusammenfassung der Inhalte.

> An der Kopfzeile erkennen Sie, in welchem Kapitel des Handbuchs Sie sich gerade befinden,

> An der Fußzeile erkennen Sie die Version des Handbuchs.

> Am Ende des Handbuchs finden Sie ein Glossar, in dem Sie verwendete Fachbegriffe nachschlagen können.

> Mit dem Stichwortverzeichnis ebenfalls am Ende des Handbuchs finden Sie die gewünschte Information schnell und zielgenau.

Konventionen In den beiden folgenden Tabellen finden Sie die durchgängig im ganzen Handbuch verwendeten Konventionen für Schreibweisen und Symbole.

Stil Verwendung

fett Felder, Oberflächenelemente, Fenster- und Dialognamen der Software, besondere Hervorhebungen.

[OK] Schaltflächen in eckigen Klammern

File|Save Notation für Menüs und Menüeinträge

CANape Rechtlich geschützte Eigennamen und Marginalientext.

Quellcode Datei- und Verzeichnisnamen, Quellcode, Klassen- und Objektnamen, Objektattribute und Werte.

Hyperlink Hyperlinks und Verweise.

<STRG>+<S> Notation für Tastaturkürzel.

Symbol Verwendung

Dieses Symbol gibt Ihnen Hinweise und Tipps, die Ihnen die Arbeit erleichtern.

Dieses Symbol warnt Sie vor Gefahren, die zu Sachschäden führen können.

Dieses Symbol weist Sie auf weiterführende Informationen hin.



Symbol Verwendung

Dieses Symbol weist Sie auf Beispiele hin.

Dieses Symbol weist Sie auf Schritt-für-Schritt-Anleitungen hin.

1.6.1 Zertifizierung

Qualitäts-managementsystem

Die Vector Informatik GmbH ist gemäß ISO 9001:2008 zertifiziert. Der ISO-Standard ist ein weltweit anerkannter Qualitätsstandard.

1.6.2 Gewährleistung

Einschränkung der Gewährleistung

Wir behalten uns inhaltliche Änderungen der Dokumentation und der Software ohne Ankündigung vor. Vector übernimmt keine Gewährleistung und/oder Haftung für die Vollständigkeit oder Richtigkeit der Inhalte oder für Schäden, die sich aus dem Gebrauch der Dokumentation ergeben.

1.6.3 Support

Sie benötigen Hilfe? Sie können unsere Hotline telefonisch unter der Rufnummer

+49 (0)711 80670-200

oder per E-Mail unter [email protected] erreichen.

1.6.4 Marken

Geschützte Marken Alle in dieser Dokumentation genannten Produktbezeichnungen sind eingetragene oder nicht eingetragene Marken ihrer jeweiligen Inhaber.

Handbuch CANape CASL Grundlegendes


2 Grundlegendes


2.2 Was sind Funktionen Seite 8

2.3 Was sind Skripte Seite 10

2.4 Unterschiede zwischen Funktionen und Skripte Seite 11

2.5 Funktionseditor Seite 12

2.6 Weitere Definitionen Seite 14

Variablentypen

Argumente und Übergabeparameter (von Funktionen)

Kommentare

Beachtung der Groß- und Kleinschreibung

Vordefinierte Funktionsgruppen und Codebausteine von CANape

2.7 Allgemeine Systemgrenzen Seite 19



2.1 Anwendungsfälle für Funktionen und Skripte

Einführung Innerhalb von CANape steht ein Funktionseditor zur Verfügung, mit dem geräteübergreifende Funktionen und Skripte geschrieben werden können.

Die dafür verwendete Skriptsprache CASL ist ähnlich der Programmiersprache C. CANape bietet zur leichteren Anwendung eine IntelliSense-Eingabe, Codebausteine und verschiedene bereits eingebaute Funktionsgruppen an.

Allgemeine Anwendungsfälle

Mit Funktionen und Skripten können von einfachen Berechnungen, z.B. Signale addieren, bis hin zur Automatisierung von CANape vielfältige Aufgaben gelöst werden.

Funktionen werden synchron während einer Messung abgearbeitet. Funktionen werden hauptsächlich für verschiedene Berechnungen und Anwendungen auf eine vorhandene Messdatei oder auf eine laufende Messung verwendet.

Skripte laufen unabhängig von einer Messung und werden für reproduzierbare Automatisierung von Abläufen eingesetzt.

2.2 Was sind Funktionen

Einführung Funktionen sind Teile eines Programmcodes, der unter eigenem Namen zusammengefasst ist. Sie können in CANape geräteübergreifend definiert werden.

Syntax Der Code der Funktion folgt den Regeln der CASL-Sprache (Calculation and Scripting Language).

Aufgaben Eine Funktion kann z. B. eine mathematische Formel oder ein Programmcode sein, in der Variablen als Platzhalter für Signale oder Parameter stehen.

Sie erleichtern die Analyse von Messsignalen, ermöglichen das Einstellen von Verstellobjekten und anderweitiges Eingreifen auf Geräteniveau.

Online-Anwendungen

Funktionen werden bei der Online-Anwendung während einer Messung durch ein Ereignis getriggert ausgeführt. Dies geschieht gemäß dem in der Messkonfiguration eingestellten Messmodus.

So können

> virtuellen Messsignale berechnet und

> Schreibzugriffe auf Gerätespeicher oder externe Messhardware ermöglicht werden.

Offline-Anwendungen

Bei der Offline-Anwendung greifen Funktionen auf vorhandene Messdateien zu.

So können

> virtuelle Messdateikanäle berechnet und

> Data Mining-Analysen durchgeführt werden.

Funktionsaufbau Nachfolgend der syntaktische Aufbau einer Funktion:

Schlüssel- wort

Name Argumente, Übergabeparameter

Funktionskopf function My_function(input, output)

Funktionsrumpf {

double a = 1;

long b = 2;



output = a + b*input;

writef("The result is: %d", output);

return output;

}

Parameterübergabe Beim Aufruf einer Funktion können der Funktion Parameter übergeben werden. Die Parameter werden der Funktion grundsätzlich als Referenz übergeben und können somit sowohl für den input als auch für den output verwendet werden.

Näheres zur Übergabe von Parametern siehe Abschnitt Argumente und Übergabeparameter (von Funktionen) auf Seite 16.

Kontrollstruktur return

Um aus Funktionen Ergebnisse herausgeben zu können, gibt es neben der Möglichkeit der Parameterübergabe auch den Weg über die Kontrollstruktur (auch

Schlüsselwort) return. Standardmäßig wird ein Wert vom Typ double

zurückgegeben. Der optionale Rückgabewert beinhaltet also stets einen Skalar.

Es kann sinnvoll sein, einen anderen Typen zurückzugeben. Hierzu muss der Rückgabetyp im Funktionskopf deklariert werden. Felder oder Vektoren (Arrays) sind als Rückgabewert verboten. Einen Überblick über alle zur Verfügung stehenden Kontrollstrukturen finden Sie im Abschnitt Kontrollstrukturen auf Seite 27.

Beispiel: Funktionskopf für alternativen Rückgabewert byte

function byte TestFunction (signal)

{

return 1;

}

Verwendung Die return-Rückgabewerte von Funktionen können in CANape vielseitig

weiterverwendet werden. So lassen sich diese z. B. in einem Grafik-Fenster als virtueller Messdateikanal darstellen. Es empfiehlt sich daher einen einzelnen skalaren

Rückgabewert über return und nicht über die Parameterliste zurückzugeben.

Soll eine Funktion keinen Wert zurückgeben, so kann dies über folgende drei Wege geschehen:

> return

> cancel

> Weder return noch cancel stehen im Funktionscode.

Hinweis: Messgrößen, die schreibgeschützt sind (z. B. mit rotem Zeiger in der

Messliste versehen sind) können nicht als output-Parameter einer Funktion verwendet werden.

Funktionsaufruf Funktionen können in die Messsignalliste eingefügt oder als Funktionsdefinition für virtuellen Messdateikanal (z. B. für Data Mining) verwendet werden. Sie können auch direkt von einer anderen benutzerdefinierten Funktion bzw. einem benutzerdefiniertem Skript aufgerufen werden. Für Details siehe Abschnitt Funktionen in Betrieb nehmen bzw. instanziieren auf Seite 34.



Prozesspriorität Funktionen - wie auch die Messung selbst - laufen unter CANape mit sehr hoher Priorität ab. Der Code sollte daher möglichst effizient gehalten werden, da die Funktion sonst die gesamte Messung beeinflussen kann (Messwerte können z. B. verloren gehen). Endlosschleifen legen die gesamte Messung lahm und können nur mittels dreisekündigem Betätigen der <ESC> Taste unterbrochen werden.

Einschränkungen Da CANape Prozesse während der Messung für Funktionen angehalten werden, sind einige CASL-Funktionen nicht verfügbar. Sie würden zu einem Laufzeitfehler führen. Solche CASL-Funktionen werden daher beim Schreiben von benutzerdefinierten Funktionen gar nicht erst angeboten, z. B. gilt dies für die eingebaute Skript-Funktion Sleep().

Speicherort Funktionen werden projektbezogen in die Konfigurationsdatei canape.ini in Ihrem

Arbeitsverzeichnis gespeichert.

Funktionstypen In CANape wird zwischen benutzerdefinierten Funktionen und bereits von CANape vordefinierten CASL-Funktionen unterschieden.

Benutzerdefinierte Funktionen

Zu den benutzerdefinierten Funktionen gehören zum einen die vom Benutzer selbst geschriebenen Projekt-Funktionen als auch die veränderbaren Bibliothek-Funktionen. Beide werden im Symbol Explorer von CANape angezeigt.

Globale Funktionsbibliothek

Die Bibliothek-Funktionen erhalten Sie, wenn Sie während des Setup-Prozesses die globale Funktionsbibliothek mit anlegen lassen (Default-Einstellung). Näheres siehe Abschnitt Globale Funktionsbibliothek auf Seite 46.

Projekt-Funktion Die vom Benutzer selbst geschriebenen oder geänderten Funktionen sehen Sie in der Baumansicht des Funktionseditors unter Projekt-Funktionen.

Funktionsgruppen Die bereits von CANape vordefinierten CASL-Funktionen verschiedener Funktionsgruppen wie z. B. Diagnose- oder Flash-Funktionen können hingegen nicht vom Benutzer verändert werden. Sie führen lediglich bestimmte Befehle aus, die Sie wiederum innerhalb Ihrer benutzerdefinierten Funktionen und Skripte nutzen können. Näheres dazu siehe Abschnitt Vordefinierte Funktionsgruppen und Codebausteine von CANape auf Seite 17.

Messfunktion Unter einer Messfunktion versteht man die Kombination aus Funktion und Messparameter (siehe Abschnitt Funktion während einer Messung verwenden auf Seite 36). Messfunktionen werden in CANape unter Messsignal|Funktionen in der Baumansicht der Messkonfiguration angezeigt.

2.3 Was sind Skripte

Einführung Skripte sind Teile des Programmcodes und können in CANape geräteübergreifend definiert werden.

Syntax Der Code eines Skripts folgt den Regeln der CASL-Sprache (Calculation and Scripting Language).

Er kann direkt im Editorfenster des Funktionseditors geschrieben werden und wird bei Aufruf sequentiell abgearbeitet.

Aufgaben Skripte werden verwendet, um gemeinsame Aktivitäten in CANape, wie das Starten und Stoppen von Messungen und andere systembezogene Abläufe zu automatisieren bzw. zu steuern.

Skripte laufen unabhängig von der Messung.



Sie können auch verwendet werden, um externe Modelle aufzurufen, die in Microsoft Visual Studio oder MATLAB/Simulink generiert wurden.

Skriptaufruf Skripte können auf verschiedene Art und Weise aufgerufen werden. Zum Aufruf aus der CANape Oberfläche heraus, siehe Abschnitt Aufruf von Skripten auf Seite 55.

Zum anderen kann das Skriptverhalten bereits bei der Ausführung von CANape über Kommandozeilen-Optionen gesteuert werden (siehe Abschnitt Skriptverhalten bei Ausführung von CANape auf Seite 60).

Prozesspriorität Skripte

Skripte unterliegen einer eher geringen Prozesspriorität. Sie werden lediglich alle 100 ms garantiert ausgeführt.

Debuggen Zum Diagnostizieren und Auffinden von logischen Fehlern in benutzerdefinierten Skripten steht das Debuggen von Skripten mittels sogenannter "Breakpoints" zur Verfügung. Nähere Details siehe Abschnitt Debuggen von Skripten auf Seite 60.

Dateiformat und Speicherort

Skripte sind separate Dateien im Skriptformat *.scr oder *.cns, die jederzeit in ein

anderes Projektverzeichnis kopiert werden können. Defaultmäßig werden Skripte in Ihrem Arbeitsverzeichnis gespeichert.

Beispielskripte Beispielskripte liefert CANape in den verschiedenen Demos mit. Diese werden nach Öffnen der jeweiligen Demo im Funktionseditor in der Baumansicht unter Skripte angezeigt. Hier werden dann auch die benutzerdefinierten Skripte gelistet.

2.4 Unterschiede zwischen Funktionen und Skripte

Prozesspriorität Skripte laufen wegen der eher geringen Prozesspriorität asynchron zur Messung. Funktionen hingegen werden mit hoher Prozesspriorität synchron zur Messung ausgeführt.

Dadurch ergeben sich für Funktionen Einschränkungen, wie z. B. die Skript-Funktion

Sleep(). Skripte verfügen im Vergleich zu Funktionen daher über eine

umfangreichere Auswahl an vordefinierten Funktionsgruppen, wie zusätzliche Datei- und Skriptfunktionen, Flash-Funktionen, Diagnose- und Data Mining-Funktionen.

Rückgabewerte Das RETURN-Schlüsselwort kann einen Wert vom Datentyp DOUBLE (ein Skalar, kein Datenfeld/Array usw.) an die aufrufende Routine zurückliefern.

Hinweis: Rückgabewerte von Skripten können derzeit nicht ausgewertet werden.

Debugging Funktionen lassen sich wegen Ihrer hohen Priorität im Gegensatz zu Skripten nicht mittels Breakpoints debuggen. Sie können stattdessen die Ausgabe von Debug-

Informationen im Write Fenster mittels Write(), Writef(), Print() oder

Printf() nutzen (siehe Abschnitt Debuggen von Funktionen auf Seite 48).

Subfunktionen Als Subfunktionen werden in CANape Unterfunktionen von Skripten bezeichnet. Subfunktionen sind daher in Funktionen nicht vorhanden.

Die Definition der Subfunktion muss vor dem Hauptteil des Skripts erfolgen. Optional können Argumente für die Subfunktion angegeben werden.



Wird bei der Messung eine Funktion2 aus einer anderen Funktion1 heraus

aufgerufen, so wird die Funktion2 im allgemeinen Sprachgebrauch ebenfalls als

Subfunktion bezeichnet.

In CANape wird in diesem Zusammenhang jedoch nicht von Subfunktionen gesprochen.

Programmcode Skripte benötigen keinen Funktionskopf und -rumpf. Der Programmcode kann einfach direkt in den Editor geschrieben werden und wird dann sequentiell abgearbeitet.

Speicherort Eine Funktion wird in die Konfigurationsdatei canape.ini in Ihrem

Arbeitsverzeichnis gespeichert. Skriptdateien werden stattdessen als separate Datei im Arbeitsverzeichnis gespeichert.

Format Skripte liegen im Skriptformat *.scr oder *.cns vor. Funktionen hingegen sind in

der canape.ini eingebettet.

2.5 Funktionseditor

Aufgaben Globale Variablen, Funktionen, Skripte und Seed-&-Key-Algorithmen können im Funktionseditor von CANape erstellt, editiert und kompiliert werden.

Funktionseditor öffnen

1. Klicken Sie in der Symbolleiste auf das Symbol .

oder

Klicken Sie im Menü Extras auf Funktionen und Skripte.

Der Funktionseditor öffnet sich.



Abbildung 2-1: Der Funktionseditor in CANape

Bereiche des Funktionseditors

Der Funktionseditor ist in folgende Bereiche eingeteilt:

> Baumansicht

> Listenansicht

> Editorfenster

> Meldungsfenster

Baumansicht In der Baumansicht werden alle vorhandenen Elemente aufgelistet:

> Globale Variablen

> Projekt-Funktionen

> Skripte

> Seed-&-Key-Algorithmen

Listenansicht In der Listenansicht befinden sich am unteren Rand verschiedene Registerkarten. Je nach Art der ausgewählten Registerkarte werden unterschiedliche Informationen zu den Elementen angezeigt.

Die Informationsspalten lassen sich über einen Klick auf den jeweiligen Spaltenkopf sortieren.

Meldungsfenster Im Reiter Output des Meldungsfensters werden Fehler- und Fortschrittsmeldungen angezeigt. Diese Meldungen können über das Kontextmenü bearbeitet werden.

Wenn das Debugging aktiviert ist, werden hier auch die jeweils aktiven Variablen,

Baumansicht

Listenansicht

Editorfenster

Meldungsfenster



Breakpoints und Debug-Tasks angezeigt.

Hinweis: Der Funktionseditor in CANape bietet zwei Hilfen an, die es ermöglichen, mit wenig Programmierkenntnissen Funktionen und Skripte zu erstellen:

> Kontextsensitive Hilfe: Setzen Sie den Cursor im Kontextmenü des Editorfensters auf eine Funktionsdefinition und klicken Sie <F1>. Die Hilfeseite zu der entsprechenden Funktion öffnet sich.

> Automatischen Syntaxvervollständigung: Beim Tippen in das Editorfenster wird eine Vorschlagsliste aller verfügbaren Funktionen, Objekte und globale Variablen angezeigt, deren Namen mit dem eingetippten Buchstaben beginnen. Mit [Eingabe] oder der <TAB>-Taste wird der Vorschlag übernommen.

2.6 Weitere Definitionen

2.6.1 Variablentypen

Vereinbarung Variablen sind Platzhalter für Werte eines bestimmten Typs. In Skripten und Funktionen können Variablen deklariert und definiert werden.

Definition (Art + Wert)

Bei der Definition wird dem Compiler ein Wert zugewiesen. Undefinierte lokale Variablen haben stets den Startwert 0. Die Definition von Variablen dient also dazu, die Art der Variablen anzulegen und Datenobjekte im Speicher anzulegen.

Deklaration (Name + Typ)

Bei der Deklaration wird dem Compiler die jeweilige Variable bekannt gegeben. Die Deklaration besteht immer aus dem Namen eines Objekts und seinem Typ. Damit weiß der Compiler, mit welchem Typ er einen Namen verbinden muss.

Globale Variablen Globale Variablen werden in der Listenansicht oder Baumansicht des Funktionseditors deklariert und können z. B. in jeder Funktion oder jedem Skript verwendet werden.

Lokale Variablen Lokale Variablen können im Funktions- oder Skriptkopf deklariert und auch gleichzeitig definiert werden. Übergabeparameter werden in der Parameterliste der Funktion deklariert.

Lebensdauer Während globale Variablen so lange leben wie das Programm, sind lokale Variablen nur während des Blockaufrufs gültig.

Gerätevariablen Mit einer Gerätevariablen ist es möglich, auf einen geräteinternen Wert zuzugreifen.

2.6.1.1 Globale Variablen

Nutzen Globale Variablen sind spezielle Datenobjekte, die in der CANape Konfiguration von allen Funktionen und Skripten genutzt werden können.

Ohne Hilfe von Übergabeparametern können Sie mithilfe globaler Variablen Informationen an andere Funktionen oder Skripte übergeben.

Definition Globale Variablen werden im Funktionseditor definiert. Als globale Variablen können ein- oder mehrdimensionale Felder sowie Variablen definiert werden.

Speicherort Globale Variablen werden projektbezogen in die Konfigurationsdatei canape.ini in

Ihrem Arbeitsverzeichnis gespeichert.

Eigenschaften Eine globale Variable besteht unter anderem aus einem Namen, einem Kommentar, einem Datentyp und einer Umrechnungsregel.



Gültigkeit Globale Variablen sind CANape weit gültig. Sie können in Verstell-Fenster eingefügt werden, so dass während der Messung die Werte der Variablen vom Anwender verändert werden können.

Überschreibung Sie werden von gleichnamigen lokalen Variablen sowie von gleichnamigen Funktionsargumenten überschrieben.

Statisches Verhalten Globale Variablen sind statisch. Sie behalten Ihren Wert zwischen zwei Messungen, wie auch über das Laden des Projektes hinweg. Ihr aktueller Wert wird beim Speichern der Konfiguration oder des Projekts in einer Parameterdatei gespeichert und beim Laden des Projektes auch wieder geladen.

Hinweis: Beachten Sie, dass Werte, die bei einer vorherigen Messung in einer globalen Variable gespeichert wurden, auch noch bei Start einer neuen Messung vorhanden sind.

Einbinden in CANape

Wie Sie eine globale Variable erstellen, lesen Sie in Abschnitt Erstellen einer globalen Variablen auf Seite 63.

Weiterhin wird auch beschrieben, wie Sie beeinflussen können, wann die globale Variable auf einen definierten Wert gesetzt werden soll, siehe Abschnitt Globale Variable auf definierten Wert setzen auf Seite 63.

2.6.1.2 Lokale Variablen

Gültigkeit Lokale Variablen sind nur innerhalb der jeweiligen Funktion oder des jeweiligen Skriptes gültig.

Überschreibung Sie überschreiben gleichnamige globale Variablen und werden wiederum von gleichnamigen Funktionsargumenten überschrieben.

Deklaration Lokale Variablen können im Unterschied zu C bis einschließlich CANape 11.0 nur am Anfang einer Funktion oder eines Skriptes deklariert werden und behalten in der gesamten Funktion Ihre Gültigkeit.

Mit CANape 12.0 ist auch eine Deklaration innerhalb einer Funktion sowie innerhalb

einer Blockanweisung (z. B. If-Anweisung oder for-Schleife) möglich.

Definition Undefinierte lokale Variablen haben stets den Startwert 0.

Beispiel: In der nachfolgenden Beispielfunktion handelt es sich bei c um eine lokale

Variable und bei A um einen Übergabeparameter.

function Function1 (Var A)

{

double Result;

Result = A;

if (A > 0)

{

int c = 2; // kein Syntaxfehler ab CANape 12.0

Result = c;

}

return Result;

}



Statisches oder nicht statisches Verhalten

Lokale Variablen können sich in CANape statisch oder nicht statisch verhalten. Statisches Verhalten bedeutet, dass die Variablen Ihren Wert zwischen den jeweiligen Funktionsaufrufen beibehalten.

Nachfolgend eine Übersicht über das Verhalten von lokalen Variablen innerhalb von CANape:

Verhalten Ort der Variablen Statisch Nicht statisch

Skript X

Funktion im Skript X

Benutzerdefinierte Funktion X

Benutzerdefinierte Funktion bei Aufruf durch Skript

X

Benutzerdefinierte Funktion bei Aufruf durch benutzerdefinierte Funktion

X

Benutzerdefinierte Funktion bei Aufruf durch Skript-Funktion

X

Unterschiedliche Startwerte

Wenn eine Funktion z. B. in der Data-Mining-Umgebung oder als virtueller Messdateikanal verwendet wird, gibt es in CANape die Möglichkeit, jeder Instanz einer Funktion einen unterschiedlichen Startwert einer lokalen Variable zuzuordnen.

Wie Sie eine lokale Variable auf einen definierten Wert setzen, siehe Abschnitt Lokale Variable auf definierten Wert setzen auf Seite 65.

2.6.1.3 Gerätevariablen

Zugriff auf geräteinternen Wert

Mit einer Gerätevariablen ist es möglich, auf einen geräteinternen Wert zuzugreifen und wenn möglich (datenbasenabhängig), diesen auch zu verändern. Die Kommunikation mit dem Gerät wird im Hintergrund ausgeführt, ohne dass sich der Anwender explizit darum kümmern muss.

Änderungen Änderungen von Gerätevariablen wirken sich unmittelbar auf das entsprechende Gerät aus.

Einfügen Die zur Verfügung stehenden Gerätevariablen können im Funktionseditor über das Kontextmenü eingesehen und in Funktionen und Skripte eingefügt werden. Wie Sie eine Gerätevariable einfügen, siehe Abschnitt Gerätevariable einfügen auf Seite 68.

2.6.2 Argumente und Übergabeparameter (von Funktionen)

Übergabe als Referenz

Argumente oder Übergabeparameter werden an Funktionen stets als Referenz (by

reference) übergeben und können somit auch für die Rückgabe von Werten

benutzt werden (siehe auch Abschnitt Was sind Funktionen auf Seite 8).

Sie überschreiben gleichnamige lokale und gleichnamige globale Variablen und

können als Datentyp lediglich die gleichbedeutenden Werte var und double

annehmen.

Somit sind die folgenden beiden Funktionen identisch:

Funktion A function Add (var A, var B)

{

return A+B;

}



Funktion B function Add (double A, double B)

{

return A+B;

}

Parametertypen Es sind zwei Typen von Parametern möglich: Skalare und Array-Parameter.

Skalare Parameter Als Argument für skalare Parameter kann jede skalare Variable, ein einzelnes Array-Element oder eine Konstante verwendet werden.

Array-Parameter Um Array-Parameter zu definieren, muss [ ] direkt hinter dem Parameternamen gesetzt werden. Als Argument für Array-Parameter kann jede Array-Variable,

konstante Strings oder globale/Datenbasis-Variablen vom Typ String verwendet

werden.

Optional kann als Datentyp-Präfix das Schlüsselwort var oder double verwendet

werden. Es gibt keinen Unterschied bei den Worten. Andere Präfixtypen werden nicht unterstützt.

2.6.3 Kommentare

Dokumentation Kommentare werden verwendet, um einen Code-Abschnitt innerhalb eines

Programms zu dokumentieren. Sie werden durch // für einen einzeiligen Kommentar

oder zwischen /* ... */ für mehrere Zeilen gekennzeichnet.

2.6.4 Beachtung der Groß- und Kleinschreibung

Variablennamen Bei Variablennamen in Funktionen und Skripten, globale Variablen und Variablen, die aus einer Datenbasis im CANape Funktionseditor referenziert werden, wird die Groß-und Kleinschreibung berücksichtigt.

Geräte- und Funktionsnamen

Gerätenamen und interne Funktionsnamen sind nicht case sensitive.

2.6.5 Vordefinierte Funktionsgruppen und Codebausteine von CANape

Hilfestellung Als Hilfe für den Funktionsentwurf bietet Ihnen CANape Codebausteine und verschiedene Funktionsgruppen an.

Codebausteine Klicken Sie hierzu mit einem rechten Mausklick in das Editorfenster und öffnen Sie dadurch das Kontextmenu. Wählen Sie den gewünschten Codebaustein, z. B. eine Kontrollstruktur, aus. Lernen Sie hierdurch Schritt für Schritt die C-ähnliche Syntax der CANape eigenen Programmiersprache kennen.

Funktionsgruppen Wählen Sie zwischen den verschiedenen von CANape vordefinierten CASL-Funktionen. Diese sind in folgende Funktionsgruppen gegliedert:

Precompiler-Direktiven

Precompiler-Direktiven zur bedingten Kompilierung. Anhand der Precompiler-Direktiven kann der Precompiler anhand von Ausdrücken und Symbolen entscheiden, welcher Teil des Source-Codes eingefügt, kompiliert und welcher entsprechend entfernt werden kann.

Trigonometrische Funktionen

Mit trigonometrischen Funktionen können Zusammenhänge zwischen Winkel und Seitenverhältnis berechnet werden.



Exponential-funktionen

Mit Exponentialfunktionen können Logarithmen und Potenzen und deren Bestandteile berechnet werden.

Verschiedene Funktionen

Unter Verschiedene Funktionen sind all die Funktionen zusammengefasst, die sich nicht zu einer der anderen Gruppen zuordnen lassen.

Zugriffsattribute Über die Funktionsgruppe der Zugriffsattribute erhält man Zugriff auf Merkmale verschiedener Datenobjekte wie z.B. Messwerte, Achsen oder Kennfelder/Kennlinien. Die Merkmale der Datenobjekte können z. B. Farbe, Anzahl, Status, Adresse, o.ä. sein.

Programm-funktionen

Mithilfe der Programmfunktionen werden allgemeine Zugriffe auf CANape ermöglicht.

Die folgenden Untergruppen bieten speziellere Zugriffe:

> Benutzereingabe: Zeigt verschiedene Dialogboxen an

> Ausgabe: Formatiert Ausgaben eines Strings, beschreibt die Fortschrittsanzeige

> Steuerung: Steuert die verschiedenen CANape Fenster

> Panel: Setzt Stoppuhren und greift auf Steuer- und Anzeigeelemente zu

> Konfiguration: Händelt Konfigurationen und Teilkonfigurationen

Gerätefunktionen Mithilfe der Gerätefunktionen können Sie auf die Geräte direkt als auch auf deren Datenbasen, Treiber, Status u. ä. zugreifen.

Messen Die Funktionen der Funktionsgruppe Messen ermöglichen Zugriff auf verschiedenste Vorgänge, die das Messen betreffen. In den Untergruppen Rekorder und Trigger finden Sie Funktionen, die jeweils auf die Rekorder und die Triggerung derer zugreifen.

Verstellen Mithilfe der Funktionen der Funktionsgruppe Verstellen können Sie auf Parametersätze zugreifen und den Verstellmodus von Geräten ändern. Außerdem erhalten Sie Schreib- und Lesezugriff auf den Gerätespeicher sowie Zugriff auf die verschiedenen Werte (physikalisch, Roh- oder String-Werte) von Objekten. Zusätzlich lässt sich die blockweise Modifikation eines Gerätes steuern.

In der Untergruppe Datenstände finden Sie die Funktionen, mit denen Sie Datenstände handhaben können.

Auswerten Die Funktionen der Funktionsgruppe Auswerten ermöglichen Zugriff auf den globalen Mess- und Differenzcursor und den Zeit-Offset, sowie auf Kommentare und auf Informationen über Triggerereignisse. Des Weiteren können Teile eines Integer-Signals extrahiert werden oder Messwerte eines Signals als String ermittelt werden.

Datenbasis Die Funktionen der Funktionsgruppe Datenbasis ermöglichen Zugriff auf Maßeinheit oder Namen von Datenbasisvariablen.

Flash-Funktionen Mithilfe von Flash-Funktionen können Programme und Parametersatzdateien geladen oder entladen werden. Es kann auch ein Parametersatz in eine binäre Datei kopiert werden.

Diagnosefunktionen Diagnosefunktionen gewähren Zugriff auf Serviceparameter und Messages (Request und Response an das Steuergerät).

In der Untergruppe Gerätefunktionen finden Sie Funktionen, die auf Geräte mit diagnosefähigem Treiber zugreifen können. Zusätzlich werden zwei Funktionen bereitgestellt, die die Implementierung von Seed-&-Key-Verfahren zulassen.

Skriptfunktionen Mithilfe von Skriptfunktionen werden Skripte gezielt aufgerufen, geprüft und gesteuert. Entsprechend können Fehlercodes und -texte ausgegeben werden oder Kommandozeilenargumente ermittelt werden. Außerdem gibt es eine Skriptfunktion zum temporären Laden/Entladen von Funktions-DLLs.

Data Mining-Funktionen

Data Mining-Funktionen können Data Mining-Analysen (und deren Methoden) starten, stoppen, beobachten oder vergleichen.



String-Funktionen Mithilfe von String-Funktionen können Strings oder allgemein die Inhalte bestimmter Speicherstellen be- und verarbeitet werden. Beispielsweise gibt es Funktionen zum Kopieren, Vergleichen oder Anhängen.

System- und Zeitfunktionen

System- und Zeitfunktionen können die unterschiedlichen Zeiten des Systems zurückgeben. Des Weiteren können Startwerte anderer Funktionen festgelegt werden und auf deren Prozesse gewartet werden.

Dateifunktionen Mithilfe von Dateifunktionen können Dateien gehandhabt werden. Dateien können beispielsweise gesucht, gelöscht, umbenannt, geöffnet oder gelesen werden. Dies gilt auch für die dateispezifischen Untergruppen HEX, MDF, PAR und XML.

Veraltete Funktionen Die Funktionen dieser Gruppe sind veraltet und sollten nicht mehr verwendet werden. Sie werden aber immer noch durch den Funktionseditor unterstützt.

Hinweis: Mehr Details zu den verschiedenen Funktionsgruppen und Codebausteinen erfahren Sie in der Hilfe. Markieren Sie dazu im Kontextmenü des Editorfensters die gewünschte Funktion oder Codebaustein und drücken Sie die Taste <F1>.

2.7 Allgemeine Systemgrenzen

Globale Variablen Die maximale Anzahl von globalen Variablen wird durch den Systemspeicher begrenzt.

Lokale Variablen Die maximale Anzahl von lokalen Variablen beträgt 16383.

Subfunktionen Die maximale Anzahl von Subfunktionen, die von einem Skript aufgerufen werden können, beträgt 10000.

Projekt-Funktionen Die maximale Anzahl von Projekt-Funktionen wird durch den Systemspeicher begrenzt.

Daten-Stack Das Daten-Stack ist 1024 Einträge groß. Sein Datentyp ist double.

Call-Stack Die maximale Anzahl der Aufruftiefe beträgt 64.

Argumenten-Stack Argumente für Subfunktionen oder Benutzer-Funktionsaufrufe werden in den Argumenten-Stack abgelegt. Die maximale Größe eines Argumenten-Stacks beträgt 10.000 Einträge.

Zeilenlänge Die Zeilenlänge des Quellcodes ist unbegrenzt.

Anweisungen Jede Verschachtelung im Quellcode (der Abschnitt zwischen { und }), kann etwa 9990 Anweisungen enthalten.

Handbuch CANape CASL Syntax


3 Syntax


3.1 Unterschiede zwischen C-Programmierung und CASL Seite 21

3.2 Zahlen und Zeichen Seite 21

Datentypen und Wertebereiche

Parametertypen für vordefinierte Funktionen

Konstanten

Arrays

Strings

Platzhalter

3.3 Operatoren Seite 26

3.4 Kontrollstrukturen (Anweisungen) Seite 27



3.1 Unterschiede zwischen C-Programmierung und CASL

Unterschiede Die CANape Skriptsprache CASL ist der C-Programmsprache sehr ähnlich. Sie unterscheidet sich jedoch in folgenden Punkten:

> CANape rechnet intern ausschließlich mit double-Werten.

> CANape verwendet keine Pointer (Zeiger).

Zusätzliche Feature Die CANape Skriptsprache CASL hat im Gegensatz zur C-Programmsprache eine Reihe zusätzlicher Features

> Ein fehlender Ergebnistyp wird als void interpretiert.

> Arrays beliebiger Dimension und Größe dürfen übergeben werden.

> Eine leere Parameterliste ist wie in C++ erlaubt.

> Überladen von Funktionen (d.h. mehrere Funktionen mit dem gleichen Namen, aber unterschiedlichen Parameterlisten) ist wie in C++ möglich.

> Eine Parameterprüfung erfolgt wie in C++.

3.2 Zahlen und Zeichen

3.2.1 Datentypen und Wertebereiche

Datentypen CANape stellt zur Verwendung in Funktionen und Skripten folgende Datentypen zu Verfügung:

Datentyp Wertebereich Größe/Bytes

char -128 bis 127 1

unsigned char 0 bis 255 1

byte 0 bis 255 1

short -32 768 bis 32 767 2

unsigned short 0 bis 65535 2

int -32 768 bis 32 767 2

unsigned int 0 bis 65 535 2

long -2 147 483 648 bis 2 147 483 647 4

unsigned long 0 bis 4 294 967 295 4

float -3,4·1038 bis 3,4·1038 (IEEE 32 Bit) 4

double -1,7·10308 bis 1,7·10308 (IEEE 64 Bit) 8

Array aus Datentyp erstellen

Des Weiteren können von jedem Datentyp Arrays erstellt werden. Der Zugriff auf die einzelnen Array-Elemente bei ein- bzw. zweidimensionalen Arrays erfolgt über den [<Index>]-Zugriffsoperator.

Beispiel: Array vom Datentyp int int Array[2];//Deklaration

Array[0]=1;//Definition

Array[1]=3;//Definition



3.2.2 Parametertypen für vordefinierte Funktionen

Übergabeparameter In der Syntax der Funktionen gibt es verschiedenen Typen von Parametern zur Übergabe von Daten. Diese werden in CANape Parametertypen genannt.

Typ Richtung Beschreibung

ARRAYREF [in/out] Referenz auf eine Array-Variable (lokal, global, device, parameter)

BUFFER [out] String für die Zuordnung eines Ausgangs über eine Referenz (lokal, global, device, parameter)

OPT_INLIST [in] Optionale Liste mit Eingangsargumenten

OPT_OUTLIST [out] Optionale Liste mit Ausgangsargumenten

REFERENCE [in/out] Der Compiler akzeptiert skalare oder Array-Variablen, die über eine Referenz definiert sind.

SIGNALREF [in/out] Signalobjekt, über eine Referenz definiert, z. B.

<DeviceName>.<SignalName>.

Beispiel: sizeof(CCPsim.channel1)

Für Funktionen, die den Wert oder den Status des Signals zu einem bestimmten Zeitpunkt benötigen, kann <file>.<signal>.mbuffer[index]

verwendet werden, z. B. für time() oder phy().

Ohne mbuffer wird für Gerätesignale der

aktuelle Status verwendet; für Dateisignale ist der Ausgang nicht definiert.

STRING [in] Über einen Wert definierter String (const, expression, lokal, global, device, parameter).

VAL [in] Über einen Wert definiert skalarer Wert (const, expression, lokal, global, device, parameter)

VALREF [out] Referenz auf eine skalare Variable (lokal, global, device, parameter)

Funktions-DLLs Für Funktions-DLLs gibt es ausschließlich:

Typ Richtung Beschreibung

REFERENCE [in/out] Skalar oder Array

VALUE [in] Skalar oder Array

3.2.3 Konstanten

Verwendung in Skripten

Beim Verwenden von Konstanten in Skripten ist bei der Interpretation von Hexadezimalkonstanten Folgendes zu beachten:

Hexadezimalkon-stanten

Hexadezimalkonstanten werden defaultmäßig als signed interpretiert. Damit eine

Hexadezimalkonstante als unsigned interpretiert wird, muss ein u oder U angehängt

werden.

Dezimalkonstanten Dezimalkonstanten werden korrekt interpretiert.



Hinweis: Zum Verhalten von Dezimal- und Hexadezimalkonstanten, die einer Variablen zugewiesen werden, erfahren Sie mehr in der Hilfe.

Einzelne ASCII-Zeichen

In Skripten und Funktionen können keine einzelnen ASCII-Zeichen z. B. 'A' als Konstanten verwendet werden. Die einfachen Hochkommas sind bereits für den Zugriff auf Signale, deren Namen nicht ASAM-konform sind, reserviert.

Um einer Variablen ein einzelnes Zeichen zuzuweisen, muss stattdessen die äquivalente hexadezimale Schreibweise verwendet werden.

Beispiel:

Für Konstanten ungültig ist:

char letter = 'A';

Stattdessen hexadezimale Schreibweise nutzen:

char letter = 0x41;

3.2.4 Arrays

Sammlung von Datenelementen

Ein Array (auch Feld genannt) ist eine Sammlung von Datenelementen, die alle den gleichen Namen haben. Der Wert innerhalb der eckigen Klammern hinter dem Array-Namen zeigt entweder die Array-Größe oder einen Indexwert, um die Daten anzugeben. Das Array beginnt immer bei Index 0. Die Anzahl der eckigen Klammern gibt die Dimension des Arrays an.

Übergabe Arrays werden stets als Referenz (by reference) übergeben.

Sprachgebrauch Ein eindimensionales Array bzw. eine Kennlinie entspricht einem Vektor.

Ein zwei- oder mehrdimensionales Array bzw. ein Kennfeld entspricht einer Matrize.

Beispiel 1: int data[3] = {10, 20, 40};

ergibt: data[0] = 10, data[1] = 20, data[2] = 40

Beispiel 2: Initialisiert werden die globalen Array-Variablen g_count[6][4] und

g_time[6][4].

int i=0;

int k=0;

for(k=0;k<=5;k++)

{

for(i=0;i<=3;i++)

{

g_count[k][i]=0;

g_time[k][i]=0;

}

}



3.2.5 Strings

Zeichenkette Ein String besteht aus einer Folge von einem oder mehreren aufeinanderfolgenden Zeichen, die in doppelte Anführungszeichen gesetzt sind.

Aufbau Das letzte Element in einem String ist ein Nullzeichen (\0), welches das Ende des

Strings anzeigt. Als Ergebnis ist die Array-Größe immer die Anzahl der Zeichen plus eins.

Übergabe Strings werden stets als Referenz (by reference) übergeben.

Beispiel: char string[12] = "Hello World!";

3.2.6 Platzhalter

Funktion write() Die write()-Funktion gibt einen String mit Formatierungsanweisungen wie bei dem

C-Befehl printf() aus. Die Ausgabe erfolgt zeilenweise in das Write-Fenster von

CANape.

Formatierungs-anweisung

Die Formatierungsanweisungen verwenden verschiedene Platzhalter.

Form Die Platzhalter haben die Form:

%[Flags][Feldbreite][.Genauigkeit]Typ

Wobei Flags, die Feldbreite und die Genauigkeit optional anzugeben sind.

Platzhalter Folgende Typen von Platzhaltern werden von den Formatierungsanweisungen verwendet:

Typ Typ Ausgabe

x, X Groß-/Kleinschreibung beachtende HEX-Zahlen vom Datentyp unsigned

long (4 Byte)

h, H HEX-Zahlen vom Typ unsigned short (2 Byte)

b, B HEX-Zahlen vom Typ unsigned char (1 Byte)

o Oktalzahlen

e, E Gleitkommazahlen in Exponentialdarstellung

g, G Gleitkommazahlen oder Exponentialdarstellung, je nachdem was kürzer ist

f Gleitkommazahlen

u Ganze positive Dezimalzahlen

d, i Ganzen Dezimalzahlen

c Ein einzelnes Zeichen (character)

s Strings

Beispiele:



Write("%h", 0xffff); // Ausgabe: ffff

Write("%o", 10); // Ausgabe: 12

Write("%e", 12.3456); // Ausgabe: 1.234560e+001

Write("c", 0x41); // Ausgabe: A

Write("%s", "Hello"); // Ausgabe: Hello

Flags Jeder der oben angegebenen Platzhalter kann optional mit einem Flag modifiziert werden. Folgende Flags können verwendet werden:

Flag Beschreibung

+ Zahlen werden rechtsbündig mit Vorzeichen ausgegeben.

- Zahlen werden linksbündig ausgegeben.

Negative Zahlen erhalten ein Vorzeichen.

' ' (Leerzeichen) Positive Zahlen werden mit führenden Leerzeichen ausgegeben.

0 Das Feld vor der Zahl wird mit 0 ausgefüllt.

# Typ g: Erzwingt einen Gleitpunkt

Typ x: Erhält ein 0x vor einer HEX-Zahl

Typ o: Setzt eine 0 vor die Oktalzahl. Anschließende Nullen nach dem Dezimalpunkt werden nicht angezeigt.

Beispiele:

Write("%+d", 1234); //Ausgabe: +1234

Write("Wert:% d", 20); //Ausgabe: Wert: 20

Write("%#g", 03); //Ausgabe: 3.00000

Write("%#x", 03); //Ausgabe: 0x03

Write("%#o", 5.1); //Ausgabe: 05

Feldbreite Die Feldbreite legt die Länge des Ausgabefeldes fest.

Beispiel: Feldbreite 12

long number = 12;

Write("Number:%4d", number);

//Ausgabe:

Number: 12

Genauigkeit Die Genauigkeit legt bei Gleitkommazahlen (z. B. vom Typ f) die Anzahl der

Nachkommastellen fest und rundet den Wert.

Beispiel: Genauigkeit von 2 Nachkommastellen

float number = 12.3456;

Write("Number:%.2f", number);



//Ausgabe:

Number: 12.35

Hinweis: Platzhalter können auch in jeder anderen benutzerdefinierten Funktion

verwendet werden, die mit Strings arbeitet (z. B. Sprint(), fprint()).

3.3 Operatoren

Verarbeitung von Datenobjekten

Der Funktionseditor in CANape verwendet verschiedene Operatoren zur Verarbeitung von Datenobjekten. Datenobjekte, die von Operatoren aufgerufen werden, nennt man Operanden.

Ziel Das Ziel der Verknüpfung von Operatoren und Operanden ist die Berechnung neuer Werte. Der Wert eines Ausdrucks wird oft auch als Rückgabewert bezeichnet.

Übersicht Folgende Operatoren stehen zur Verfügung:

> Arithmetische Operatoren

> Relationale Operatoren

> Binäre Operatoren

> Logische Operatoren

Arithmetische Operatoren

Operator Bezeichnung Syntax

+ Addition a + b

- Subtraktion a - b

* Multiplikation a * b

/ Division a / b

% Modulo, Rest einer Ganzzahldivision a % b

Relationale Operatoren

Operator Bezeichnung Syntax

> Größer a > b

< Kleiner a < b

>= Größer gleich a >= b

<= Kleiner gleich a <= b

== Gleich a == b

!= Ungleich a != b

Wenn die Aussage der Syntax bestätigt ist, wird 1 (TRUE) zurückgeliefert, sonst 0

(FALSE).

Binäre Operatoren Operator Bezeichnung Syntax

& Bitweise UND-Verknüpfung a & b

| Bitweise ODER-Verknüpfung a | b

~ Bitweise Komplement ~a

^ Bitweise exklusiv ODER-Verknüpfung a ^ b

<< Bitweise nach links Verschiebung a << x



Binäre Operatoren Operator Bezeichnung Syntax

>> Bitweise nach rechts Verschiebung a >> x

Logische Operatoren Operator Bezeichnung Syntax Beschreibung

! Logisches NICHT !a Wenn a wahr (TRUE) ist, liefert die

Operation falsch (FALSE) zurück.

&& Logisches UND a && b Die Operation liefert nur TRUE zurück,

wenn a und b TRUE sind; sonst

FALSE.

|| Logisches ODER a || b Die Operation liefert nur TRUE zurück,

wenn a oder b TRUE sind; sonst

FALSE.

Verweis: Beispiele zu den verschiedenen Operatoren finden Sie in der Hilfe. Markieren Sie dazu im Kontextmenü des Editorfensters den gewünschten Operator und drücken Sie die Taste <F1>.

3.4 Kontrollstrukturen (Anweisungen)

Kontrollfluss beeinflussen

Ein Programm besteht aus verschiedensten Anweisungen, die in der Regel eine nach der anderen abgearbeitet werden. Die Abarbeitungsreihenfolge von Anweisungen wird Kontrollfluss genannt. Eine Anweisung, die diesen Kontrollfluss beeinflusst, nennt man daher auch Kontrollstruktur.

Der Funktionseditor von CANape verwendet verschiedene Kontrollstrukturen, ähnlich wie in der C-Programmiersprache.

for Die for-Schleife ist eine bedingte Schleife. Sie führt die Anweisung(en) solange aus,

bis die Bedingung wahr (ungleich 0) ist.

for (Initialisierung; Bedingung; Reinitialisierung)

{..Anweisung(en)..}

while Die while-Schleife ist eine bedingte Schleife. Sie führt die Anweisung(en) solange

aus, bis die Bedingung nicht wahr (gleich 0) ist. Wenn die Bedingung von Anfang an

nicht wahr (gleich 0) ist, wird die while-Schleife im Gegensatz zur for-Schleife

überhaupt nicht ausgeführt.

while (Bedingung)

{..Anweisung(en)..}

do-while Die do-while-Schleife verhält sich wie die while-Schleife, mit dem Unterschied,

dass diese Schleife mindestens ein Mal durchlaufen wird.

do {..Anweisung(en)..} while (Bedingung);

if Die if-Anweisung ist eine bedingte Verzweigung im Programm. Wenn die Bedingung

wahr (ungleich 0) ist, dann werden die Anweisungen innerhalb des if-

Anweisungsblocks ausgeführt.

if (Bedingung) {..Anweisung(en)..}



if-else Die if-else-Anweisung ist eine bedingte Verzweigung im Programm. Wenn die

Bedingung wahr (ungleich 0) ist, dann werden die Anweisungen innerhalb des if-

Anweisungsblocks ausgeführt. Sonst werden die Anweisungen des else-

Anweisungsblocks ausgeführt.


else {..Anweisung(en)..}

if-else if Die if-else if-Anweisung ist eine Kette von bedingten Verzweigungen im

Programm. Es werden die Anweisungen innerhalb des if-Anweisungsblocks

ausgeführt, dessen Bedingung wahr (ungleich 0) ist. Sonst werden die Anweisungen

des else-Anweisungsblocks ausgeführt. Wenn kein alternativer Anweisungsblock

(else) am Ende der Verzweigungskette benötigt wird, dann kann die letzte else-

Anweisung weggelassen werden.


else if (Bedingung) {..Anweisung(en)..}

...

else {..Anweisung(en)..}

switch Die switch-Anweisung wird benutzt, um mehrere Verzweigungen in einem

Programm durchzuführen. Im Gegensatz zum if-else if-Statement ist das

switch-Statement einfacher und übersichtlicher.

Der Aufbau einer switch-Anweisung besteht aus einer Reihe von case-Marken und

einer optionalen default-Marke. Zwei konstante Ausdrücke in case-Marken dürfen

bei der Auswertung nicht denselben Wert annehmen.

Der konstante Ausdruck der case-Marken wird auf Gleichheit mit dem Ausdruck in

switch geprüft. Stimmt der Ausdruck in einer case-Marke mit einer Konstanten

überein, dann werden die Anweisungen ab diesem case ausgeführt. Die default-

Anweisung wird ausgeführt, wenn der Ausdruck mit keiner der Konstanten übereinstimmt.

switch (Ausdruck)

{

case Konstante1:

..Anweisung(en)..

break;

case Konstante2:

..Anweisung(en)..

break;

...

case KonstanteX:

..Anweisung(en)..

break;

default:

..Anweisung(en)..

}

break Der break-Befehl bricht eine Schleife (for oder while) oder eine switch-

Anweisung sofort ab.

break;



?: Die ?:-Anweisung ist ein Bedingungsoperator, eine Kurzform von if-else. Wenn

die Bedingung wahr (ungleich 0) ist, wird der Ausdruck1 zurückgeliefert, sonst wird

der Ausdruck2 zurückgeliefert.

(Bedingung) ? Ausdruck1 : Ausdruck2

continue Der continue-Befehl überspringt die verbleibenden Anweisungen einer Schleife und

kehrt zum Anfang der Schleife zurück. Bei einer for- oder einer while-Schleife wird

sofort der nächste Schleifendurchlauf ausgeführt. Bei einer do-while-Schleife wird

erst die Abbruchbedingung getestet und dann, falls nötig, der nächste Schleifendurchlauf gestartet.

continue;

return Das Schlüsselwort kann auf zwei Weisen verwendet werden: Es kann dazu dienen, eine benutzerdefinierte Funktion, eine Subfunktion oder ein Skript zu beenden und die Kontrolle zurück an die aufrufende Routine zurückzugeben. Falls kein Wert an die aufrufende Routine übergeben werden soll,

wird return ohne nachfolgenden Ausdruck eingesetzt (return;).

Das return-Schlüsselwort kann jedoch auch einen Wert vom Datentyp double an

die aufrufende Routine zurückliefern. Rückgabewerte von Skripten können derzeit nicht ausgewertet werden.

return [expression];

cancel Wenn der Befehl in einer Funktion verwendet wird, wird die Funktion ohne Rückgabewert abgebrochen. Die Kontrolle wird zurück an die aufrufende Routine übergeben.

Wenn der Befehl cancel in einer Subfunktion oder in einem Skript verwendet wird,

wird das Skript beendet.

cancel;

Hinweis: Für den Aufruf einer Funktion, die den Befehl cancel enthält, ist

entsprechend kein Ergebniswert verfügbar, d.h. es wird kein Wert in der Messdatei gespeichert oder im Anzeige-Fenster angezeigt. Damit lässt sich der Befehl z. B. zur Datenreduktion verwenden. Oder im Falle einer Steuergeräte-Stimulation wird die STIM-Botschaft nicht gesendet und es erfolgt dadurch kein Download der stimulierten Variable(n).

function Das Schlüsselwort function definiert eine benutzerdefinierte Funktion. Außerdem

kann es benutzt werden, um eine Subfunktion innerhalb eines Skripts zu definieren.

function <function name> (Parameter)

Verweis: Beispiele und detailliertere Beschreibungen zu den verschiedenen Kontrollstrukturen finden Sie in der Hilfe. Markieren Sie dazu im Kontextmenü des Editorfensters die gewünschte Kontrollstruktur und drücken Sie die Taste <F1>.

Handbuch CANape CASL Funktionen, Skripte und Variablen in CANape


4 Funktionen, Skripte und Variablen in CANape


4.1 Funktionen Seite 31

Funktionen schreiben

Funktionen speichern und weitergeben (exportieren/importieren)

Funktionen in Betrieb nehmen bzw. instanziieren

Beispielfunktionen

Globale Funktionsbibliothek

Externe Funktionsbibliotheken einbinden

Debuggen von Funktionen

4.2 Skripte Seite 51

Skripte schreiben

Skripte speichern und weitergeben (exportieren/importieren)

Task-Manager

Aufruf von Skripten

Skriptverhalten bei Ausführung von CANape

Debuggen von Skripten

Beispielskripte

4.3 Variablen Seite 63

Erstellen einer globalen Variablen

Globale Variable auf definierten Wert setzen

Lokale Variable auf definierten Wert setzen

Gerätevariable einfügen



4.1 Funktionen

4.1.1 Funktionen schreiben

Funktionseditor Eine Funktion kann im Funktionseditor von CANape geschrieben werden.

Funktionen anlegen:

1. Öffnen Sie den Funktionseditor über das Symbol (siehe auch Abschnitt Funktionseditor auf Seite 12).

2. Klicken Sie im Funktionseditor mit der rechten Maustaste in der Baumansicht auf Projekt-Funktionen|Neu.

Der Dialog Eigenschaften öffnet sich.

3. Geben Sie der Funktion den gewünschten Namen und fügen Sie ggf. einen Kommentar hinzu.

4. Bestätigen Sie Ihre Eingaben mit [OK].

5. Schreiben Sie im Editorfenster Ihre neue Funktion.

Vordefinierte Funktionsgruppen und Codebausteine

Als Hilfe für den Entwurf bietet Ihnen CANape Codebausteine und verschiedene vordefinierte CASL-Funktionen (in Funktionsgruppen gegliedert) an. Klicken Sie hierzu mit einem rechten Mausklick in das Editorfenster und öffnen Sie dadurch das Kontextmenu. Weitere Details siehe Abschnitt Vordefinierte Funktionsgruppen und Codebausteine von CANape auf Seite 17.

IntelliSense Lernen Sie CANape’s IntelliSense kennen! Tippen Sie z. B. den oder die Anfangsbuchstaben einer vordefinierten CASL-Funktion ein. Wählen Sie diese aus der automatisch erscheinenden IntelliSense-Liste aus. Mit <Tab>, <Eingabe> oder Doppelklick mit der linken Maustaste wird die markierte Funktion in das Editorfenster übernommen.

Achten Sie auf die Informationen, die CANape Ihnen zusätzlich über die Funktion einblendet. Hier werden z. B. der Datentyp des Rückgabewertes und die Anzahl der Übergabeparameter angezeigt.

Abb. 4-1: IntelliSense-Liste mit Zusatzinformationen beim Eintippen eines Buchstabens



Funktionen speichern und kompilieren:

6. Wenn Ihre Funktion fertig geschrieben ist, kompilieren Sie die Funktion über das

Symbol oder den Menüeintrag Kompilieren|Kompilieren.

7. Achten Sie hierbei auf die Nachrichten, welche CANape im Nachrichten-Fenster (Register Output) am unteren Bildschirmrand meldet.

Wenn dort die Nachricht "Das Programm ist kompiliert." erscheint, ist die Syntax Ihrer Funktion korrekt. Das rote Kreuz, mit der Ihre Funktion in der Baumansicht markiert ist, verschwindet.

Wenn eine Fehlernachricht angezeigt wird, versuchen Sie mithilfe der Meldung den Fehler zu beheben. Das rote Kreuz, mit der Ihre Funktion in der Baumansicht markiert ist, bleibt bestehen.

8. Speichern Sie Ihre Funktion mit oder über Datei|Speichern.

Die Funktion wird in die Konfigurationsdatei canape.ini in Ihrem

Arbeitsverzeichnis gespeichert. Das Sternchen, mit der Ihre Funktion in der Baumansicht markiert ist, verschwindet. Auch nicht kompilierte Funktionen können so gespeichert werden.

9. Schließen Sie den Funktionseditor über das Symbol oder das Menü Datei|Schließen.

Hinweis: Funktionen wie auch die Messung selbst haben in CANape eine sehr hohe Prozesspriorität. Vermeiden Sie daher langandauernden Programmcode, da sich dieser negativ auf die Performance Ihrer Messung auswirkt, z. B. können Messwerte verloren gehen. Endlosschleifen legen die gesamte Messung lahm und können nur mittels dreisekündigem Betätigen der <ESC>-Taste unterbrochen werden.

4.1.2 Funktionen speichern und weitergeben (exportieren/importieren)

Speichern Funktionen werden in die Konfigurationsdatei canape.ini in Ihrem

Arbeitsverzeichnis gespeichert.

Exportieren/ Importieren

Funktionen lassen sich aus dem Funktionseditor heraus exportieren und auch in diesen hinein importieren.

Formate Funktionen müssen im Funktionseditor-Exportformat (*.cne) oder als ASCII-

Textdatei (*.txt) vorliegen, damit sie importiert werden können.

Exportiert werden Funktionen im Funktionseditor-Exportformat (*.cne), als ASCII-

Textdatei (*.txt) oder im HTML-Format (*.html oder *.htm).

Funktionen importieren:

1. Öffnen Sie den Funktionseditor über das Symbol .

2. Wählen Sie Datei|Importieren|Funktion.

Ein Explorer-Fenster öffnet sich.

3. Wählen Sie die zu importierende Funktion aus und bestätigen Sie Ihre Wahl mit einem Doppelklick oder mit [Öffnen].

4. Funktionseditor-Exportformat (*.cne): Markieren Sie in der nun folgenden

Abfrage Ihre Funktion und bestätigen Sie Ihre Wahl mit [OK].

oder



ASCII-Textdatei (*.txt): Bestätigen Sie die Eigenschaften der Funktion.

Die importierte Funktion wird in der Baumansicht als ungespeichert (mit Sternmarkierung) angezeigt.

5. Speichern Sie Ihre Funktion mit oder über Datei|Speichern.

Funktionen exportieren:


2. Markieren Sie die zu exportierende Funktion in der Baumansicht.

3. Wählen Sie im Kontextmenü Export.

oder

Aktivieren Sie Ihre Maus im Editorfenster, Reiter Projekt-Funktionen und klicken Sie auf Bearbeiten|Export.

4. Wählen Sie in dem aufgegangenen Dialog das gewünschte Exportformat aus.

5. Wählen Sie im Explorer-Fenster den gewünschten Speicherort aus und bestätigen Sie Ihre Wahl mit [Speichern] und ggf. mit [OK].

Benutzereigene Funktionen und auch deren Verknüpfungen werden darüber

hinaus in der jeweiligen Konfiguration (*.cna-Datei) des Projekts gespeichert.

Die Funktionen werden außerdem in der zugehörigen CANape INI-Datei abgelegt.

Verknüpfte Funktionen weitergeben

Um z. B. ein offline konfiguriertes virtuelles Signal und eine damit verknüpfte Funktion für andere Nutzer zugänglich zu machen, können Sie eine neue Konfiguration erstellen. In dieser Konfiguration können Sie die gewünschte Funktion als virtuellen Messdateikanal in einem Grafik-Fenster verwenden (siehe Abschnitt Funktion in einem Grafik-Fenster als virtuellen Messdateikanal verwenden auf Seite 35).

Konfiguration importieren

Anschließend können Sie diese Konfiguration an anderer Stelle importieren.

Bei CANape Versionen unter 11.0 nutzen Sie hierfür ausschließlich Datei|Konfiguration partiell laden.

Bei CANape Versionen ab 11.0 können Sie darüber hinaus die neue Konfiguration zur aktuellen Konfiguration hinzufügen. Wählen Sie hierzu Datei|Konfiguration|Konfigurations-Manager und im Konfigurations-Manager [Hinzufügen] Existierende Konfiguration.

Die hinzugefügte Konfiguration können Sie jederzeit im Konfigurations-Manager deaktivieren. Das partielle Laden bietet die Möglichkeit nur Teile einer großen Konfiguration zur aktuellen Konfiguration hinzuzufügen.

Achten Sie bei der Verwendung von Gerätegrößen (z. B. Signalen) als Eingangsgrößen für Ihre Funktion darauf, dass das verwendete Gerät in der aktuellen Konfiguration auch vorhanden ist.

Hinweis: Befindet sich nur ein Gerät in der Gerätekonfiguration, wird dessen Datenbasis automatisch zur Auswahl geöffnet. Bei mehreren Geräten werden Sie zunächst über einen Dialog aufgefordert, eines der vorhandenen Geräte auszuwählen, damit dessen Datenbasis zur Auswahl der Signale verwendet wird. Somit können den Variablen einer Funktion geräteübergreifend Signale zugewiesen werden.



4.1.3 Funktionen in Betrieb nehmen bzw. instanziieren

Funktionsdefinitionen Benutzerdefinierte Funktionen, also Bibliothek-Funktionen und Projekt-Funktionen, werden in der Baumansicht unter Funktionsdefinitionen im Symbol Explorer angezeigt.

Projekt-Funktionen werden außerdem in der Baumansicht des Funktionseditors angezeigt. Die Bibliothek-Funktionen können ebenfalls in den Funktionseditor importiert werden (siehe Abschnitt Globale Funktionsbibliothek auf Seite 46).

Abb. 4-2: Projekt-Funktionen im Symbol Explorer

Funktion instanziieren

Um eine Funktion in Betrieb zu nehmen, muss diese instanziiert werden. Dies kann auf folgende Arten geschehen:

> Eine Funktion in einem Grafik-Fenster als virtuellen Messdateikanal verwenden (für Details siehe Abschnitt Funktion in einem Grafik-Fenster als virtuellen Messdateikanal verwenden auf Seite 35).

> Eine Funktion in der Messsignalliste instanziieren (für Details siehe Abschnitt Funktion während einer Messung verwenden auf Seite 36).

> Eine Funktion bei Erhalt einer CAN-Rohbotschaft ausführen (für Details siehe Abschnitt Funktionen bei Erhalt eines CAN-Signals ausführen auf Seite 39).

> Eine Funktion aus einer anderen Funktion heraus aufrufen (für Details siehe Abschnitt Funktion aus einer anderen Funktion heraus aufrufen auf Seite 42).

> Eine Funktion aus einem Skript heraus aufrufen (für Details siehe Abschnitt Subfunktion in einem Skript erstellen und aufrufen auf Seite 43).

> Eine Funktion im Data Mining als virtuelles MDF-Signal verwenden (für Details siehe Abschnitt Funktion im Data Mining als virtuelles MDF-Signal verwenden auf Seite 43).

Verwendung von Funktionen

Funktionen können in die Messsignalliste eingefügt oder als Funktionsdefinition für virtuelle MDF-Signale (z. B. für Data Mining) verwendet werden. Sie können auch direkt von einer anderen benutzerdefinierten Funktion bzw. einem benutzerdefiniertem Skript aufgerufen werden. Dieses Verfahren wird aber nicht



empfohlen, wenn eine hohe Performance erforderlich ist.

4.1.3.1 Funktion in einem Grafik-Fenster als virtuellen Messdateikanal verwenden

Modifikation an Messsignal über Funktion grafisch darstellbar

Um sich Modifikationen an einem ursprünglich gemessenen Messsignal grafisch darstellen zu lassen, können Sie diese Modifikationen am Messsignal in einer Funktion vornehmen und sich das Ergebnis der Funktion in einem Grafik-Fenster als virtuellen Messdateikanal anzeigen lassen.

Die Funktion wird dann automatisch auf jeden Abtastwert des Messsignals angewendet.

Beispiel: Sie können einen Offset zum ursprünglichen Signal hinzufügen, das ursprüngliche Signal anders skalieren oder auch Berechnungen aus zwei Messsignalen durchführen.

Es ist möglich, sich aus den Eingangssignalen Strom und Spannung die Leistung

berechnen zu lassen. In einem weiteren Schritt kann die Leistung mittels der

Bibliothek-Funktion Integral() zur über den Zeitraum benötigten Energie

integriert werden.

Virtuellen Messdateikanal anlegen:

1. Ziehen Sie per Drag & Drop die gewünschte Funktion in das Grafik-Fenster.

Abb. 4-3: Funktion aus Symbol Explorer in ein Grafik-Fenster ziehen

2. Wählen Sie im aufpoppenden Menü Virtueller Messdateikanal.

3. Ordnen Sie der Funktion Ihre Eingangsgröße(n) zu. Ziehen Sie dazu via Drag &



Drop die gewünschte Eingangsgröße auf den gewünschten Eingangsparameter der Funktion.

Abb. 4-4: Eingangsgröße der Funktion zuordnen

1. Sie können alternativ zum oben genannten Vorgehen auch einen Rechtsklick in das Grafik-Fenster tätigen und Einfügen|Neuen virtuellen Messdateikanal aus|Funktion wählen.

2. Befüllen den sich öffnenden Dialog wie in Abschnitt Funktion während einer Messung verwenden auf Seite 36 beschrieben.

4.1.3.2 Funktion während einer Messung verwenden

Ziel Um eine Funktion während einer Messung verwenden zu können, muss diese in die Messliste der Messkonfiguration angelegt werden. Sie wird dann auch Messfunktion genannt.

Funktion in Messkonfiguration instanziieren/Messfunktion erstellen:

1. Öffnen Sie die Messkonfiguration über <F4>, das Symbol oder über den Menüeintrag Messen|Messkonfiguration.

2. Gehen Sie in den Abschnitt Messsignale.

3. Klicken Sie auf das Symbol oder wählen Sie das Menü Bearbeiten|Funktion einfügen.

Der Dialog Funktion öffnet sich.

In dem Dialog Funktion können Sie eine schon bestehende Funktion auswählen oder eine neue Funktion anlegen.

Beispiel: Um eine Verstellgröße zyklisch zu verändern, könnten Sie die folgende

Beispielfunktion ToggleSignal mit folgender Funktionsdefinition verwenden:



function ToggleSignal (Signal)

{

if(Signal==199)

{

Signal=0;

}

else

{

Signal=199;

}

}

4. Erstellen Sie im Dialog Funktion eine neue Funktion über [Neu]

oder

wählen Sie eine vorhandene Funktion mit [Auswahl] aus.

Für die Neuerstellung einer Funktion entspricht die Menüführung der Vorgehensweise wie sie in Abschnitt Funktionen schreiben auf Seite 31 ab Handlungsschritt 3 beschrieben ist.

Abb. 4-5: Dialog Funktion nach Anlage einer neuen Funktion

Variablen verknüpfen Sie können hier außerdem den Variablen Ihrer Funktion eventuell benötigte Eingangsgrößen zuordnen. Wählen Sie hierbei zwischen globalen Variablen und

realen oder simulierten (z. B. XCPsim) Messsignalen.

Mit der Beispielfunktion können Sie z. B. die Verstellgröße ampl in der XCP-Demo

beeinflussen.

5. Markieren Sie die entsprechende Variable Signal.

6. Klicken Sie auf [Manuell verknüpfen].

Der Dialog Manuell verknüpfen öffnet sich.

7. Wählen Sie das Gerät XCPsim aus und bestätigen Sie Ihre Wahl mit einem

Doppelklick oder mit [OK].

Die Datenbasis-Auswahl öffnet sich.

8. Markieren Sie den Verstellparameter ampl.



9. Klicken Sie auf Übernehmen und beenden Sie die Datenbasis-Auswahl über

das Symbol .

Die Verknüpfung erscheint im Dialog Funktion wie folgt:

Abb. 4-6: Variable mit zugeordnetem Signal

10. Verlassen Sie den Dialog Funktion mit [OK].

Die Funktion wird in die Messsignalliste eingefügt.

Sie können den geschlossenen Dialog jederzeit mit dem Kontextmenübefehl Funktion ändern erneut aufrufen und somit z. B. die Signalverknüpfung ändern.

11. Wählen Sie den Messmodus der Funktion aus, z. B. cyclic mit einer Rate von

100.

Die Verstellgröße ampl der Beispielfunktion ToggleSignal wird dann

regelmäßig alle 100 ms verstellt.

Hinweis: Wenn Ihre Funktion die globalen Variablen bei Messungsstart resetten soll, verwenden Sie den Messmodus on event 'MeasurementStart' wählen.



Abb. 4-7: Messsignalliste mit Beispielfunktion und ihren Messmodus-Einstellungen

Hinweis: Befindet sich nur ein Gerät in der Gerätekonfiguration, wird dessen Datenbasis automatisch zur Auswahl geöffnet. Bei mehreren Geräten werden Sie zunächst über einen Dialog aufgefordert, eines der vorhandenen Geräte auszuwählen, damit dessen Datenbasis zur Auswahl der Signale verwendet wird. Somit können den Variablen einer Funktion geräteübergreifend Signale zugewiesen werden.

4.1.3.3 Funktionen bei Erhalt eines CAN-Signals ausführen

Ziel Möchten Sie z. B. bei Erhalt eines über CAN gemessenen Signals Ihre Funktion aufrufen, so müssen Sie sicherstellen, dass ein CAN-Gerät angelegt ist.

Hinweis:

Es gibt drei verschiedene Möglichkeiten, ein Gerät anzulegen:

> über das Hauptmenü mit Gerät|Neu

> über die Gerätekonfiguration

> aus einer bestehenden Datenbasis importieren und anlegen (Gerät|Neu aus|Datenbasis)

Mehr Details erfahren Sie in der CANape Hilfe.

Um nun Ihre Funktion bei Eintreffen eines CAN-Signals ausführen zu lassen, können Sie nahezu analog zu Abschnitt Funktion während einer Messung verwenden auf Seite 36 vorgehen.

1. Öffnen Sie die Messkonfiguration über das Symbol oder über den Menüeintrag Messen|Messkonfiguration.

2. Klicken Sie auf das Symbol oder wählen Sie im Menü Bearbeiten|Funktion einfügen.




In dem Dialog Funktion können Sie eine schon bestehende Funktion auswählen oder eine neue Funktion anlegen.

3. Verwenden Sie z. B. die CANape Bibliothek-Funktion AbsoluteValue(), um

z. B. ein Sinussignal gleichzurichten.

4. Benennen Sie die Funktion z. B. Rectify.

5. Markieren Sie die Variable Signal.

6. Klicken Sie auf [Manuell verknüpfen].

Der Dialog Manuell verknüpfen öffnet sich.

7. Um ein CAN-Signal als Eingangssignal zu verwenden, wählen Sie das bereits

angelegte Gerät CANDemo.

Abb. 4-8: Signal manuell verknüpfen

8. Bestätigen Sie Ihre Wahl mit einem Doppelklick oder [OK].


9. Klicken Sie auf den Ordner Signals, um sich dessen Inhalt anzeigen zu lassen.

10. Wählen Sie daraus z. B. das Signal Kanal1 aus.

Abb. 4-9: Signal aus Datenbasis übernehmen


das Symbol .

Die Verknüpfung wird im Dialog Funktion angezeigt.

12. Verlassen Sie den Dialog Funktion mit [OK].

Die Funktion wird in die Messsignalliste eingefügt.



Abb. 4-10: Funktionen in Messsignalliste mit verschiedenen Messmodi

Ergebnis Die Auswahl des Messmodus on input oder in diesem Fall auch on signal

'Kanal1' bewirkt, dass Ihre Funktion jedes Mal ausgeführt wird, wenn Ihre

Eingangsgröße einen neuen Wert übermittelt bekommt.

Kanal1 ist hierbei ein CAN-Signal, welches als Eingangssignal an die Funktion

übergeben wird.

13. Beenden Sie die Messkonfiguration über das Symbol .

Abb. 4-11: Funktionen in Messsignalliste des Symbol Explorers



Funktion als virtuellen Messkanal verwenden

Nun können Sie Ihre Funktion z. B. als virtuellen Messkanal verwenden, indem Sie

diese via Drag & Drop aus dem Symbol Explorer in ein Grafik-Fenster ziehen (siehe auch Abschnitt Funktion in einem Grafik-Fenster als virtuellen Messdateikanal verwenden auf Seite 35).

14. Ziehen Sie die Funktion per Drag & Drop auf ein Grafik-Fenster.

Abb. 4-12: Funktion in Grafik-Fenster einfügen

Ergebnis Das Ergebnis einer Beispielmessung kann dann z. B. so aussehen:

Abb. 4-13: Ergebnis einer Messung (Beispiel)

4.1.3.4 Funktion aus einer anderen Funktion heraus aufrufen

Ziel Es ist möglich, eine Funktion aus einer anderen Funktion heraus aufzurufen.

Beispiel:


{

double Result;

Result=A*2;

return SecondaryFunction(Result);

}



function SecondaryFunction (Var B)

{

return B+1;

}

4.1.3.5 Subfunktion in einem Skript erstellen und aufrufen

Unterfunktionen von Skripten

Als Subfunktionen werden in CANape Unterfunktionen von Skripten bezeichnet. Sie bieten den Vorteil, dass Sie zusammen mit den aufrufenden Funktionen in einer Skriptdatei erstellt und somit auch ganzheitlich exportiert werden können, ohne das gesamte Projekt weitergeben zu müssen.

Syntax Von der Syntax her unterscheiden sie sich jedoch nicht von einer herkömmlichen Funktion.

Mehrere Subfunktionen in einem Skript

Ein Skript kann mehrere Subfunktionen enthalten. Die Funktionsdefinitionen müssen aber vor dem Hauptteil des Quellcodes des Skripts stehen (der Hauptteil des Skripts beginnt nach dem Definitionsteil aller Variablen und Subfunktionen).

Geltungsbereich Subfunktionen gelten nur für das Skript, in dem sie definiert wurden. Sie können nicht von einem anderen Skript oder einer anderen benutzerdefinierten Funktion aufgerufen werden. Es ist aber möglich, ein Skript, das ein Set von Subfunktionen

enthält, über #include in ein anderes Skript einzufügen.

4.1.3.6 Funktion aus einem Skript heraus aufrufen

Ziel Es ist ebenfalls möglich, eine Funktion aus einem Skript heraus aufzurufen.

Beispiel:

Funktion:


{

double Result;

Result=A*2;

return Result;

}

Skript:

Double Output;

Output=Function1(100);

Write("%d", Output);

4.1.3.7 Funktion im Data Mining als virtuelles MDF-Signal verwenden

Data Mining Data Mining ist ein Verfahren zur automatischen Offline-Auswertung von Signalen in einer Reihe vorhandener MDF-Dateien. Auf diese Messdateien wird eine Funktion angewendet, um die Messwerte nach bestimmten Kriterien zu durchsuchen.

Vorteil So können Sie für mehrere MDF-Dateien Funktionsergebnisse innerhalb nur eines Suchlaufs filtern.



1. Wählen Sie im Menü Analyse|Data Mining|Editor.

Wenn Sie noch keine Messdatei geladen haben, erscheint ein Dialog, in dem Sie gefragt werden, ob Sie eine Messdatei laden möchten.

2. Wählen Sie gegebenenfalls [Ja].


3. Wählen Sie die gewünschte MDF-Datei aus.

4. Bestätigen Sie Ihre Wahl mit einem Doppelklick oder mit [Öffnen].

Das Fenster Data Mining öffnet sich.

5. Im Abschnitt Konfiguration|Methoden werden Ihnen alle virtuellen Messdateikanäle angezeigt.

6. Zusätzlich können Sie weitere einfügen/neu anlegen, indem Sie auf Bearbeiten|Funktion einfügen klicken.

Neuerstellung: Für die Neuerstellung einer Funktion entspricht die weitere Menüführung der Vorgehensweise wie sie in Abschnitt Funktionen schreiben auf Seite 31 ab Handlungsschritt 3 beschrieben ist.

Auswahl: Für die Auswahl einer vorhandenen Funktion entspricht die weitere Menüführung der Vorgehensweise wie sie im Abschnitt Funktion während einer Messung verwenden auf Seite 36 ab Handlungsschritt 3 beschrieben ist.

4.1.4 Beispielfunktionen

Beispiel 1: Benutzerdefinierte Funktion Add()

// user function Add()

function Add(Var a, Var b)

{

return a + b;

}

Beispiel 2: Subfunktion in einem Skript

// simple_sub_functions_demo.scr

// Variable definitions

Var var1;

// Subfunction definitions

Function F1()

{

var1++;

}

Function F2(Var param1, Var increment_constant)

{



Var var2; // Local variable inside subfunction

var2 = increment_constant;

F1();

param1 = param1 + var2; //Using parameter for output

}

Function F3(Var param1[], Var param2)

{

write("%s : (value=%d)", param1, param2);

return 1;

}

// Main Script Part

var1 = 0;

F1();

F2(var1, 1);

if (var1!=3)

{

var1 = F3("Error", var1);

}

else

{

var1 = F3("Ok", var1);

}

Write("var1 = %d", var1);

Beispiel 3: Übergabe von eindimensionalem Array bzw. Kennlinie

function ChecksumBlock(var Signal1[])

{

unsigned long DpkCtr1_Size, i;

unsigned long changeVal;

DpkCtr1_Size = xDimension(Signal1);

for (i = 0; i < DpkCtr1_Size; i++)

{

changeVal += Signal1[i] * (i + 1);

}

return changeVal;

}



Hinweis: Achten Sie auf die eckigen Klammern der Variablen im Funktionskopf, wenn Sie Kennlinien oder eindimensionale Arrays an eine Funktion übergeben möchten.

Bei mehrdimensionalen Arrays bzw. Kennfeldern muss die Anzahl der eckigen Klammern mit der Anzahl der Dimension des jeweiligen Arrays/Kennfeldes übereinstimmen.

Bei zweidimensionalen Arrays verwenden Sie zwei eckige Klammern hintereinander,

z. B. Signal1[][].

4.1.5 Globale Funktionsbibliothek

Bibliothek-Funktionen

Nutzen Sie auch die seit CANape 8.0 mitgelieferte globale Funktionsbibliothek. Während des Setup-Prozesses wird defaultmäßig die globale Funktionsbibliothek angelegt, die einige Funktionsdefinitionen enthält.

Diese können entweder unverändert verwendet werden oder nach Benutzerwünschen bearbeitet werden.

Die Funktionen der globalen Funktionsbibliothek nennt man Bibliothek-Funktionen.

Sie finden die Bibliothek-Funktionen im Symbol Explorer unter Funktionsdefinitionen|Bibliothek-Funktionen.

1. Öffnen Sie den Symbol Explorer gegebenenfalls mit Anzeige|Symbol Explorer

oder über das Symbol .

Abb. 4-14: Anzeige der Bibliothek-Funktionen im Symbol Explorer

Hinweis: Die globale Funktionsbibliothek enthält nur Funktionen - keine Skripte, globale Variablen oder Seed-&-Key-Algorithmen.

Import aus Bibliothek Die Bibliothek-Funktionen müssen zur Bearbeitung in den Funktionseditor importiert werden.



Export in Bibliothek Genauso können geänderte Bibliothek-Funktionen oder eigene Projekt-Funktionen in die globale Funktionsbibliothek exportiert werden.

Beide Befehle dazu finden Sie im Kontextmenü der Funktion in der Baumansicht im Funktionseditor.

4.1.6 Externe Funktionsbibliotheken einbinden

Erweiterter Funktionsumfang

Sollte Ihnen der Funktionsumfang und die Möglichkeiten, die CANape Ihnen bietet nicht ausreichen, können Sie außerhalb von CANape Ihre eigene Funktionsbibliothek

(Erweiterung *.dll) mit den gewünschten Funktionen schreiben.

Vorteile Vorteile der Nutzung einer externen Funktionsbibliothek:

> Sie können bereits bestehenden C-Code in CANape einbinden.

> Sie können komplexere Aufgaben lösen als mit den von CANape zur Verfügung gestellten Funktionen und Skripten.

> Die DLL wird schneller ausgeführt, da sie bereits kompiliert ist.

Argumente Argumente werden entweder als Wert (by value) oder als Reference (by

reference) übergeben.

value Im Fall von value wird eine Kopie des Parameterwertes an Ihre Funktion übergeben

(Eingabeparameter). Änderungen an diesem Parameterwert in der Funktion bleiben für aufrufende Programme ungültig.

CANape rechnet intern ausschließlich mit double-Werten.

Wenn z. B. aus einem CANape Skript heraus an Ihre DLL-Funktion Argumente by

value übergeben werden, erscheinen diese in Ihrer DLL-Funktion daher stets als

double-Typ.

reference Arrays (Char-Arrays) oder Strings lassen sich nicht by value übergeben. Daher

werden diese grundsätzlich by reference übergeben.

Wenn z. B. aus einem CANape Skript heraus an Ihre DLL-Funktion Argumente by

reference (als Referenz) übergeben werden und es sich nicht um einen double-

Typ handelt, erscheinen diese in Ihrer DLL-Funktion als sich vom Typ double

unterscheidenden Typ. Ein Char-Array wird z. B. als kDtypByte übergeben.

Auch wenn ein Parameterwert von der Funktion geändert werden soll

(Ausgabeparameter), müssen Sie den Typ reference verwenden.

Rückgabewert In allen Fällen ist der Rückgabewert der Funktion vom Typ double.

Verhalten testen Wie sich CANape bei anderen Datentypen im Detail verhält, können Sie durch Debuggen Ihrer DLL-Datei feststellen.

Attachen Sie sich dazu z. B. an die canape32.exe, während Sie Ihre DLL-Funktion

von CANape aus (z. B. in einem Skript) aufrufen.

Verweis: In Ihrem CANape Installationsverzeichnis befindet sich unter

Documentation die Application Note AN-IMC-1-012_How_to_use_C-

Code_Functions_in_CANape.pdf zu diesem Thema. Außerdem finden Sie unter

Examples\FunctionDemoDLL\Sources Beispielcode in der

Programmiersprache C.



Einbinden einer DLL-Bibliothek:

1. Öffnen Sie den Menüpunkt Extras|Optionen.

Der Optionen-Dialog öffnet sich.

2. Wählen Sie den Bereich Sonstiges|Funktionen und Skripte.

3. Klicken Sie auf die Schaltfläche [Hinzufügen].


4. Wählen Sie die gewünschte DLL-Datei aus.

5. Bestätigen Sie Ihre Wahl mit [Öffnen].

Ihre DLL-Datei wird in der Liste der Bibliotheken angezeigt.

6. Beenden Sie den Optionen-Dialog mit [OK].

Abb. 4-15: Externe Funktionsbibliothek über den Optionen-Dialog einbinden

7. Öffnen Sie nun den Funktionseditor über das Symbol .

8. Klicken Sie anschließend mit der rechten Maustaste in das Editorfenster.

Analog zu Abschnitt Vordefinierte Funktionsgruppen und Codebausteine von CANape auf Seite 17 können Sie nun im Editorfenster unter dem Kontextmenüeintrag Einfügen|DLL-Funktionen Ihre extern erstellten Funktionen verwenden.

4.1.7 Debuggen von Funktionen

Ziel Zum Diagnostizieren und Auffinden von logischen Fehlern in benutzerdefinierten Funktionen empfehlen wir Ihnen das Debuggen von Funktionen.

Funktionen lassen sich wegen Ihrer hohen Prozesspriorität jedoch im Gegensatz zu Skripten nicht im Funktionseditor mittels Breakpoints debuggen.



Vorgehen Daher muss stattdessen die Ausgabe von Debug-Informationen im Write-Fenster

mittels der Programm-Funktionen wie z. B. Write, Writef, Print oder Printf

genutzt werden.

Beispiel: Anhand des folgenden Beispiels, möchte der Nutzer feststellen, warum sein

Rückgabewert der Funktion (Result) nur ganzzahlige Werte annimmt.

function Funktion_1 (var Input)

{

double Result=0;

double Offset=10;

Long Result2=0;

Result=Input+Offset;

Write("Result Write: %g", Result);// line break, output

before information loss

/*

..

*/

Result2=Result;// conversion double to long, thus information

loss

/*

*/

Result=Result2;// reconversion to double, information loss

remains

Print("Result Print: %g", Result);// no line break, output

after information loss

Print("Result Print: %g", Result);// no line break

Printf("Result Printf: %g", Result);// line break

return Result;

}

Hinweis: Die Funktion dient nur als Beispiel und würde im konkreten Anwendungsfall deutlich umfangreicher aussehen.

Debug-Informationen im Write-Fenster erzeugen:

1. Erstellen Sie die Beispielfunktion Function_1 (siehe auch Abschnitt Funktionen

schreiben auf Seite 31).

2. Legen Sie ein Write-Fenster über das Menü Anzeige|Sonstige Fenster|Write-Fenster an.

3. Legen Sie ein Grafik-Fenster über das Menü Anzeige|Messfenster|Grafik-Fenster an.

4. Ziehen Sie aus dem Symbol Explorer ein Signal, z. B. channel1, per Drag &

Drop in das Grafik-Fenster.

5. Rufen Sie die Funktion auf. Wählen Sie dazu zwischen einen der folgenden



Möglichkeiten:

a) Funktion in einem Grafik-Fenster als virtuellen Messdateikanal verwenden auf Seite 35

b) Funktion aus einem Skript heraus aufrufen auf Seite 43

c) Funktion während einer Messung verwenden auf Seite 36.

Wenn Sie nur ein Messsignal zum Debuggen haben, können Sie auch direkt

mit Drag & Drop die Function_1 über channel1 in das Grafik-Fenster

ziehen und die Messfunktion in der Messliste anlegen:

Abb. 4-16: Messfunktion in Messliste anlegen per Drag & Drop

6. Starten Sie die Messung mit .

7. Bewerten Sie die Meldungen im Write-Fenster.

Puffergröße Achten Sie auf die Puffergröße Ihres Write-Fensters und passen Sie diese ggf. an. Sollte die Puffergröße nicht ausreichen, lassen Sie sich entsprechende Informationen in eine Logdatei schreiben.

Konfiguration Write-Fenster

Klicken Sie hierzu mit der rechten Maustaste auf Ihr Write-Fenster und wählen Sie unter Konfiguration die entsprechenden Punkte laut Abb. 4-17: Konfiguration Write-Fenster auf Seite 51 aus.



Abb. 4-17: Konfiguration Write-Fenster

4.2 Skripte

4.2.1 Skripte schreiben

Funktionseditor Skripte können wie Funktionen mit dem Funktionseditor (siehe Abschnitt Funktionseditor auf Seite 12) erstellt werden.

Skript neu anlegen:


2. Klicken Sie im Funktionseditor mit der rechten Maustaste in der Baumansicht auf Skripte|Neu oder wählen Sie im Menü Bearbeiten|Neu|Skript.

Der Dialog Skript Eigenschaften öffnet sich.

3. Geben Sie dem Skript den gewünschten Namen und wählen Sie ggf. das Verzeichnis aus. Das Standardverzeichnis für Skripte ist das jeweilige Projektverzeichnis.

4. Wählen Sie den Dateityp aus, z. B. *.cns.



Hinweis: Als Datentyp stehen unter anderem SCR und CNS zur Verfügung. Nach Möglichkeit sollte die Erweiterung CNS gewählt werden, um Verwechslungen mit Windows Bildschirmschonerdateien zu vermeiden. Für .NET-Skripte gibt es weitere Datentypen. Während einer CANape Sitzung wird immer die zuletzt ausgewählten Erweiterung vorgeschlagen.


6. Schreiben Sie im Editorfenster Ihr neues Skript.

Vordefinierte Funktionsgruppen und Codebausteine

Wie beim Schreiben von Funktionen bietet CANape auch hier Codebausteine und verschiedene vordefinierte CASL-Funktionen (in Funktionsgruppen gegliedert) als Hilfe an (siehe Abschnitt Vordefinierte Funktionsgruppen und Codebausteine von CANape auf Seite 17).

IntelliSense Lernen Sie CANape’s IntelliSense kennen! Tippen Sie z. B. den oder die Anfangsbuchstaben einer vordefinierten CASL-Funktion ein. Wählen Sie diese aus der automatisch erscheinenden IntelliSense-Liste aus. Mit <Tab>, <Eingabe> oder Doppelklick mit der linken Maustaste wird die markierte Funktion in das Editorfenster übernommen.

Achten Sie auf die Informationen, die CANape Ihnen zusätzlich über die Funktion einblendet (siehe auch IntelliSense auf Seite 31).

Gerätevariablen in Skript einfügen:

1. Klicken Sie im Kontextmenü des Editorfensters auf Einfügen|Variable|Gerätevariablen und das entsprechende Gerät, z. B. CCPsim.


2. Wählen Sie die gewünschte Variable, z. B. ampl.

3. Bestätigen Sie Ihre Wahl mit einem Doppelklick oder mit Übernehmen.

4. In Ihrem Skript wird Ihre gewählte Gerätevariable geschrieben, z. B.

CCPsim.ampl.

Skript kompilieren und speichern:

1. Wenn Ihr Skript fertig geschrieben ist, kompilieren Sie das Skript über das

Symbol oder den Menüeintrag Kompilieren|Kompilieren.

2. Achten Sie hierbei auf die Nachrichten, welche CANape im Nachrichten-Fenster (Register Output) am unteren Bildschirmrand meldet.

Wenn dort die Nachricht "Das Programm ist kompiliert." erscheint, ist die Syntax Ihres Skripts korrekt. Das rote Kreuz, mit der Ihr Skript in der Baumansicht markiert ist, verschwindet.

Wenn eine Fehlernachricht angezeigt wird, versuchen Sie mithilfe der Meldung den Fehler zu beheben. Das rote Kreuz, mit der Ihr Skript in der Baumansicht markiert ist, bleibt bestehen.

3. Speichern Sie Ihr Skript mit oder über Datei|Speichern.

Jedes Skript wird als gleichnamige Datei mit der zuvor gewählten Erweiterung im Arbeitsverzeichnis abgelegt. Das Sternchen, mit der Ihr Skript in der Baumansicht markiert ist, verschwindet. Auch nicht kompilierte Skripte können so gespeichert werden.




Hinweis: Beachten Sie beim Schreiben, dass Skripte in CANape einer eher geringen

Prozesspriorität unterliegen. Sie werden lediglich alle 100 ms garantiert ausgeführt.

4.2.2 Skripte speichern und weitergeben (exportieren/importieren)

Speichern Die erstellten Skripte werden automatisch im Arbeitsverzeichnis als Skriptdatei abgelegt. Weitere Verzeichnisse können Sie im Funktionseditor hinzufügen. Den Dateityp der Skriptdatei haben Sie bei der Neuanlage des Skriptes bereits ausgewählt.

Exportieren/ Importieren

Skripte lassen sich aus dem Funktionseditor heraus exportieren und auch in diesen hinein importieren.

Formate Skripte werden im jeweiligen Skriptformat (z. B. *.scr) oder HTML-Format (*.html

oder *.htm) exportiert.

Skripte müssen im Skriptformat vorliegen (*.scr oder *.cns) vorliegen, damit sie

importiert werden können.

4.2.3 Task-Manager

Skripte starten Der Task-Manager bietet Ihnen die Möglichkeit, Skripte automatisch und manuell zu starten.

1. Öffnen Sie den Task-Manger über die Anwahl des Symbols (Task-Manager öffnen) oder über das Menü unter Extras|Task-Manager.

Abb. 4-18: Task-Manager

2. Fügen Sie das gewünschte Skript über die Schaltfläche [Einfügen] ein.

3. In der Spalte Startart können Sie zwischen verschiedenen Ereignissen wählen und damit festlegen, wann Ihr Skript gestartet werden soll.



Startarten: > Manuell

> Beim Laden des Projekts (und damit automatisch auch beim Starten von CANape)

> Beim Schließen des Projekts (und damit automatisch auch beim Beenden von CANape)

> Wenn die Messung beendet wird

> Nach Abgleich des Spiegelspeichers

> Beim Laden einer Messdatei

> Beim Aktualisieren einer Messdatei

> Beim Aktivieren, Bewegen und Deaktivieren des Globalen Messcursors

> Wenn eine Messung gestartet wird (die Ausführung des Skriptes wird zeitgleich mit der Messung gestartet)

> Bevor eine Messung gestartet wird (beim Start der Messung wird erst das entsprechende Skript abgearbeitet; wenn das Skript beendet ist, wird die Messung gestartet).

Hinweis: Der Messungsstart verzögert sich also um die Abarbeitungszeit des Skripts.

4. Wenn Sie die Startart Manuell wählen, können Sie das Skript durch Betätigen der Schaltfläche [Starten] ausführen lassen.

5. Wenn Sie ein Skript bearbeiten möchten, markieren Sie es und klicken Sie auf [Bearbeiten].

Der Funktionseditor mit Symbolleiste, Editor- und Meldungsfenster wird geöffnet.

Hinweis: Das geänderte Skript muss vor dem Verlassen des Funktionseditors

kompiliert werden.

6. In der Spalte current_device= kann ausgewählt werden, für welches Gerät in der Gerätekonfiguration das Skript ausgeführt werden soll.

Wenn im Skript der universelle Gerätepräfix current_device verwendet wird und in der Spalte der Eintrag <none> (Standardeintrag) steht, erscheint beim Starten des Skripts ein Dialog, in dem das Gerät ausgewählt werden muss.

Hinweis: Skripte mit der gleichen automatischen Startart (z. B. "Beim Start der Messung") werden nacheinander in der Reihenfolge gestartet, in der sie im Task-Manager stehen.

Für Skripte, die unabhängig voneinander abgearbeitet werden, besteht darin kein Problem.

Wenn aber ein Skript erst gestartet werden soll, wenn zuvor ein anderes Skript beendet wurde, (z. B. ein Skript initialisiert Variablen und das nächste Skript verwendet diese initialisierten Variablen), so sollte im Task-Manager ein Hauptskript

aufgerufen werden, das über die Funktion CallScript() nacheinander die

einzelnen Skripte abarbeitet (siehe auch Abschnitt Aufruf von Skripten auf Seite 55).

ms-its:syntax49.chm::/topics/HID_current_device.htm

mk:@MSITStore:D:/Programme/CANape/11/SP3/Exec/CANape49.chm::/topics/kDlgSelectCurrentDevice.htm



Achtung: Wenn eine Wertezuweisung über Skripte erfolgt (z. B. ampl=4) so wird

diese Änderung im Onlinemodus sofort wirksam, auch wenn die Direktverstellung nicht aktiviert ist (im Menu Verstellen|Direktverstellung). Um offline zu gehen klicken Sie im Menü Verstellen|Gehe offline.

4.2.4 Aufruf von Skripten

Mehrere Möglichkeiten

Skripte können in CANape auf verschiedene Arten aufgerufen werden. Sie können:

> Ein Skript über das Hauptmenü von CANape ausführen, siehe Seite 55

> Ein Skript über den Task-Manager aufrufen, siehe Seite 55

> Ein Skript aus dem Funktionseditor heraus ausführen, siehe Seite 56

> Ein Skript aus einem anderen Skript heraus aufrufen, siehe Seite 56

> Ein Skript durch ein Steuerelement aus einem Panel heraus aufrufen, siehe Seite 57

> Ein Skript bei der Ausführung von CANape aufrufen, siehe Abschnitt Skriptverhalten bei Ausführung von CANape auf Seite 60

Write-Fenster In einem Write-Fenster können Sie die entsprechend des Skripts ausgeführten Kommandos, Statusmeldungen und Fehlermeldungen des Treibers sowie Werte von Funktionen und Skripten verfolgen.

Write-Fenster öffnen:

1. Öffnen Sie das Write-Fenster über das Hauptmenü Anzeige|Sonstige Fenster|Write-Fenster.

4.2.4.1 Ein Skript über das Hauptmenü von CANape ausführen

Ziel Sie können Skripte direkt über das Hauptmenü von CANape ausführen.

1. Wählen Sie im Menü Extras|Skript ausführen.


2. Wählen Sie die gewünschte Skriptdatei, z. B. Skript_1.cns.


4. Das Skript wird ausgeführt.

Achtung: Wenn eine Wertezuweisung über Skripte erfolgt (z. B. ampl=4) so wird

diese Änderung im Onlinemodus sofort wirksam, auch wenn die Direktverstellung nicht aktiviert ist (im Menu Verstellen|Direktverstellung). Um offline zu gehen klicken Sie im Menü Verstellen|Gehe offline.

4.2.4.2 Ein Skript über den Task-Manager aufrufen

Ziel Sie können Skripte mir der Startart manuell direkt aus dem Task-Manager heraus aufrufen.

Da Sie aus dem Task-Manager heraus auch den Funktionseditor öffnen können, haben Sie dann dort ebenfalls die Möglichkeit ein Skript aufzurufen.



1. Öffnen Sie den Task-Manger über die Anwahl des Symbols (Task-Manager öffnen) oder über das Menü unter Extras|Task Manager.

2. Fügen Sie das gewünschte Skript über den Button [Einfügen] ein.

3. Wenn Sie die Startart Manuell gewählt haben, können Sie das Skript durch betätigen der Schaltfläche [Starten] ausführen lassen.

oder

Wenn Sie eine automatische Startart gewählt haben, können Sie mit der Schaltfläche [Bearbeiten] den Funktionseditor öffnen und darüber das Skript aufrufen (siehe Abschnitt Ein Skript aus dem Funktionseditor heraus ausführen auf Seite 56).

4.2.4.3 Ein Skript aus dem Funktionseditor heraus ausführen

Ziel Ein erstelltes Skript können Sie direkt nach dem Kompilieren aus dem Funktionseditor heraus ausführen.


2. Markieren Sie in der Baumansicht das auszuführende Skript.

3. Klicken Sie auf das Symbol oder wählen Sie im Menü Debug|Skript ausführen, um das Skript auszuführen.

4.2.4.4 Ein Skript aus einem anderen Skript heraus aufrufen

Ziel Sie können ein Unterskript von einem Hauptskript aus aufrufen.

Vorteil Dies bietet sich vor allem dann an, wenn Sie eine bestimmte chronologische Abfolge Ihrer Befehle sicherstellen möchten

Beispiel: Im nachfolgenden Beispiel sehen Sie, wie hierbei Rückgabewerte an das

Hauptskript zurückgegeben werden können:

SubSkript.cns:

Double Result=0;

Result++;

Write("Result SubSkript: %d", Result);

return Result

MainSkript.cns:

Double Result;

int i;

ClearWriteWindow();

for (i=0; i<=10;i++)

{

Result=CallScript("SubSkript.cns",true);

Write("Result MainSkript: %d", Result);

}



Beispiel: In folgenden Beispiel sehen Sie, wie an das Unterskript Argumente/Parameter übergeben werden können:

SubSkriptWithArguments.cns:

long i, nArgs;

char argBuffer[256];

nArgs = GetArgCnt();

Write("Number of specified arguments: %d", nArgs);

for(i = 0; i < nArgs; i++)

{

GetArg(i, argBuffer);//Get the i. script argument

Write("Argument %d: %s", i+1, argBuffer);

}

MainSkript.cns:

CallScriptEx("SubSkriptWithArguments.cns", "Argument_1

Argument_2 Argument_3");

Sollten die Argumente Leerzeichen oder Pfade enthalten, so müssen diese wie folgt übergeben werden:

MainSkript.cns:

CallScriptEx("SubSkriptWithArguments.cns",

"MyFirstArgument \"My argument containing spaces\" \"C:\\My

Path\\My Data File.dat\"");

4.2.4.5 Ein Skript durch ein Steuerelement aus einem Panel heraus aufrufen

Ziel Skripte lassen sich auch durch Steuerelemente, wie z. B. einem Button, in CANape starten.

Voraussetzung Sie müssen jedoch zunächst ein Panel erstellen oder ein vorhandenes Panel in CANape einfügen.

Ein Panel erstellen:

1. Klicken Sie auf das Symbol oder auf das Menü Extras|Panel Designer.

Das Fenster des Vector Panel Designers öffnet sich. Es besteht aus der Symbolleiste, der Panel-Ansicht, der Toolbox, den Eigenschaften und dem Ausgabefenster.

2. Ziehen Sie per Drag & Drop das Steuerelement Button von der Toolbox auf die Panel-Fläche.

3. Legen Sie unter Eigenschaften den Text fest, der auf dem Button angezeigt werden soll, z. B. "Skript ausführen".



Abb. 4-19: Fenster des Vector Panel Designers

4. Klicken Sie auf den Link Label zuweisen.

Der Dialog Label definieren öffnet sich.

5. Tragen Sie unter Label den Namen für das Steuerelement ein, z. B.

Skriptstart.

6. Bestätigen Sie Ihre Eingabe mit [OK].

7. Speichern Sie das Panel unter dem gewünschten Namen und im gewünschten Verzeichnis.

8. Schließen Sie den Panel Designer.

Nun können Sie das Panel in CANape einfügen, siehe Vorhandenes Panel einfügen.

Vorhandenes Panel einfügen:

1. Wählen Sie Anzeige|Sonstige Fenster|Panel-Fenster.


2. Wählen Sie Ihre Panel-Datei aus, z. B. Panel1.xvp.




Der Dialog Verknüpfungen öffnet sich.

Hier werden die einzelnen Steuerelemente des Panels mit den entsprechenden Datenobjekten verknüpft.

Abb. 4 24: Dialog Verknüpfungen

4. Öffnen Sie das Kontextmenü des Steuerelements Skriptstart und wählen Sie

dort Verknüpfen mit Skript.

oder

Wählen Sie im Register Verknüpfungen das Menü Skript|Verknüpfen mit Skript.

Ein Editorfenster öffnet sich.

5. Wählen Sie das Skript, welches bei Betätigung des Steuerelements

Skriptstart ausgeführt werden soll, z. B. Skript_1.cns.


Im Dialog Verknüpfungen wird nun das ausgewählte Skript in der entsprechenden Spalte angezeigt.

7. Bestätigen Sie die angelegte Verknüpfung mit [OK].

8. Wenn Sie nun im Panel-Fenster auf Ihren Button klicken wird Ihr Skript ausgeführt.

Änderung der Skriptzuweisung

Sie können die Skriptzuweisung jederzeit ändern. klicken Sie mit der rechten Maustaste auf Ihr Panel und wählen Datenobjekte verknüpfen.

9. Klicken Sie dazu mit der rechten Maustaste auf Ihr Panel und wählen Sie Datenobjekte verknüpfen.

Der Dialog Verknüpfungen öffnet sich. Über das Kontextmenü des Steuerelements oder das Menü Skript können Sie Ihre Skriptzuweisung ändern.



4.2.5 Skriptverhalten bei Ausführung von CANape

Kommandozeilen-Optionen

Drei verschiedene CANape Kommandozeilen-Optionen konfigurieren das Skriptverhalten bei der Ausführung von CANape. Diese Optionen können dem Ziel in dem Eigenschaften-Dialog der Verknüpfung, die zum Starten von CANape verwendet wird, hinzugefügt werden.

Syntax canape32.exe [Optionen] [Datei]

-b Skriptdatei <*.scr> Startet die angegebene Skriptdatei (Batch-Modus).

-bc Skriptdatei <*.scr> Skriptargument

Startet die angegebene Skriptdatei mit den angegebenen Argumenten (Batch-Modus).

-PATH SCR "path" Setzt den Pfad, aus dem Skriptdateien zur sofortigen Ausführung ausgewählt werden.

Hinweis: Der Pfad ("path") muss in Anführungszeichen geschrieben werden, wenn er Leerzeichen enthält. Er kann absolut oder relativ zum aktuellen Arbeitsverzeichnis (dem Projektverzeichnis) angegeben werden.

4.2.6 Debuggen von Skripten

Ziel Zum Diagnostizieren und Auffinden von logischen Fehlern in benutzerdefinierten Skripten empfehlen wir Ihnen das Debuggen von Skripten.

Breakpoints Um Skripte nur bis zu einer bestimmten Codezeile ausführen zu lassen, können Sie im Funktionseditor sogenannte "Breakpoints" setzen.

Im Reiter Breakpoints des Meldungsfensters werden alle gesetzten Breakpoints angezeigt. Über das Kontextmenü können Sie Breakpoints löschen, aktivieren/deaktivieren oder zum entsprechenden Quelltext navigieren.

Während des Debuggens können Sie dann alle Werte Ihrer Variablen im Reiter Variables des Meldungsfensters inspizieren.

Breakpoints setzen

1. Einen Breakpoint können Sie im Funktionseditor mittels Mausklick auf der linken Seite (graue Spalte) des Editorfensters setzen.

oder

Setzen Sie den Cursor in die gewünschte Zeile, in welcher ein Breakpoint gesetzt werden soll, und wählen Sie das Symbol (Toggle Breakpoint on current line) an.



Abb. 4-20: Breakpoint im Editorfenster

Debuggen

2. Um das Skript bis (einschließlich) zum Breakpoint auszuführen, klicken Sie auf

das Symbol (Start Debugging current script).

3. Zum Beenden des Skripts wählen Sie einfach (Stop Script).

4. Mit (Step In) gehen Sie jede einzelne Zeile Ihres Programmes durch.

Der Debugger springt dann auch in aufgerufene Skripte und Funktionen hinein.

5. Diese können Sie mit dem Icon (Step Out) wieder verlassen.

6. Benutzen Sie hingegen (Step Over), wenn Sie die Details eines Skripts oder einer Funktion, welche(s) Sie von Ihrem darüber liegenden Hauptskript aus aufrufen, nicht interessieren.

4.2.7 Beispielskripte

Einfache Beispiele Im Folgenden ein paar einfache Beispiele, die vielfach verwendet werden können:

> Parametersatz laden:

CCPsim.LoadParameterset()

> Messung Start/Stopp:

Start();

Stop();

> Messen und Kalibrieren:

x = CCPsim.ampl;



CCPsim.ampl = x;

> E-Mail versenden:

SendMail();

> CAN-Botschaften senden:

<Device>.SendMessage(0x1a1,0xff,0x7f)

Beispiel 1: In dem folgenden Skript werden automatisch nach dem Laden des

Projekts CCP Demo sequentiell folgende Anweisungen durchgeführt:

1. Messung starten.

2. Sekunden nach Messungsstart wird der Parameter PWM_Level auf 5 Volt

kalibriert.

3. Nach weiteren 3 Sekunden stoppt die Messung.

Start();

Sleep(5000);

CCPsim.PWM_Level=5;

Sleep(3000);

Stop();

Beispiel 2: In dem folgenden Skript werden automatisch nach dem Laden des

Projekts CCP Demo sequentiell folgende Anweisungen durchgeführt:

1. Write-Fenster öffnen und leeren.

2. Der Wert des Parameters ampl wird zyklisch erhöht bis er einen vordefinierten

Grenzwert erreicht.

Dieser Grenzwert ist in der globalen Variable MaxValue definiert. Der Wert kann

außerdem zur Laufzeit der Messung in einem Verstell-Fenster verändert werden.

3. Bei Erreichen des Grenzwertes Parameter auf 1 zurücksetzen.

//Prepare the Write window

OpenWriteWindow();

ClearWriteWindow();

//Endless loop

while (1==1){

//Check if the value of the global variable MaxValue is

between 0 and 50.

if (MaxValue < 0 || MaxValue > 50) MaxValue = 10;

//Increment the parameter ampl from device ccpsim by step 1

//if the current value is less than the value of MaxValue

if (CCPsim.ampl >= MaxValue)

{

CCPsim.ampl = 0;

Write("MaxValue reset on 0, real value:%d", CCPsim.ampl);

}



CCPsim.ampl = CCPsim.ampl+1;

//Wait 1 s

Sleep (1000);

}

Weitere Beispielskripte

Weitere Beispielskripte liefert CANape in den verschiedenen Demos mit. Diese werden nach Öffnen der jeweiligen Demo im Funktionseditor in der Baumansicht unter Skripte angezeigt.

4.3 Variablen

4.3.1 Erstellen einer globalen Variablen


2. Wählen Sie in der Baumansicht Globale Variablen den Kontextmenübefehl Neu.

Der Dialog Variable öffnet sich.

3. Geben Sie der Variable den gewünschten Namen, z. B. gVarDouble, und

ordnen Sie dieser den gewünschten Datentyp sowie weitere Eigenschaften zu.


Der Dialog Variable schließt sich und die neu angelegte Variable wird in der Baumansicht angezeigt.

5. Nachdem Sie die Variable gespeichert haben, wird diese nicht mehr mit einem * markiert.


Ihre globale Variable wird auch im Symbol Explorer in der Baumansicht unter Geräte|Globale Variablen angezeigt.

4.3.2 Globale Variable auf definierten Wert setzen

Wert definieren Sie können beeinflussen, wann die globale Variable auf einen definierten Wert gesetzt werden soll.

Möchten Sie z. B. bei Messungsstart Ihre globale Variable auf einen bestimmten Wert zurücksetzen oder initialisieren, so können Sie

> sich eine eigene Funktion (z. B. Reset_gVarDouble()) schreiben oder

> ein Skript ausführen.

Initialisieren mithilfe eigener Funktion:

1. Legen Sie im Editorfenster die Beispielfunktion Reset_gVarDouble wie folgt an

(siehe auch Abschnitt Funktionen schreiben auf Seite 31):



function Reset_gVarDouble()

{

// Geben Sie hier den Code ein

gVarDouble = 0;

Write("Die globale Variable gVarDouble wurde auf den

Wert %f geändert.",gVarDouble);

return;

}

2. Kompilieren Sie die Funktion mit und speichern Sie diese.

3. Ziehen Sie die globale Variable gVarDouble vom Symbol Explorer (Abschnitt

Geräte|Globale Variablen) auf eine freie Fläche einer Anzeigeseite.

Die möglichen Anzeige- und Verstell-Fenster werden zur Auswahl gestellt.

4. Wählen Sie Default-Fenster.

Ein Verstell-Fenster mit der globalen Variablen gVarDouble und dem Wert 0

wird angezeigt.

5. Öffnen Sie die Messkonfiguration über <F4>, das Symbol oder über den Menüeintrag Messen|Messkonfiguration.

6. Wählen Sie im Kontextmenü Funktion einfügen.


7. Klicken Sie auf die Schaltfläche [Auswahl].

Eine Auswahl der Funktionsdefinition öffnet sich.

8. Wählen Sie gVarDouble und bestätigen Sie Ihre Wahl mit Doppelklick oder

[OK].

9. Schließen Sie den Dialog Funktion mit [OK].

10. Stellen Sie in der Messkonfiguration den Messmodus Ihrer Funktion auf on

event 'MeasurementStart'.

11. Schließen Sie die Messkonfiguration mit .

12. Setzen Sie den Wert Ihrer globalen Variable gVarDouble im Verstell-Fenster auf

z. B. 4 (mit Doppelklick in die Zelle gehen, Wert ändern und <Eingabe>) .

13. Starten Sie eine Messung mit .

Der Wert Ihrer globalen Variable gVarDouble im Verstell-Fenster wird auf 0

initialisiert.

Abb. 4-21: Verstell-Fenster mit verändertem Wert = 4 Abb. 4-22: Verstell-Fenster mit initialisiertem Wert

Initialisieren mithilfe eines Skriptes:

1. Legen Sie im Editorfenster das Beispielskript Reset_gVarDouble wie folgt an

(siehe auch Abschnitt Skripte schreiben auf Seite 51):



gVarDouble = 0;

Write("Die globale Variable gVarDouble wurde auf den

Wert %f geändert.",gVarDouble);

2. Kompilieren Sie das Skript mit und speichern Sie es.

3. Legen Sie ein Verstell-Fenster mit der globale Variable gVarDouble an

(s. Handlungsschritte 3 bis 4, oben).

4. Legen Sie zur besseren Beobachtung über Anzeige|Sonstige Fenster|Write-Fenster ebenfalls ein Write-Fenster an.

5. Öffnen Sie den Task-Manager über das Symbol und fügen Sie mit [Einfügen]

das neu angelegte Skript Reset_gVarDouble ein (siehe auch Abschnitt Task-

Manager auf Seite 53).

6. Setzen Sie die Startart des Skripts auf Vor der Messung.

7. Markieren Sie das Skript Reset_gVarDouble und klicken Sie auf [Starten].

Das Skript wird ausgeführt. Der Wert Ihrer globalen Variable gVarDouble im

Verstell-Fenster wird auf 0 initialisiert.

Abb. 4-23: Anzeige des Write-Fensters nach Ausführung des Skripts Reset_gVarDouble

Hinweis: Mittels der vordefinierten CASL-Funktion der Funktionsgruppe "Programm-

Funktionen" UpdateCalibrationWindows() können Sie die Startwerte auch

gleich automatisch in den Verstell-Fenstern anzeigen lassen.

4.3.3 Lokale Variable auf definierten Wert setzen

Unterschiedliche Startwerte

Wenn eine Funktion z. B. in der Data-Mining-Umgebung oder als virtueller Messdateikanal verwendet wird, gibt es in CANape die Möglichkeit, jeder Instanz einer Funktion einen unterschiedlichen Startwert einer lokalen Variable zuzuordnen. Hierfür kann auch ein Kommentar angegeben werden, der unter den Eigenschaften der Funktion später zu sehen ist (siehe Abschnitt Funktionen schreiben auf Seite 31).

Beispiel: Als Beispiel dazu dient die Bibliothek-Funktion MovingAverage() von

CANape:

function MovingAverage(var signal)

{

//! number of last measure values to be used for the

calculation

int smoothFactor = 4;

....

//! Hier wird der lokalen Variable smoothFactor zunächst der Wert 4 zugeordnet.

Durch das Voranführen von //! kann diese Variable in den Eigenschaften z. B. eines

virtuellen Messdateikanals mit einem anderen Startwert belegt werden. Alle Zeichen,



die nach //! erscheinen, sind ebenfalls in den Eigenschaften als Information zu

sehen.

Anderen Startwert setzen (wenn Funktion als virtueller Messdateikanal verwendet wird):

1. Ziehen Sie die die Bibliothek-Funktion MovingAverage() per Drag & Drop auf

eine leere Fläche einer Anzeigeseite.

Die möglichen Anzeige- und Verstell-Fenster werden zur Auswahl gestellt.

2. Wählen Sie Default-Fenster.

Ein Grafik-Fenster wird angezeigt und Virtueller Messdateikanal und Messfunktion zur Auswahl gestellt.

3. Klicken Sie auf Virtueller Messdateikanal.

Der virtuelle Messdateikanal wird im Grafik-Fenster angezeigt. Der Funktion ist jedoch noch kein Eingangssignal zugeordnet.

4. Wählen Sie im Kontextmenü des Grafik-Fensters Eigenschaften.

Der Dialog Eigenschaften öffnet sich.

5. Markieren Sie die Zeile für das Eingangssignal und klicken Sie auf [Manuell verknüpfen].

6. Wählen Sie im aufpoppenden Dialog Manuell verknüpfen XCPsim.

7. Bestätigen Sie Ihre Wahl mit einem Doppelklick oder [OK].


8. Wählen Sie das Messsignal channel1.


das Symbol .

10. Markieren Sie nun im Dialog Eigenschaften die Zeile mit dem

Funktionsparameter smoothFactor und klicken Sie auf [Parameterwert

ändern].

11. Geben Sie in dem aufpoppenden Dialog den neuen Wert für die Initialisierung ein, z.B. 10.

12. Bestätigen Sie Ihre Eingabe mit [OK].

13. Bestätigen Sie Ihre Änderungen im Dialog Eigenschaften mit [OK].



Abb. 4-24: Der lokalen Variable smoothFactor wird hier ein Startwert von 10 zugewiesen.



4.3.4 Gerätevariable einfügen


2. Wählen Sie im Kontextmenü des Editorfenster des Funktionseditors Gerätevariablen.

Die angelegten Geräte werden angezeigt, z.B. CCPsim.

3. Klicken Sie auf das gewünschte Gerät CCPsim.

Die Datenbasis-Auswahl des Geräts mit den zur Verfügung stehenden Gerätevariablen öffnet sich.

4. Wählen Sie die gewünschte Gerätevariable mit einem Doppelklick aus.

5. Beenden Sie die Datenbasis-Auswahl mit .

In der Funktion/im Skript steht die eingefügte Gerätevariable wie folgt:

<DeviceName>.<VariableName>.

Hinweis: Enthält der Variablenbezeichner einen oder mehrere Punkte, so muss der Bezeichnerstring in einfache Anführungszeichen gesetzt werden, z.B. KWPsim.'ECU_Identification.Ident_Digit_1_0'

Zugriff bei mehrmaliger Verwendung

Wenn in einer DBC-Datei ein CAN-Signal mehrmals aufgeführt ist, kann mit einem Skript oder einer Funktion darauf zugegriffen werden:

value = <CANdevice>.'$<CAN message name>$<signal>';

Handbuch CANape CASL Allgemeine Tipps


5 Allgemeine Tipps


5.1 Richtiges Beenden von Funktionen und Skripte Seite 70

5.2 Zugriff auf Systeminformationen Seite 70



5.1 Richtiges Beenden von Funktionen und Skripte

Beenden mit cancel Wenn z. B. ein Parameter einen bestimmten Wert erreicht hat, kann über die

Kontrollstruktur cancel eine Funktion oder Skript beendet werden.

Wenn der Befehl cancel in einer Funktion verwendet wird, wird die Funktion ohne

Rückgabewert abgebrochen. Die Kontrolle wird zurück an die aufrufende Routine übergeben.

Wenn der Befehl cancel in einer Subfunktion oder in einem Skript verwendet wird,

wird das Skript sofort beendet.

Beispiel: Wenn in der aufgerufenen Dialogbox [Yes] gewählt wird (Rückgabewert ist

0), wird das Skript beendet.

long result;

result = UserQueryDialog ("Yes | No", /*buttons*/

0, /*question*/ "Do you want to cancel the script?");

if (result == 0)

{

cancel;

}

print("Continue...");

Beenden mit break Der break-Befehl bricht eine Schleife (for oder while) oder eine switch-

Anweisung sofort ab.

Beispiel: Der break-Befehl bricht eine for-Schleife ab.

// break

long i;

for (i = 0; i < 15; i++)

{

if (i == 10)

{

break;

}

}

Write("i = %d", i);

5.2 Zugriff auf Systeminformationen

Gerät System In CANape gibt es die Möglichkeit, Systeminformationen in Skripten zu verwenden. Dazu muss die entsprechende Option aktiviert werden. Diese Option bewirkt, dass

ein Gerät System mit verschiedensten Systemvariablen angelegt wird.

Nutzen Sie können so einzelne Variablen des Systems in Skripten verwenden.



Systeminformationen aktivieren:

1. Klicken Sie im Hauptmenü auf Extras|Optionen.

Der Optionen-Dialog öffnet sich.

2. Wählen Sie in der Baumansicht des Optionen-Dialoges Sonstiges|Systeminformationen.

3. Aktivieren Sie auf der rechten Seite des Dialoges das Kontrollfeld der Systeminformationen.

In der Gerätekonfiguration wird ein Gerät mit dem Namen System angelegt.

Dieses Gerät ist nur in der Listendarstellung auf der rechten Seite aufgeführt, nicht in der Baumdarstellung links.

Das Gerät wird auch im Symbol Explorer angezeigt.

Beispiel 1: Ausgabe von Systeminformationen im Skript

Write("%s",System.'Windows.User.UserDisplayName' );

Write("%s",System.'Windows.User.UserLoginName' );

Beispiel 2: Im Messdateinamen können Sie ein Makro verwenden, welches ein

Skript evaluiert. Das Skript könnte dann wie folgt aussehen:

char buffer[100];

SPrint(buffer, System.'Windows.User.UserDisplayName');

SetScriptResult ("%s", buffer);

Handbuch CANape CASL Adressen


6 Adressen

Vector Knowledge Base

Kurze Artikel zu verschiedenen Fragestellungen finden Sie in der Vector Knowledge Base unter:

http://www.vector.com/vi_knowledgebase_en.html

Adressen auf Vector Homepage

Die Kontaktadressen der Vector Informatik GmbH und ihrer Töchter weltweit finden Sie unter:

http://www.vector.com/vi_adressen_de.html

http://www.vector.com/vi_knowledgebase_en.html

Handbuch CANape CASL Glossar


7 Glossar

Argument Beim Aufruf einer Funktion können der Funktion (Kommandozeilen-)Argumente übergeben werden.

Array Ein Array ist ein Feld aus Variablen gleichen Typs.

ASCII ASCII ist die Abkürzung für American Standard Code for Information Interchange. Es stellt das Standardverfahren zur Codierung alphabetischer, numerischer und Steuerzeichen in 7-bit-Form dar.

CASL CANape verwendet eine eigene Skriptsprache, die auch CASL (Calculation and Scripting Language) genannt wird.

debuggen Diagnostizieren und Auffinden von logischen Fehlern

Funktion Eine Funktion wird durch Ereignisse getriggert gestartet und synchron während einer Messung abgearbeitet.

Funktionsparameter Argumente und Übergabeparameter werden im allgemeinen Wortlaut auch einfach als Funktionsparameter bezeichnet.

Globale Variable Globale Variablen sind spezielle Datenobjekte, die in der CANape Konfiguration von allen Funktionen und Skripten genutzt werden können.

kompilieren Ein Compiler übersetzt den von Menschen lesbaren Quelltext in die für den Computer verständliche Maschinensprache. Beim Kompilieren werden Syntaxfehler entdeckt.

Kontrollstruktur Die Abarbeitungsreihenfolge von Anweisungen wird Kontrollfluss genannt. Eine Anweisung, die diesen Kontrollfluss beeinflusst, nennt man daher auch Kontrollstruktur.

Lokale Variable Lokale Variablen sind nur innerhalb der jeweiligen Funktion oder des jeweiligen Skriptes gültig.

MDF-Datei MDF steht für Mess-Daten-Format. Das MDF-Format ist ein binäres Dateiformat zum Speichern von Messdaten. CANape speichert die gemessenen Daten in diesem Format ab. Daher spricht man auch oft von der Messdatei, was ein Synonym für die MDF-Datei ist.

Messfunktion Unter einer Messfunktion wird die Kombination Funktion + Messparameter verstanden. Messfunktionen werden unter Messsignal|Funktionen in der Baumansicht der Messkonfiguration angezeigt.

Parameter-Typen In der Syntax der Funktionen gibt es verschiedenen Typen von Parametern zur Übergabe von Daten.

Precompiler Präprozessor

Skript Ein Skript kann unabhängig von einer laufenden Messung gestartet werden, es kann extern aufgerufen werden und wird parallel zu einer Messung ausgeführt.

Übergabeparameter Beim Aufruf einer Funktion können der Funktion Übergabeparameter übergeben werden.

virtueller Messdateikanal

Von einem virtuellen Messdateikanal spricht man, wenn ein scheinbar echtes (virtuelles) Signal aus Messwerten bereits abgespeicherter Messungen genutzt werden soll.

Handbuch CANape CASL Index


8 Index

A

Array-Parameter 17

B

Bibliothek-Funktionen 46

Breakpoints setzen 60

D

DLL-Bibliothek einbinden 48

F

Funktion anlegen 31

aufrufen 34

debuggen 48

exportieren 33

importieren 32

kompilieren 32

schreiben 31

speichern 32

Funktionseditor 12 Oberfläche 13

öffnen 12

Funktionstypen 10

G

Gerätevariable einfügen 68

Einführung 16

Globale Funktionsbibliothek 46

Globale Variable erstellen 63

initialisieren (mithilfe eigener Funktion) 63

initialisieren (mithilfe eines Skriptes) 64

K

Kommandozeilen-Optionen 60

L

Lokale Variable

Startwert setzen 66

M

Messfunktion erstellen 36

P

Panel einfügen 58

erstellen 57

Parametertypen 17

Platzhalter 24 Feldbreite 25

Flag 25

Genauigkeit 25

Typ 24

S

Skalare Parameter 17

Skript aufrufen 55

debuggen 60

Gerätevariable einfügen 52

importieren/exportieren 53

kompilieren 52

neu anlegen 51

schreiben 51

speichern 52, 53

starten 53

Startarten 54

Systeminformationen aktivieren 71

T

Task-Manager 53

V

Vektor-Element 23

vektorielle Variable 23

Vektor-Variable 23

Virtuellen Messdateikanal anlegen 35

Handbuch CANape CASL Index


W Write-Fenster öffnen 55

Möchten Sie weitere Informationen!

Besuchen Sie unsere Internetseite:

> Neues

> Produkte

> Demo Software

> Support

> Schulungen

> Adressen

www.vector.com

http://www.vector-worldwide.com/

handbuch canape casl - vector...4.2.3 task-manager 53 4.2.4 aufruf von skripten 55 4.2.5...

Documents