Interpret-Funktionen
Nach oben Vorwärts

Hauptmenü Konvert Strings Allgemein TypeInfo Arithmetik Aggregat Operatoren

1.Vorrangsstufe

Konvertierungsfunktionen
Funktion Erklärung Beispiel Ergebnis
int atoi( char[] )   ascii to integer   i = atoi ( "123");   i = 123
char itoa( char[], int, int iBasis) integer to ascii   char s[10];
itoa ( s, 123, 10 );  
s = "123"
Vorsicht: Länge von Variable s muß 1 Zeichen größer sein als Länge des zu konvertierenden Wertes
double atof(char[])   ascii to float   f = atof ( "1.23" );   f = 1.23
void ftoa(char[], double, int iP)   float to ascii mit Präzision iP char s[10];
ftoa ( s, 1.23, 7);  
s = 1.2300000
iPrec: Anzahl gültige Ziffern (excl. Vorzeichen, Dezimalpunkt)
Vorsicht: Länge von Variable s muß 3 Zeichen größer sein als Länge des zu konvertierenden Wertes
double itof( int)   integer to float   double d;
d = itof ( 77 );  
d = 77.000
int ftoi( double)   float to integer   int i; i = ftoi ( 99.99 );   i = 99
int ctoi( char)   char to integer (-128..127) i=ctoi( '¦' ); i = -90
char itoc( int)   integer to char   char c;
init { c = itoc ( 99 ); }  
c='c'
int uctoi( char c)    unsigned char to integer i=uctoi( '¦' ); i=166
ftobstr( double, char[])   float to binary string   double f;
char e[4];
ftobstr(f,e);
 
double bstrtof( char[]) binary-string to float   double f;
char e[4];
f=bstrtof(e);
-

Beispiel:  
input trigger dI( "TYPEINFO", "TypeInfo", "DOUBLE[1]", "TIME_DOMAIN" );
input trigger cI( "TYPEINFO", "TypeInfo", "UBYTE[]", "TIME_DOMAIN" );
output        dO( "TYPEINFO", "TypeInfo", "DOUBLE[]", "TIME_DOMAIN" );

double f; char e[4]; char o[1];
execute
{
f = dI[0];
ftobstr( f, e ); // float to binary-string
f=bstrtof(e); // binary-string to float
dO << f;
f = bstrtof(cI);
dO << f;
}

Funktionen für Zeichenketten
Funktion Aktion Ergebnis Beispiel
char d[20]; d="123456.123";
char s[100]; s="abc";
int i; char c;
char strcpy
( char[]
d, char[] s)
String kopieren   liefert  Länge von Dest (incl. '\0') d="123456.123"; s="abc"; i=strcpy(d,s); // d="abc",   i=4
char strcat( char[] d, char[] s) String anfügen   Zeichenkette um 1 Zeichen länger wegen '\0' d="123456.123"; s="abc"; i=strcat(d,s); // d="123456.123abc",   i=14
int strcmp( char[] d, char[] s) Strings vergleichen 0, falls d = s
-1, falls d < s (lexikographisch)
1, falls d > s
d="123456.123"; s="abc"; i=strcmp(d,s); //   i=-1
d="123456.123"; s="abc"; i=strcmp(s,d); //  i=1
d="123456.123";  i=strcmp(d,d); //  i=0
int strlen( char[] s)   String-
Länge
Anzahl Zeichen in String (ohne \0) s="abc"; i=strlen(s); //   i=3
int strchr( char[] d, char c) Index-
Suche  
0, falls Charakter nicht in String enthalten, sonst Position (Base 1) d="123456.123"; c='5'; i=strchr(d,c); // i=5
d="123456.123"; c='1'; i=strchr(d,c); // i=1
d="123456.123"; c='9'; i=strchr(d,c); // i=0
int strstr( char[] d, char[] s) Index-
Suche  
0, falls s nicht in d, sonst Startposition (Base 1) d="123456.123"; i=strstr(d,"6.1");   // i=6;
d="123456.123"; i=strstr(d,"1"); // i=1;
d="123456.123"; i=strstr(d,"9.1"); // i=0;
int strncpy( char[] d, int i, char[] s, int c)
Vorsicht: nicht kompatibel mit strncpy von C
s wird auf d kopiert
ab Index i werden c Zeichen kopiert, Ergebnis ist Länge + 1 (\0) d="123456.123"; s="abc"; i=strncpy(d,5,s,6); // d="12345abc",  i=9
d="123456.123"; s="abc"; i=strncpy(d,5,s,2); // d="12345ab123",  i=11

 

