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
|
FUNCTION_BLOCK "Ringpuffer"
TITLE =Ringpuffer (FIFO) mit 32-bit breiten Elementen
VERSION : 0.1
VAR_INPUT
eingabe : BOOL ;
ausgabe : BOOL ;
eingabe_wert : DWORD ;
reset : BOOL ;
END_VAR
VAR_OUTPUT
ausgabe_wert : DWORD ;
ueberlauf : BOOL ;
unterlauf : BOOL ;
fuellstand : INT ;
END_VAR
VAR
fm_eingabe : BOOL ;
fm_ausgabe : BOOL ;
anzahl_belegt : INT ;
ptr_eingabe : DWORD ;
ptr_ausgabe : DWORD ;
elemente : ARRAY [0 .. 31 ] OF DWORD ;
END_VAR
VAR_TEMP
max_anzahl_elemente : INT ;
zaehler : INT ;
END_VAR
BEGIN
NETWORK
TITLE =Konstanten definieren
L 32; // Groesse des "elemente" Arrays
T #max_anzahl_elemente;
NETWORK
TITLE =Ringpuffer entladen
U #ausgabe; // "ausgabe" positive Flanke?
FP #fm_ausgabe;
SPBN end1; // Nein? Dann Ende.
L #anzahl_belegt;
L 0;
==D ; // anzahl_belegt == 0?
SPBN nunt; // ... dann kein Unterlauf
SET ;
= #unterlauf; // ... sonst Unterlauf anzeigen
L 0;
T #ausgabe_wert;
SPA end1; // Und Ende.
nunt: L P##elemente;
L #ptr_ausgabe;
+D ; // AR1 = element_0 + ptr_ausgabe
LAR1 ; // AR1 zeigt auf das erste belegte Element
L D [AR1,P#0.0];
T #ausgabe_wert; // ausgabe_wert = erstes belegtes Element
L 0; // Element nullen. (Nicht unbedingt noetig)
T D [AR1,P#0.0];
L #anzahl_belegt;
L 1;
-D ; // anzahl_belegt -= 1
T #anzahl_belegt;
L #ptr_ausgabe;
L P#4.0;
+D ; // ptr_ausgabe += 4
T #ptr_ausgabe;
L #max_anzahl_elemente;
L P#4.0;
*D ; // akku = Pointer auf Ringende
L #ptr_ausgabe;
>D ; // ptr_ausgabe < Ringende
SPB end0; // ... dann Ende
L P#0.0; // ... sonst ptr_ausgabe = P#0.0
T #ptr_ausgabe;
end0: CLR ;
= #ueberlauf; // Fehleranzeigen zuruecksetzen
= #unterlauf;
end1: NOP 0;
NETWORK
TITLE =Ringpuffer beladen
U #eingabe; // "eingabe" positive Flanke?
FP #fm_eingabe;
SPBN end3; // Nein? Dann Ende.
L #anzahl_belegt;
L #max_anzahl_elemente;
<D ; // anzahl_belegt < max_anzahl?
SPB nueb; // ... dann kein Ueberlauf
SET ;
= #ueberlauf; // ... sonst Ueberlauf anzeigen
SPA end3; // Und Ende.
nueb: L P##elemente;
L #ptr_eingabe;
+D ; // AR1 = element_0 + ptr_eingabe
LAR1 ; // AR1 zeigt auf das erste freie Element
L #eingabe_wert;
T D [AR1,P#0.0]; // Erstes freies Element = eingabe_wert
L #anzahl_belegt;
L 1;
+D ; // anzahl_belegt += 1
T #anzahl_belegt;
L #ptr_eingabe;
L P#4.0;
+D ; // ptr_eingabe += 4
T #ptr_eingabe;
L #max_anzahl_elemente;
L P#4.0;
*D ; // akku = Pointer auf Ringende
L #ptr_eingabe;
>D ; // ptr_eingabe < Ringende
SPB end2; // ... dann Ende
L P#0.0; // ... sonst ptr_eingabe = P#0.0
T #ptr_eingabe;
end2: CLR ;
= #ueberlauf; // Fehleranzeigen zuruecksetzen
= #unterlauf;
end3: NOP 0;
NETWORK
TITLE =Reset-Signal verarbeiten
U #reset;
SPBN nrst;
// Statische Variablen und Ausgaenge nullen
L 0;
T #ausgabe_wert;
T #fuellstand;
T #anzahl_belegt;
T #ptr_eingabe;
T #ptr_ausgabe;
CLR ;
= #ueberlauf;
= #unterlauf;
// Alle Elemente nullen.
// Dies ist nicht unbedingt notwendig, aber zur Fehlersuche sinnvoll.
L #max_anzahl_elemente;
next: T #zaehler;
L 1;
-D ;
L P#4.0;
*D ;
L P##elemente;
+D ;
LAR1 ;
L 0;
T D [AR1,P#0.0];
L #zaehler;
LOOP next;
nrst: NOP 0;
NETWORK
TITLE =Fuellstand ausgeben
L #anzahl_belegt;
T #fuellstand;
END_FUNCTION_BLOCK
DATA_BLOCK "DB_Ringpuffer"
"Ringpuffer"
BEGIN
END_DATA_BLOCK
ORGANIZATION_BLOCK OB 1
VAR_TEMP
OB1_EV_CLASS : BYTE; // Bits 0-3 = 1 (Coming event), Bits 4-7 = 1 (Event class 1)
OB1_SCAN_1 : BYTE; // 1 (Cold restart scan 1 of OB 1), 3 (Scan 2-n of OB 1)
OB1_PRIORITY : BYTE; // Priority of OB execution
OB1_OB_NUMBR : BYTE; // 1 (Organization block 1, OB 1)
OB1_RESERVED_1 : BYTE;
OB1_RESERVED_2 : BYTE;
OB1_PREV_CYCLE : INT; // Cycle time of previous OB 1 scan (milliseconds)
OB1_MIN_CYCLE : INT; // Minimum cycle time of OB 1 (milliseconds)
OB1_MAX_CYCLE : INT; // Maximum cycle time of OB 1 (milliseconds)
OB1_DATE_TIME : DATE_AND_TIME; // Date and time OB 1 started
END_VAR
BEGIN
U "clock_100ms"
= E 0.0
U "clock_200ms"
= E 0.1
L L#31337
T ED 2
U A 0.0
= E 0.2
CALL "Ringpuffer", "DB_Ringpuffer" (
eingabe := E 0.0,
ausgabe := E 0.1,
eingabe_wert := ED 2,
reset := E 0.2,
ausgabe_wert := AD 2,
ueberlauf := A 0.0,
unterlauf := A 0.1,
fuellstand := AW 6,
)
L ED 2
L AD 2
L AW 6
END_ORGANIZATION_BLOCK
|
