1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
|
(*
**********************************************************
**********************************************************
** **
** ls-Prozess 2 **
** **
** Version 1.02 **
** **
** (Stand : 06.06.89) **
** **
** **
** **
** Autoren: Bruno Pollok, Bielefeld **
** Wolfgang Weber, Bielefeld **
** **
** **
** Copyright (C) 1988 Eva Latta-Weber, Bielefeld **
** Copyright (C) 1990 ERGOS GmbH, Siegburg **
**********************************************************
**********************************************************
*)
PACKET ls prozess 2 DEFINES
wert an analogausgang ausgeben,
spannungswert ausgeben,
bitsymbol ausgeben,
bitmuster ausgeben,
dezimalwert ausgeben,
bitmuster gleich,
bit ist gesetzt,
wert von analogeingang,
spannungswert,
bitsymbol,
bitmuster,
dezimalwert:
LET eins = "I",
null = "O",
invers = "T",
egal = "X";
REAL CONST maximalwert :: real (ganzzahl obergrenze - 1);
(********************* A U S G A B E - B E F E H L E *********************)
PROC wert an analogausgang ausgeben (INT CONST kanal, wert):
pruefe kanal (kanal, analog aus);
ausgeben (kanal, wert MOD ganzzahlobergrenze)
END PROC wert an analogausgang ausgeben;
PROC spannungswert ausgeben (INT CONST kanal, REAL CONST wert):
pruefe kanal (kanal, analog aus);
pruefe spannungswert;
ausgeben (kanal, gewandelte spannung).
pruefe spannungswert:
REAL VAR u min, u max;
hole spannungsbereich (kanal, u min, u max);
IF wert < u min OR wert > u max
THEN errorstop ("Der Spannungswert " + text (wert) +
" ist nicht zulaessig!")
FI.
gewandelte spannung:
int (((wert - u min) * maximalwert) / (u max - u min) + 0.5).
END PROC spannungswert ausgeben;
PROC bitsymbol ausgeben (INT CONST kanal, bitnummer, TEXT CONST zeichen):
pruefe kanal (kanal, digital aus);
pruefe bitnummer (bitnummer);
ausgeben (kanal, relativer dezimalwert (zeichen, bitnummer, kanal))
END PROC bitsymbol ausgeben;
PROC bitmuster ausgeben (INT CONST kanal, TEXT CONST zeichenkette):
pruefe kanal (kanal, digital aus);
ausgeben (kanal, relativer dezimalwert (zeichenkette, kanal))
END PROC bitmuster ausgeben;
PROC dezimalwert ausgeben (INT CONST kanal, wert):
pruefe kanal (kanal, digital aus);
ausgeben (kanal, wert MOD ganzzahl obergrenze)
END PROC dezimalwert ausgeben;
(********************* E I N G A B E - B E F E H L E *********************)
BOOL PROC bitmuster gleich (INT CONST kanal, TEXT CONST zeichenkette):
INT CONST eingabewert :: dezimalwert (kanal);
pruefe zeichenkette;
eingabe passt zur zeichenkette.
pruefe zeichenkette:
IF length (zeichenkette) <> kanalbreite
THEN errorstop ("Das Bitmuster '" + zeichenkette +
"' hat eine unzulaessige Laenge!")
FI.
eingabe passt zur zeichenkette:
INT VAR stelle;
BOOL VAR abweichung gefunden :: FALSE;
FOR stelle FROM 1 UPTO kanalbreite REP
teste bit an dieser stelle
UNTIL abweichung gefunden PER;
NOT abweichung gefunden.
teste bit an dieser stelle:
TEXT CONST einzelbit :: zeichenkette SUB stelle;
IF einzelbit = eins
THEN teste eingabebit auf eins
ELIF einzelbit = null
THEN teste eingabebit auf null
ELIF einzelbit = egal
THEN eingabebit ist beliebig
ELSE errorstop ("'" + einzelbit + "' ist unzulaessiges " +
"Bitsymbol in '" + zeichenkette + "'!")
FI.
teste eingabebit auf eins:
IF NOT bit (eingabewert, kanalbreite - stelle)
THEN abweichung gefunden := TRUE
FI.
teste eingabebit auf null:
IF bit (eingabewert, kanalbreite - stelle)
THEN abweichung gefunden := TRUE
FI.
eingabebit ist beliebig:
.
END PROC bitmuster gleich;
BOOL PROC bit ist gesetzt (INT CONST kanal, bitnummer):
pruefe kanal (kanal, digital ein);
pruefe bitnummer (bitnummer);
IF bit (eingabe (kanal), bitnummer)
THEN TRUE
ELSE FALSE
FI
END PROC bit ist gesetzt;
INT PROC wert von analogeingang (INT CONST kanal):
pruefe kanal (kanal, analog ein);
eingabe (kanal)
END PROC wert von analogeingang;
REAL PROC spannungswert (INT CONST kanal):
INT CONST dezimalwert :: wert von analogeingang (kanal);
REAL VAR u min, u max;
hole spannungsbereich (kanal, u min, u max);
round (real (dezimalwert) * (u max - u min) / maximalwert + u min, 3)
END PROC spannungswert;
TEXT PROC bitsymbol (INT CONST kanal, bitnummer):
pruefe kanal (kanal, digital ein);
pruefe bitnummer (bitnummer);
IF bit (eingabe (kanal), bitnummer)
THEN eins
ELSE null
FI
END PROC bitsymbol;
TEXT PROC bitmuster (INT CONST kanal):
TEXT VAR zeichenkette :: "";
INT CONST wert :: dezimalwert (kanal);
wandle wert;
zeichenkette.
wandle wert:
INT VAR zeiger;
FOR zeiger FROM kanalbreite - 1 DOWNTO 0 REP
IF bit (wert, zeiger)
THEN zeichenkette CAT eins
ELSE zeichenkette CAT null
FI
PER.
END PROC bitmuster;
INT PROC dezimalwert (INT CONST kanal):
pruefe kanal (kanal, digital ein);
eingabe (kanal)
END PROC dezimalwert;
(******************** H I L F S - P R O Z E D U R E N ********************)
INT PROC relativer dezimalwert (TEXT CONST zeichenkette, INT CONST kanal):
INT VAR wert := letzte ausgabe (kanal);
pruefe zeichenkette auf korrekte laenge;
veraendere alten wert;
wert.
pruefe zeichenkette auf korrekte laenge:
IF length (zeichenkette) <> kanalbreite
THEN errorstop ("Bitmuster '" + zeichenkette + "' hat "
+ "unzulaessige Laenge!")
FI.
veraendere alten wert:
INT VAR zeiger;
FOR zeiger FROM 1 UPTO kanalbreite REP
veraendere dieses bit
PER.
veraendere dieses bit:
TEXT CONST einzelbit :: zeichenkette SUB zeiger;
IF einzelbit = eins THEN setze bit
ELIF einzelbit = null THEN loesche bit
ELIF einzelbit = invers THEN invertiere bit
ELIF einzelbit = egal THEN lasse bit
ELSE errorstop ("'" + einzelbit + "' ist unzulaessiges " +
"Bitsymbol in '" + zeichenkette + "'!")
FI.
setze bit:
set bit (wert, kanalbreite - zeiger).
loesche bit:
reset bit (wert, kanalbreite - zeiger).
invertiere bit:
IF bit (wert, kanalbreite - zeiger)
THEN loesche bit
ELSE setze bit
FI.
lasse bit:
.
END PROC relativer dezimalwert;
INT PROC relativer dezimalwert (TEXT CONST bitzeichen,
INT CONST bitnummer, kanal):
INT VAR wert :: letzte ausgabe (kanal);
IF bitzeichen = eins THEN setze bit
ELIF bitzeichen = null THEN loesche bit
ELIF bitzeichen = invers THEN invertiere bit
ELIF bitzeichen = egal THEN lasse bit
ELSE errorstop ("'" + bitzeichen + "' ist ein unzulaessiges " +
"Bitsymbol!")
FI;
wert.
setze bit:
set bit (wert, bitnummer).
loesche bit:
reset bit (wert, bitnummer).
invertiere bit:
IF bit (wert, bitnummer)
THEN loesche bit
ELSE setze bit
FI.
lasse bit:
.
END PROC relativer dezimalwert;
PROC pruefe bitnummer (INT CONST bitnummer):
IF bitnummer < 0 OR bitnummer > kanalbreite - 1
THEN errorstop ("Bitnummer " + text (bitnummer) +
" ist nicht zulaessig!")
FI
END PROC pruefe bitnummer
END PACKET ls prozess 2
|
