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; |
|
|