-
Notifications
You must be signed in to change notification settings - Fork 2
Expand file tree
/
Copy pathsequence.py
More file actions
545 lines (456 loc) · 26.5 KB
/
Copy pathsequence.py
File metadata and controls
545 lines (456 loc) · 26.5 KB
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
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
####################################################################################
# #
# sequence.py -- contains functions to implement engine sequencing routines #
# #
# Author: Nitish Chennoju, Colton Acosta #
# Date: 6/12/2022 #
# Sun Devil Rocketry Avionics #
# #
####################################################################################
####################################################################################
# Standard Imports #
####################################################################################
import time
import sys
####################################################################################
# Project Imports #
####################################################################################
import engineController
import valveController
####################################################################################
# Sequencing Functions #
####################################################################################
####################################################################################
# #
# PROCEDURE: #
# pre_fire_purge #
# #
# DESCRIPTION: #
# Initiates the pre-hotfire purge of the engine #
# #
####################################################################################
def pre_fire_purge( engine_state, serialObj ):
# Verify correct state
state = engine_state.get_engine_state()
if ( state != "Ready State" ):
print( "Error: Cannot perform the pre-fire purge. The engine controller " +
"must be in the Ready state to perform the purge. The current " +
"state is: ")
print( state )
return
# Initiate the pre-fire purge
engineController.pfpurge( [], serialObj )
# Set the new engine state
engine_state.set_engine_state( serialObj.get_engine_state() )
## pre_fire_purge ##
####################################################################################
# #
# PROCEDURE: #
# fill_and_chill #
# #
# DESCRIPTION: #
# Initiates the fill and chill engine sequence #
# #
####################################################################################
def fill_and_chill( engine_state, serialObj ):
# Verify correct state
state = engine_state.get_engine_state()
if ( state != "Pre-Fire Purge State" ):
print( "Error: Cannot initiate the Fill and Chill sequence. The engine " +
"controller must be in the Pre-Fire Purge state to initiate the " +
"Fill and Chill sequence. The current state is: " )
print( state )
return
# Initiate the fill and chill sequence
engineController.fillchill( [], serialObj )
# Set the new engine state
engine_state.set_engine_state( serialObj.get_engine_state() )
## fill_and_chill ##
####################################################################################
# #
# PROCEDURE: #
# standby #
# #
# DESCRIPTION: #
# Puts the engine controller into the standby state #
# #
####################################################################################
def standby( engine_state, serialObj ):
# Verify correct state
state = engine_state.get_engine_state()
if ( state != "Fill and Chill State" ):
print( "Error: Cannot initiate the standby sequence. The engine controller " +
"must be in the Fill and Chill state to transition into Standby. The current " +
"state is: ")
print( state )
return
# Put the engine in standby state
engineController.standby( [], serialObj )
# Set the new engine state
engine_state.set_engine_state( serialObj.get_engine_state() )
## standby ##
####################################################################################
# #
# PROCEDURE: #
# fire_engine #
# #
# DESCRIPTION: #
# Initiates the engine ignition sequence #
# #
####################################################################################
def fire_engine( engine_state, serialObj ):
# Verify correct state
state = engine_state.get_engine_state()
if ( state != "Standby State" ):
print( "Error: Cannot initiate the hotfire. The engine controller must " +
"be in the Standby state in order to initiate the hotfire. The " +
"current state is: ")
print( state )
return
# Initiate the hotfire
engineController.hotfire( [], serialObj )
# Set the new engine state
engine_state.set_engine_state( serialObj.get_engine_state() )
## fire_engine ##
####################################################################################
# #
# PROCEDURE: #
# hotfire_abort #
# #
# DESCRIPTION: #
# Aborts the hotfire sequence #
# #
####################################################################################
def hotfire_abort( engine_state, serialObj ):
# Issue the abort command
engineController.hotfire_abort( [], serialObj )
# Set the new engine state
engine_state.set_engine_state( serialObj.get_engine_state() )
## hotfire_abort ##
####################################################################################
# #
# PROCEDURE: #
# get_state #
# #
# DESCRIPTION: #
# Gets the state of the hotfire #
# #
####################################################################################
def get_state( engine_state, serObj ):
engineController.hotfire_getstate( [], serObj )
engine_state.set_engine_state( serObj.get_engine_state() )
## get_state ##
####################################################################################
# #
# PROCEDURE: #
# stop_hotfire #
# #
# DESCRIPTION: #
# Stops the engine hotfire #
# #
####################################################################################
def stop_hotfire( engine_state, serialObj ):
# Verify correct state
state = engine_state.get_state()
if ( state != "Fire State" ):
print( "Error: Cannot stop the engine hotfire. The engine controller " +
"must be in the Fire State in order to stop the hotfire. The " +
"current state is: " )
print( state )
return
# Issue the stop hotfire command
engineController.stop_hotfire( [], serialObj )
## stop_hotfire ##
####################################################################################
# #
# PROCEDURE: #
# stop_purge #
# #
# DESCRIPTION: #
# Halts the post-hotfire purge #
# #
####################################################################################
def stop_purge( engine_state, serialObj ):
# Verify correct state
state = engine_state.get_engine_state()
if ( state != "Fire State" ):
print( "Error: Cannot stop the engine purge. The engine controller " +
"must be in the Fire State in order to stop the purge. The " +
"current state is: " )
print( state )
return
# Issue the stop purge command
engineController.stop_purge( [], serialObj )
# Set the new engine state
engine_state.set_engine_state( serialObj.get_engine_state() )
## stop_purge ##
####################################################################################
# #
# PROCEDURE: #
# kbottle_close #
# #
# DESCRIPTION: #
# Indicate that the kbottle has been closed #
# #
####################################################################################
def kbottle_close( engine_state, serialObj ):
# Verify correct state
state = engine_state.get_engine_state()
if ( state != "Disarm State" ):
print( "Cannot send the K-Bottle close command. The engine controller " +
"must be in the Disarm State in order to issue the command. The " +
"current state is: " )
print( state )
return
# Issue the kbottle close command
engineController.kbottle_close( [], serialObj )
# Set the new engine state
engine_state.set_engine_state( serialObj.get_engine_state() )
## kbottle_close ##
####################################################################################
# #
# PROCEDURE: #
# lox_purge #
# #
# DESCRIPTION: #
# Initiate the LOX tank purge #
# #
####################################################################################
def lox_purge( engine_state, serialObj ):
# Verify correct state
state = engine_state.get_engine_state()
if ( ( state != "Disarm State" ) and ( state != "Fire State" ) ):
print( "Cannot send the LOX purge close command. The engine controller " +
"must be in the Disarm State in order to issue the command. The " +
"current state is: " )
print( state )
return
# Issue the kbottle close command
engineController.lox_purge( [], serialObj )
## lox_purge ##
####################################################################################
# #
# PROCEDURE: #
# manual #
# #
# DESCRIPTION: #
# Put the engine into manual mode #
# #
####################################################################################
def manual( engine_state, serialObj ):
# Issue the manual command
engineController.manual( [], serialObj )
# Update the engine state
engine_state.set_engine_state( serialObj.get_engine_state() )
## lox_purge ##
####################################################################################
# #
# PROCEDURE: #
# manual_lox_press #
# #
# DESCRIPTION: #
# Manually actuate the LOX pressure solenoid #
# #
####################################################################################
def manual_lox_press( engine_state, serialObj, solenoid_state ):
# Verify correct state
state = engine_state.get_engine_state()
if ( ( state != "Manual State" ) ):
print( "Cannot acutate the LOX pressure valve. The engine controller " +
"must be in the Manual State in order to issue the command. The " +
"current state is: " )
print( state )
return
# Issue the actuation command
if ( solenoid_state ):
# Close solenoid
valveController.sol( ['close', '-n', 'oxPress'], serialObj )
else:
# Open solenoid
valveController.sol( ['open', '-n', 'oxPress'], serialObj )
## lox_purge ##
####################################################################################
# #
# PROCEDURE: #
# manual_fuel_press #
# #
# DESCRIPTION: #
# Manually actuate the Fuel pressure solenoid #
# #
####################################################################################
def manual_fuel_press( engine_state, serialObj, solenoid_state ):
# Verify correct state
state = engine_state.get_engine_state()
if ( ( state != "Manual State" ) ):
print( "Cannot acutate the valve. The engine controller " +
"must be in the Manual State in order to issue the command. The " +
"current state is: " )
print( state )
return
# Issue the actuation command
if ( solenoid_state ):
# Close solenoid
valveController.sol( ['close', '-n', 'fuelPress'], serialObj )
else:
# Open solenoid
valveController.sol( ['open', '-n', 'fuelPress'], serialObj )
## lox_purge ##
####################################################################################
# #
# PROCEDURE: #
# manual_lox_vent #
# #
# DESCRIPTION: #
# Manually actuate the LOX vent solenoid #
# #
####################################################################################
def manual_lox_vent( engine_state, serialObj, solenoid_state ):
# Verify correct state
state = engine_state.get_engine_state()
if ( ( state != "Manual State" ) ):
print( "Cannot acutate the valve. The engine controller " +
"must be in the Manual State in order to issue the command. The " +
"current state is: " )
print( state )
return
# Issue the actuation command
if ( solenoid_state ):
# Close solenoid
valveController.sol( ['close', '-n', 'oxVent'], serialObj )
else:
# Open solenoid
valveController.sol( ['open', '-n', 'oxVent'], serialObj )
## manual_lox_vent ##
####################################################################################
# #
# PROCEDURE: #
# manual_fuel_vent #
# #
# DESCRIPTION: #
# Manually actuate the LOX vent solenoid #
# #
####################################################################################
def manual_fuel_vent( engine_state, serialObj, solenoid_state ):
# Verify correct state
state = engine_state.get_engine_state()
if ( ( state != "Manual State" ) ):
print( "Cannot acutate the valve. The engine controller " +
"must be in the Manual State in order to issue the command. The " +
"current state is: " )
print( state )
return
# Issue the actuation command
if ( solenoid_state ):
# Close solenoid
valveController.sol( ['close', '-n', 'fuelVent'], serialObj )
else:
# Open solenoid
valveController.sol( ['open', '-n', 'fuelVent'], serialObj )
## manual_fuel_vent ##
####################################################################################
# #
# PROCEDURE: #
# manual_lox_purge #
# #
# DESCRIPTION: #
# Manually actuate the LOX purge solenoid #
# #
####################################################################################
def manual_lox_purge( engine_state, serialObj, solenoid_state ):
# Verify correct state
state = engine_state.get_engine_state()
if ( ( state != "Manual State" ) ):
print( "Cannot acutate the valve. The engine controller " +
"must be in the Manual State in order to issue the command. The " +
"current state is: " )
print( state )
return
# Issue the actuation command
if ( solenoid_state ):
# Close solenoid
valveController.sol( ['close', '-n', 'oxPurge'], serialObj )
else:
# Open solenoid
valveController.sol( ['open', '-n', 'oxPurge'], serialObj )
## manual_lox_purge ##
####################################################################################
# #
# PROCEDURE: #
# manual_fuel_purge #
# #
# DESCRIPTION: #
# Manually actuate the Fuel purge solenoid #
# #
####################################################################################
def manual_fuel_purge( engine_state, serialObj, solenoid_state ):
# Verify correct state
state = engine_state.get_engine_state()
if ( ( state != "Manual State" ) ):
print( "Cannot acutate the valve. The engine controller " +
"must be in the Manual State in order to issue the command. The " +
"current state is: " )
print( state )
return
# Issue the actuation command
if ( solenoid_state ):
# Close solenoid
valveController.sol( ['close', '-n', 'fuelPurge'], serialObj )
else:
# Open solenoid
valveController.sol( ['open', '-n', 'fuelPurge'], serialObj )
## manual_fuel_purge ##
####################################################################################
# #
# PROCEDURE: #
# manual_lox_main #
# #
# DESCRIPTION: #
# Manually actuate the LOX main valve #
# #
####################################################################################
def manual_lox_main( engine_state, serialObj, valve_state ):
# Verify correct state
state = engine_state.get_engine_state()
if ( ( state != "Manual State" ) ):
print( "Cannot acutate the valve. The engine controller " +
"must be in the Manual State in order to issue the command. The " +
"current state is: " )
print( state )
return
# Issue the actuation command
if ( valve_state ):
# Close solenoid
valveController.valve( ['close', '-n', 'ox'], serialObj )
else:
# Open solenoid
valveController.valve( ['open', '-n', 'ox'], serialObj )
## manual_lox_main ##
####################################################################################
# #
# PROCEDURE: #
# manual_fuel_main #
# #
# DESCRIPTION: #
# Manually actuate the main fuel valve #
# #
####################################################################################
def manual_fuel_main( engine_state, serialObj, valve_state ):
# Verify correct state
state = engine_state.get_engine_state()
if ( ( state != "Manual State" ) ):
print( "Cannot acutate the valve. The engine controller " +
"must be in the Manual State in order to issue the command. The " +
"current state is: " )
print( state )
return
# Issue the actuation command
if ( valve_state ):
# Close solenoid
valveController.valve( ['close', '-n', 'fuel'], serialObj )
else:
# Open solenoid
valveController.valve( ['open', '-n', 'fuel'], serialObj )
## manual_fuel_main ##
####################################################################################
# END OF FILE #
####################################################################################