Allgemeine Funktionen
Funktion Erklärung Beispiel Ergebnis
Ausgaben in Meldungsfenster ( Signalgraph wartet, bis OK betätigt wird )
print(char[])   String-Ausgabe   print("Test") Test
printInt(int)   Integer-Ausgabe   int i; i=99; printInt(i); Integer: 99
printDbl(double) Double-Ausgabe   double d; d=0.99; printDbl(d); Double: 0.990000
Zeit-Funktionen
double time()   Zeit in ms seit 1970   double t; t = time();   t=919843576387.0
Sleep(int)   Wartezeit in ms   Sleep( 5000 );
printDbl( time() - t );  
Double: 5001.000000
int newdata(in) 1: neue Daten an input in
0: sonst  
input  trigger in("TYPEINFO", "TypeInfo", "SWORD[1]", "BIN");
execute {
if (newdata(in))
MessageBeep(); }
MessageBeep() Signalton  
Arraygrößen einlesen bzw. setzen input in("TYPEINFO", "TypeInfo", "DOUBLE[]","Random");
output out("TYPEINFO", "TypeInfo", "DOUBLE[]","Result");
int i; int ai[10]; double ad[10]; char ac[10];
int size(Arrayname)   Arraygröße einlesen i=size(ai);
i=size(ad);
i=size(ac);
i=size(in);
i=10
i=10
i=10
i=16
int setsize(Arrayname, int iSize)  
Arraygröße setzen
i=setsize(ai, 1000);
i=setsize(ad, 1000);
i=setsize(ac, 1000);
i=setsize(in, 1000);
i=1000
Achtung: um Daten an Ausgänge zu schicken gibt es verschiedene Methoden:
Daten werden nicht verändert:
     out<<in; // Eingangsdaten werden direkt an Ausgang angefügt: schnellste Methode
Daten werden bearbeitet:
     for (i=0; i<size(in); i++) out<<in[i]*0.5; // Eingangsdaten werden einzeln an Ausgang angefügt: langsame Methode
Daten werden bearbeitet, setsize wird verwendet:
     setsize(out,size(in)); for (i=0; i<size(in); i++) out[i]=in[i]*0.5; // Eingangsdaten werden einzeln an Ausgang zugewiesen: schnell, da Speicher bereits allokiert
Daten werden bearbeitet, setsize wird verwendet, Ausgangsvektorlänge ist kleiner als Eingangsvektorlänge:
     len=0;  setsize(out,size(in)); for (i=0; i<size(in); i++) if (...)  out[len++]=in[i]*0.5; setsize(out,len); // Ausgangsvektorlänge wird nach den Zuweisungen korrigiert
Port I/O
int Create_VxD_Sys () Diese Funktion gibt das Handle
auf den Treiber PortIO.vxd unter
Windows 95 bzw. PortIO.sys
unter Windows NT zurück
int handle;
init
{
handle = Create_VxD_Sys ();
}
-1 wenn ungütig und
<> -1 wenn efolgreich
Close_VxD_Sys (handle) Diese Funktion gibt das in
Create_VxD_Sys () zugeordnete
Handle wieder frei
done
{
Close_VxD_Sys (handle)
}
-
int InportByte (handle, Register-Adresse) Diese Funktion ließt aus der
Register-Adresse (als Hex-Wert) ein Byte (8 Bit) aus.
execute
if (handle !=-1)
o << itof (InportByte(handle, 0x303));
}
gelesenes BYTE
int InportWord (handle, Register-Adresse) Diese Funktion ließt aus der
Register-Adresse (als Hex-Wert)
ein WORD (16 Bit) aus.
execute
{
if (handle !=-1)
o << itof (InportWord(handle, 0x303));
}
gelesenes WORD
OutportByte (handle, Register-Adresse, Ausgabe-Wert) An der Register-Adresse
(Hex-Wert) wird der
Ausgabe-Wert als BYTE
ausgegeben
execute
{
if (handle !=-1)
OutportByte (handle, 0x303, ftoi(i[0]));
}
-
OutportWord (handle, Register-Adresse, Ausgabe-Wert) An der Register-Adresse
(Hex-Wert) wird der
Ausgabe-Wert als WORD
ausgegeben
execute
{
if (handle !=-1)
OutportWord (handle, 0x303, ftoi(i[0]));
}
-

       

