File: INCLUDE\MOTRSTRG\MOTRSTRG.H
1 #ifndef __MOTRSTRG_H
2 #define __MOTRSTRG_H
3
4 #include "motrstrg\m_motcom.h" // TMotor
5 #include "motrstrg\msimstat.h" // Motorsimulator
6
7 //--||--\\--||--//--||--\\--||--//--||--\\--||--//--||--\\--||--//--||--\\--||--
8
9
10 #if defined (Build_Motors)
12 #elif defined(Use_Motors)
14 #else
15 #define _MOTORCLASS
16 #endif
17
18
19 /* Benutzt in m_motcom.h, m_layer.h/cpp */
20 enum EValueType
21 {
22 Distance= 1, MinDistance, MaxDistance, MinDistanceRel, MaxDistanceRel, Speed, MinSpeed, MaxSpeed, Width, MinWidth, Acceleration
23
24 };
25
26 /*
27 * High Level layer der Motoransteuerung.
28 * Funktionen von ausserhalb sollten diese benutzen und nicht die
29 * aus motors.h
30 *
31 * mFunctionName = funktion benutzt den aktivierten Motor
32 * mlFunctionName= funktion benutzt den Motor mit der uebergebenen
33 * MotorID (mid)
34 * Achse= ein Motor, der eine bestimmte Achse bewegt
35 *
36 * Viele hier benutzte Typen werden in comhead.h definiert, auf
37 * jeden Fall einmal anschauen.
38 * In m_motcom.h stehen einige Kurzroutinen!!
39 *
40 * Kommentare: Jens-Uwe Rumstich, 18. Februar 1999
41 * Stefan Lützkendorf, Februar 2001
42 */
43
44 #ifdef __cplusplus
45 extern "C"
46 {
47 #endif
48 // prototypes for export functions
49
50 /*******************************************************************************
51 ******************** MotorListen-Funktionen ***********************************
52 ******************************************************************************/
53
54 /* initialisiere DLL.
55 * TRUE = initialisierung erfolgreich
56 * FALSE= sonst
57 */
58 BOOL _MOTORCLASS WINAPI mlInitializeMotorsDLL( void );
59
60 /* Auswahl der aktiven Axis (Motor).
61 * Auswahl des Motors, der danach direkt ueber die mFuntionsname
62 * Funktionen angesprochen wird.
63 *
64 * der Parameter id endspricht der Position des Motors in der
65 * Motoren-Liste bzw. dem X in [MotorX] im ini-file
66 *
67 * fuer id muss gelten: 0 <= id && id < mlGetAxisNumber()
68 *
69 * standardmaessig ist Achse 0 aktiv
70 *
71 * TRUE = Auswahl erfolgreich
72 * FALSE= Auswahl schlug fehl (id ausserhalb des gueltigen Bereiches)
73 */
74 BOOL _MOTORCLASS WINAPI mlSetAxis( int id );
75
76 /* Ermittle derzeit aktivierte Achse
77 * siehe mlSetAxis fuer mehr
78 */
79 int _MOTORCLASS WINAPI mlGetAxis( void );
80
81 /* liefert die id der Achse die einem Achsentype zugeordnet ist
82 *
83 * liefert -1 falls diese Achse nicht existiert bzw. nicht initialisiert wurde
84 * s.a. mlIsAxisValid
85 *
86 * moegliche achsen: X, Y, Z, Omega, Theta, Phi, Spi, Encoder, Monochromator,
87 * Absorber, Collimator, DF, DC, Tilt, Rotation
88 * (siehe auch comhead.h)
89 */
90 int _MOTORCLASS WINAPI mlGetIdByName( EAxisType axis);
91
92 //! neu Kullmann+Reinecker: Ermittelt die Nachkommastellengenauigkeit für Angle- und Speed-Ausgaben (siehe DFmt)
93 //ACHTUNG die Schrittweite muss eine Nachkommastelle mehr haben!!!
94 //ACHTUNG der Index dex Antriebs (erster Parameter) wird nicht auf seine Gültigkeit hin überprüft!
95 UINT _MOTORCLASS WINAPI mlGetDigits ( int );
96
97 /* returns the value of TValueType of the motor.
98 * TValueType might be one of :
99 * Distance - aktuelle Position in Nutzereinheiten (incl. AngleBias)
100 * MinDistance - kleinstmögliche Position in Nutzereinheiten
101 * MinDistanceRel - WIEVOR, jedoch incl. AngleBias
102 * MaxDistance - größtmögliche Position in Nutzereinheiten
103 * MaxDistanceRel - WIEVOR, jedoch incl. AngleBias
104 * Speed - aktuelle Geschwindigkeit in Nutzereinheiten
105 * MinSpeed - minimale Geschwindigkeit in Nutzereinheiten/Sekunde
106 * MaxSpeed - maximale Geschwindigkeit in Nutzereinheiten/Sekunde
107 * Width - Schrittweite in Nutzereinheiten
108 * MinWidth - minimale Schrittweite in Nutzereinheiten
109 * Acceleration - Beschleunigung in Nutzereinheiten/(Sekunde*Sekunde)
110 * fuer TValueType siehe auch comhead.h
111 *
112 * s.a. mGetValue
113 */
114 double _MOTORCLASS WINAPI mlGetValue( int, EValueType );
115
116 //Neu : Kullmann, Reinecker (22.10.2002); minimale, relative Antriebsposition in Nutzereinheiten
117 double _MOTORCLASS WINAPI mlGetAngleRelativeMin( int );
118
119 //Neu : Kullmann, Reinecker (22.10.2002); maximale, relative Antriebsposition in Nutzereinheiten
120 double _MOTORCLASS WINAPI mlGetAngleRelativeMax( int );
121
122 /* Bewegt den gegebenen Motor zur gegebenen Position (in Nutzereinheiten)
123 */
124 BOOL _MOTORCLASS WINAPI mlMoveToDistance( int mid, double position);
125
126 /* Bewegt aktuellen Motor relativ zur aktuellen Position um eine
127 * bestimmte Distanz.
128 * Distanz wird im Winkelmass (Nutzereinheiten) uebergeben
129 */
130 BOOL _MOTORCLASS WINAPI mMoveByDistance( double distance);
131
132
133 /* Feststellen, ob sich der Motor noch bewegt.
134 * TRUE : motor finished to move (stands still)
135 oder befindet sich in einem toten Bereich
136 */
137 BOOL _MOTORCLASS WINAPI mlIsMoveFinish( int );
138
139 /* returns Offset (dAngleBias)
140 * Offset, dass die Verschiebung der Relativen zur Absoluten Null angibt
141 * Wenn Offset != 0, dann beziehen sich alle Positionsangaben auf relative Null.
142 */
143 double _MOTORCLASS WINAPI mlGetOffset( int );
144
145 /* Setzen der Defaults fuer Winkel (dAngleBias auf 0 ) und der
146 * (erlaubten ?)Winkelbereiche (SetAngleRange). Die Werte brauchen nicht
147 * uebergeben zu werden.
148 */
149 void WINAPI mSetAngleDefault( void );
150
151 /* Umwandeln eines Strings in einen AxisType.
152 * Allows more than one name for the same axis type. for example will
153 * all of AzimutalRotation, AZ, Rotation and Azimute get to axis type
154 * Rotation.
155 * wird zum Beispiel ueber mehrere Ecken von ParsingCmd in m_steering.cpp
156 * benutzt. useless ??
157 */
158 EAxisType _MOTORCLASS WINAPI mlParsingAxis( LPSTR );
159
160 /* herausfinden, ob eine bestimmte Achse initialisiert wurde
161 * TRUE = Achse wurde bereits initialisiert
162 * FALSE= sonst
163 */
164 BOOL _MOTORCLASS WINAPI mlIsAxisValid( EAxisType );
165
166 /* liefert die Anzahl der Achsen/Motoren in der Motoren Liste
167 *
168 * gueltige Motor-IDs liegen im Bereich von 0 bis mlGetAxisNumber()-1
169 */
170 int _MOTORCLASS WINAPI mlGetAxisNumber( void );
171
172 /* Abspeichern der Einstellungen aller Motoren im ini-File
173 * - v.a. der aktuellen Position fuer den Programm-Neustart
174 * - setzt RestartPossible=TRUE um eine ordnugsgemaesses schliessen
175 * des Programmes zu signalisieren
176 * - stoppt die Motoren
177 * (motors.cpp)
178 */
179 void _MOTORCLASS WINAPI mlSaveModuleSettings( void );
180
181 /* Setzen der Defaults fuer Winkel (dAngleBias auf 0 ) und der
182 * (erlaubten ?)Winkelbereiche (SetAngleRange). Die Werte brauchen nicht
183 * uebergeben zu werden.
184 */
185 void _MOTORCLASS WINAPI mlSetAngleDefault( void );
186
187 /* Rueckgabe der Versionsnummer von der m_layer-Schicht
188 */
189 LPCSTR _MOTORCLASS WINAPI mlGetVersion( void );
190
191 /* returns instance of module
192 */
193 HINSTANCE _MOTORCLASS WINAPI mlGetInstance( void );
194
195 /*******************************************************************************
196 ************************ Motor-Funktionen *************************************
197 ******************************************************************************/
198
199 /* Bewegt den aktuellen Motor zur gegebenen Position (in Nutzereinheiten)
200 * Die Position wird im Bogenmass (Nutzereinheiten) uebergeben
201 */
202 BOOL _MOTORCLASS WINAPI mMoveToDistance( double position);
203
204 /* Feststellen, ob sich der Motor noch bewegt.
205 * TRUE : motor finished to move (stands still)
206 oder befindet sich in einem toten Bereich
207 */
208 BOOL _MOTORCLASS WINAPI mIsMoveFinish( void );
209
210 /* Feststellen, ob ein Motor (vielleicht auch nur frueher berechneter
211 * Winkel, wird in Translate gesetzt) ausserhalb des erlaubten Bereich
212 * ist.
213 * TRUE = Ausserhalb des erlaubten Bereichs, Fehler!
214 * FALSE= Innerhalb des erlaubten Bereichs, kein Problem :-)
215 */
216 BOOL _MOTORCLASS WINAPI mIsRangeHit( void );
217
218 /* Test ob Motor kalibriert ist und Werte über einen gültigen Referenzpunktlauf
219 * vorhanden sind.
220 *
221 * FALSE= die Positionsangaben kommen aus einem ungültigen Koordinatensystem
222 * TRUE = die Positionsangaben sind relativ zur Absoluten bzw. zur Relativen Null
223 *
224 * == ini_InitialMove OR (ini_RestartPossible OR Referenzkunktlauf_ist_erfolgt)
225 */
226 BOOL _MOTORCLASS WINAPI mlIsCalibrated( int axis );
227 BOOL _MOTORCLASS WINAPI mIsCalibrated( void );
228
229 /* TRUE = WinkelOffset != 0, sprich der Winkel bezieht sich auf
230 * relative Null
231 * FALSE= WinkelOffset= 0.
232 */
233 BOOL _MOTORCLASS WINAPI mlIsDistanceRelative( int axis );
234 BOOL _MOTORCLASS WINAPI mIsDistanceRelative( void );
235
236 /* Wenn FALSE, dann wird Befehl auf der 812 ignoriert !!! BUG ??
237 * Stoppen des Motors.
238 * Der Bool-Wert gibt eventuell an, ob der Motor wieder neu gestartet
239 * werden soll. Leider Source ohne Doc nicht lesbar :-(
240 */
241 void _MOTORCLASS WINAPI mStopDrive( BOOL );
242
243 /* Ermittle Distance des Motors mit der gegebenen Motor ID.
244 * TRUE = Ok, Distanz konnte ermittelt werden
245 -> Distanz steht im Double-Parameter!!
246 * FALSE= sorry, funktion ging schief
247 */
248 BOOL _MOTORCLASS WINAPI mlGetDistance( int, double& );
249 BOOL _MOTORCLASS WINAPI mGetDistance( double& );
250
251 // WIEVOR, jedoch auch in Bewegung möglich
252 double _MOTORCLASS WINAPI mlGetDistanceProcess( int axis );
253 double _MOTORCLASS WINAPI mGetDistanceProcess( void );
254
255 //! neu Kullmann+Reinecker: Ermittelt die Nachkommastellengenauigkeit für Angle- und Speed-Ausgaben (siehe DFmt)
256 //ACHTUNG die Schrittweite muss eine Nachkommastelle mehr haben!!!
257 UINT _MOTORCLASS WINAPI mGetDigits ( void );
258
259 /* s. mlGetValue
260 */
261 double _MOTORCLASS WINAPI mGetValue( EValueType );
262
263 //Neu : Kullmann, Reinecker (22.10.2002); minimale, relative Antriebsposition in Nutzereinheiten
264 double _MOTORCLASS WINAPI mGetAngleRelativeMin( void );
265
266 //Neu : Kullmann, Reinecker (22.10.2002); maximale, relative Antriebsposition in Nutzereinheiten
267 double _MOTORCLASS WINAPI mGetAngleRelativeMax( void );
268
269 /* returns Unittype.
270 * this might be one of Grad,Minuten,Sekunden,Millimeter,Mikrometer
271 * Channel. See comhead.h for deklaration of TUniType
272 */
273 EUnitType _MOTORCLASS WINAPI mlGetUnit( int axis );
274 EUnitType _MOTORCLASS WINAPI mGetUnit( void );
275
276 /* set value of a special ValueType. TValueType might be Speed or Width.
277 * Distance, MaxDistance, MinDistance allways return false an can not be set!
278 *
279 * wenn valType == Speed
280 * Einheit ist Unit / Sekunde (s. ini-Params. Unit, SpeedScale)
281 * der Wert wird automatisch durch MaxVelocity beschränkt
282 *
283 * TRUE : Function successfull
284 * FALSE: Function failed
285 * This function depends on a LowLevel-Driver to return false/true correctly
286 */
287 BOOL _MOTORCLASS WINAPI mlSetValue( int axis, EValueType vtype, double value );
288 BOOL _MOTORCLASS WINAPI mSetValue( EValueType valType, double value);
289
290 /* Aktiviere einen Motor (Ansteuerungskarte?)
291 * Dieses geschieht direkt der Hardware Ebene
292 */
293 void _MOTORCLASS WINAPI mActivateDrive( void );
294
295 /* der Correctionstate wird entweder ON oder OFF (oder 0) geschaltet
296 */
297 void _MOTORCLASS WINAPI mlSetCorrectionState( int axis, BOOL onoff );
298 void _MOTORCLASS WINAPI mSetCorrectionState( BOOL );
299
300 /* liefert die Bezeichnung des aktuellen motors (name-parameter in ini-file)
301 */
302 LPCSTR _MOTORCLASS WINAPI mlGetAxisName( int axis );
303 LPCSTR _MOTORCLASS WINAPI mGetAxisName( void );
304
305 /* ausgabe von szUnit. Wird aus ini-file ausgelesen*/
306 LPCSTR _MOTORCLASS WINAPI mlGetUnitName( int mid );
307 LPCSTR _MOTORCLASS WINAPI mGetUnitName( void );
308
309 /* rueckgabe eines String. Siehe DFmt in motors.cpp
310 */
311 LPCSTR _MOTORCLASS WINAPI mGetDF( void );
312
313 /* rueckgabe eines String. Siehe SFmt in motors.cpp
314 */
315 LPCSTR _MOTORCLASS WINAPI mGetSF( void );
316
317 /* setzen der relativen Null.
318 * Wenn Bool= TRUE -> Die relative Null wird um offset verschoben; ist bereits
319 * eine relative Null gesetzt, wird die relative Null
320 * relativ zur bisherigen relative Null gesetzt.
321 * = FALSE-> Die relative Null wird zurückgesetzt, d.h. sie wird
322 * gleich der absoluten Null gesetzt.
323 */
324 void _MOTORCLASS WINAPI mlSetRelativeZero( int axis, BOOL yes, double value );
325 void _MOTORCLASS WINAPI mSetRelativeZero( BOOL, double offset);
326
327 /* Ausfuehren des Kommandos in LPSTR direkt auf der Karte/dem Motor.
328 *
329 * sollte solcherlei direktes Ansprechen der Hardware in diesem
330 * High-Level-Layer nicht unmoeglich sein?
331 */
332 int _MOTORCLASS WINAPI mExecuteCmd( LPSTR );
333
334 /* Zwischenspeichern von dAngle, dAngleMin, dAngleMax, dAngleWidth und
335 * dSpeed. Achtung, es werden eventuell frueher gespeicherte Werte
336 * ueberschrieben. Zwischen 2 PushSettings muss also ein PopSettings
337 * erfolgen, sonst gehen diese Werte verloren!
338 * Frage: ist es wirklich sinnvoll, eine solche Routine nach aussen
339 * anzubieten? Sollte so etwas nicht irgendwie abgeschirmt werden?
340 */
341 void _MOTORCLASS WINAPI mPushSettings( void );
342
343 /* Zurueckschreiben der (letzten) mit PushSettings gespeicherten
344 * Werte in die entsprechenden Variablen!
345 */
346 void _MOTORCLASS WINAPI mPopSettings( EMParameter );
347
348 /*******************************************************************************
349 ****** "MoveScan"-Funktionen **************************************************
350 *******************************************************************************
351 *
352 * Ein MoveScan setzt den Motor mit den aktuellen Parametern
353 * in Bewegung und tastet die Position in regelmäßigen Abständen
354 * ab. Der Entstehende Vektor von Positionsangaben steht danach zur
355 * Verfügung.
356 *
357 */
358
359 /* liefert die maximale Anzahl von Abtastungen die durchgeführt wird,
360 * d.h. die Größe des Vektors
361 * (liefert konstant 150)
362 */
363 int _MOTORCLASS WINAPI mGetScanSize( void );
364
365 /* liefert die tatsächliche Anzahl von Abtastungen die durchgeführt wurden
366 * d.h. die Anzahl der Werte im Vektor die gültig sind
367 */
368 int _MOTORCLASS WINAPI mGetMoveFinishIdx( void );
369
370 /* liefert einen Zeiger auf den Vektor der abgetasteten Positionswerte
371 * der Verktor hat die Größe mGetScanSize() und der mGetMoveFinishIdx()
372 * gültige Werte enthält
373 */
374 LPLONG _MOTORCLASS WINAPI mGetMoveScan( void );
375
376 /*******************************************************************************
377 ************************ Motor-Dialoge ****************************************
378 ******************************************************************************/
379 /* ich habe alles mit DLG im Namen hierhin an das Ende verbannt. Alles mit
380 * Dialogen hat hier nichts zu suchen und sollte an eine entsprechende
381 * Files bewegt werden!!
382 * should be moved out of m_layer !!!
383 */
384
385 /* start InquireReferencePoint-Dialog
386 */
387 void _MOTORCLASS WINAPI mlInquireReferencePointDlg( BOOL ); // Parameter geändert int -> BOOL (08.08.02)
388
389 /* start PositionControl-Dialog
390 */
391 void _MOTORCLASS WINAPI mlPositionControlDlg( void );
392
393 /* start SetParameter-Dialog
394 */
395 void _MOTORCLASS WINAPI mlSetParametersDlg ( void );
396
397 /* send cm_CallExecuteScan and start Optimizing-Dialog
398 */
399 void _MOTORCLASS WINAPI mlOptimizingDlg( void );
400 #ifdef __cplusplus
401
402 }
403 #endif
404
405
406 #endif
407 // __LastLine__
408
409
410