Typ-Informationen
Begleitinformationen zu Daten: Signalname, Zeitstempel, Samplerate, Bereich, Einheit, Skalierung, Paketstatus, ... ( siehe Modul TIDisp ).
In den Interpret-Modulen ( Interpret, CAN, IEEE488, Profibus, RS232 ) legt der Benutzer die Typ-Informationen fest.
Sie werden von einem Eingang an einen Ausgang kopiert oder einzeln festgelegt.
Funktion Erklärung Beispiel Ergebnis
char name[20]; int i; double d;
input  in ("TYPEINFO","TypeInfo",DOUBLE[]","TIME_DOMAIN");
output out("TYPEINFO","TypeInfo",DOUBLE[]","TIME_DOMAIN");
int ti_getname
(char[], in)
Signalnamen lesen, Ergebnis=Länge des Namens i = ti_getname( name, in );
printInt(i); print(name);
Integer: 6
Random
ti_setname
(char[], out)
  
Signalnamen setzen  ti_setname( "O1", out ); TIDisp-Modul
Signalname: O1
double ti_gettimestamp(in) Zeitstempel lesen
ms ab 1.1.1970, 0:00
d=ti_gettimestamp(in);
printDbl(d);
Double:
919934589929.000000
ti_settimestamp
(double, out)
Zeitstempel setzen
ms ab 1.1.1970, 0:00
ti_settimestamp( d, out );   TIDisp-Modul
TimeStamp: 919934589929
double ti_getsamplerate(in) Abtastrate lesen   d=ti_getsamplerate(in);
printDbl(d);
Double: 16.000000
ti_setsamplerate
(double, out)
Abtastrate setzen   ti_setsamplerate( d, out );    TIDisp-Modul
Samplerate: 16
double ti_getrangemin(in) Bereichsmin. lesen   d = ti_getrangemin( in );
printDbl( d );  
Double: 0.000000
ti_setrangemin
(double,out)
Bereichsmin. setzen   ti_setrangemin( d, out );   TIDisp-Modul
Min.Range: 0
double ti_getrangemax(in) Bereichsmax. lesen   d = ti_getrangemax( in );
printDbl( d );  
Double: 1.000000
ti_setrangemax
(double,out)
Bereichsmax. setzen  ti_setrangemax( d, out );   TIDisp-Modul
Max.Range: 1
int ti_getunit
(char[],in)   
Einheit lesen
Liefert Länge von Einheit
i=ti_getunit(name, in);
printInt(i); print(name)
Integer: 3
Ohm
int ti_setunit( char[], output )   Einheit setzen
1=OK, 0=Fehler
i = ti_setunit( "V A^-1", out );
printInt(i);
TIDisp-Modul
Unit: Ohm
Integer: 1
double
ti_getscale(in)
Skalierung lesen   d=ti_getscale(in);
printDbl(d);  
Double: 1000.000000
ti_setscale
(double,out)
Skalierung setzen ti_setscale(1.0e-6, out );   TIDisp-Modul
Unit: Ohm*1e-006
ti_copy(out,in) Typ-Info kopieren   ti_copy(out,in);   von Ein- an Ausgang
Vorsicht: der Status wird nicht kopiert !!!
int ti_getstatus(in) Paketstatus lesen i=ti_getstatus(in)
printInt(i);
Integer: 0
Integer: 1
...
ti_setstatus(int,out) Paketstatus setzen    ti_setstatus(i,out); TIDisp-Modul
Paketstatus: Start
Paketstatus: Busy
...
Paket, bestehend aus n Blöcken: Block0=Status0 (START), Blöcke1..n-2=Status1 (BUSY), Block n-1=Status 2 (STOP).
Paket, bestehend aus einem Block: Status 3 (KOMPLETT).

 

Arithmetische Funktionen
Funktion Erklärung Beispiel Ergebnis
int i; double d;
double sin(double)   Sinus   d=sin(PI/2) d=1.0
double cos(double) Cosinus   d=cos(PI); d=-1.0
double tan(double) Tangens   d=tan(PI); d=0.0
double asin(double) Arcussinus   d=asin(1.0) d=1.570796
double acos(double) Arcuscosinus   d=acos(-1.0) d=3.141593
double atan(double) Arcustangens   d=atan(0.0) d=0.0
double sinh(double) Hyperbelfunktion sinh   d=sinh(0.0) d=0.0
double cosh(double) Hyperbelfunktion cosh   d=cosh(0.0) d=1.0
double tanh(double) Hyperbelfunktion tanh   d=tanh(0.0) d=0.0
double exp(double) Exponent   d=exp( 2.3);   d=9.974182
double log(double) Logarithmus   d=log(10.0); d=2.302585
double log10(double) Logarithmus zur Basis 10   d=log10(10.0); d=1.0
double pow
(double Base, double Exp)
Potenzfunktion d=pow(2.3,3.0);
d=pow(2.0,3.0);
d=12.167
d=8.0
double sqrt( double )   Wurzel   d=sqrt(4.0); d=2.000000
double floor( double )    nächste kleinere ganze Zahl   d=floor(1.5); d=1.000000
double ceil( double )   nächste größere ganze Zahl   d=ceil(1.5); d=2.000000
int mod( int, int )   Divisionsrest   i=mod(5,2); i=1
double abs( double )   Absolutwert von double-Zahl   d=abs(-10.0); d=10.0
int iabs( int )   Absolutwert von int-Zahl   i=iabs(-10); i=10
double round(double)    rundet ab oder auf   d=round(4.5); d=5.0
double fix(double,int)    rundet auf Anzahl Dezimalstellen   d=fix(1.2345, 3)
d=fix( 12345.678, 3)  
d=1.23
d=12300.0

 

Aggregat Funktionen
Funktion Erklärung Beispiel Ergebnis
  int i; double e;
int a[10];
a[0]=1; a[1]=2; .. a[9]=10;
double d[10];

d[0]=1.0; d[1]=2.0;.. d[9]=10.0;
int minInt(int[])    Minimum aus int-array   i=minInt(a); i=1
int maxInt(int[])    Maximum aus int-array   i=maxInt(a); i=10
double minDbl(double[])    Minimum aus double-array   e=minDbl(d); e=1.0
double maxDbl(double[]) Maximum aus double-array e=maxDbl(d); e=10.0
int mwInt(int[] )    Mittelwert aus int-array
Es wird trunkiert!
i=mwInt(a); i=5
double mwDbl(double[]) Mittelwert aus double-array e=mwDbl(d); e=5.5
int sumInt(int[])    Summe aus int-array   i=sumInt(a); i=55
double sumDbl(double[]) Summe aus double-array   e=sumDbl(d); e=55.0

 

Operatoren
Funktion
Rang-
Stufe
Oper.
Typ
Erklärung
Skalar-
Typ
Ergebnis-
Typ
Beispiel
int i; double d;
char c;
Ergeb-
nis
~   2 unär   Bitweises Komplement int   i=5; i=~i;
i=-10; i=~i;
i=-6
i=9
!   2 unär   logische Negation NOT int   i=9; i=!i;
i=0; i=!i;
i=0
i=1
-   2 unär  unäres Minus int, double   i=22; i=-i; i=-22
++ 2 unär Prä/Post-Inkrementierung int, double   i=-22; i++; i=-21;
--   2 unär Prä-/Post-Dekrementierung int, double   i=-21; i--; i=-22
*   3 binär Multiplikation int, double int: int*int
double: sonst
i=4*3;
d=3.5*2;
i=12
d=7.0
/   3 binär Division int, double int: int/int
double: sonst
i=3/4;
d=3.5/0.5
i=0
d=7.0
%   3 binär Modulo gibt Divisionsrest als Ergebniswert zurück   int   i=20%3;
i=21 % 7;  
i=2
i=0
+   4 binär Addition int, double int: int+int
double: sonst
i=20+3
d=20+3.5
i=23
d=23.5
-   4 binär Subtraktion int, double int: int-int
double: sonst
i=20-3
d=20-3.5
i=17
d=16.5
int iSHR(int,int) 5 shift binärer Rechtsshift eines Skalars (Integer) um n Stellen   int   i=iSHR(1000,2);
i=iSHR(1000,3);
i=250
i=125
int iSHL(int,int) 5 shift binärer Linksshift eines Skalars  (Integer)  um n Stellen   int   i=iSHL(10,2);
i=iSHL(10,3);
i=40:
i=80;
char cSHR(char,int) 5 shift binärer Rechtsshift eines Characters um n Stellen   char   c=cSHL('!',1);
s[0]=c; print(s)
B
char cSHL(char, int) 5 shift binärer Linksshift eines Characters um n Stellen   char   c=cSHR('B',1);
s[0]=c; print(s)
!
<=   6 binär Vergleich int, double, char int if (i<=5)
print("kleiner oder gleich");
<   6 binär Vergleich int, double, char int if (i<5.4)
print("kleiner");
>=   6 binär Vergleich int, double, char int if (i>=5)
print("größer oder gleich");-
>   6 binär Vergleich int, double, char int if (i>5)
print("größer");
==   7 binär Vergleich int, double, char int if (c=='A')
print("gleich");
!=   7 binär Vergleich int, double, char int if (c!='A')
print("ungleich");-
&     8 binär Bitweises AND int   i=13&12; i=12
^    9 binär Bitweises XOR int   i=4^12; i=8
|    10 binär Bitweises OR int   i=3|12; i=15
&&     11 binär Logisches AND int   if ((i==1) && (d>2.34))
print ("O.K.");-
||    12 binär Logisches OR int   if ((i==1) || (d>2.34))
print ("O.K.");
=    13 binär einfache Zuweisung     i=i+12;