Basic design

We compose our railway controller from several train controllers, combined with controllers for mutual exclusion.

6

7

== Mutual Exclusion ==

8

9

=== Normal segments ===

10

11

**For each block** we generate one mutex controller, similar to the following pattern.

12

13

[[image:attach:Mutex.png]]

14

15

**For each controlled train** one state and the corresponding transitions are added.

16

17

A train **must** signal the wish to enter a segment by setting the variable **bool <segment>_req[trainNum] **to true.

18

The right to enter a segement is given to the train by setting the variable **int <segment>_perm** to the train number.

19

After leaving a segment the train **must** remove its request by setting <segment>_req[trainNum] to false again.

20

21

For a free track the *_perm variable is set to -1 and all tracks, apart from starting positions, are initialized with -1. For the starting positions the *_perm variables are set to the corresponding train number and the *_req variable for the train is set to true.

22

23

**A train must not enter a segment or alter the settings of a segment without holding the lock for the segment. No exceptions from this rule are allowed.**

24

25

=== Kicking Horse Pass ===

26

27

To prevent collisions on the track, a special controller manages the rights to enter or leave the Kicking Horse Pass.

28

29

[[image:attach:Mutex_KH.png]]

30

31

The controller splits the pass into two parts, //left// and //right//, corresponding to the track layout chart. [[(Simplified track layout)>>url:http://www.informatik.uni-kiel.de/~~railway/Downloads/kscheme.pdf||shape="rect"]]

32

33

Each part has two operational modes, //in// and //out//, being active when trains are allowed to either enter or leave the pass. When entering the pass the controller counts the entering trains and only lets two trains enter (one after the other). When leaving the pass the trains are removed from the counter, freeing space for the next train.

34

35

== Train controller ==

36

37

Each train controller is set in a separate region with a referenced state. This state has the following interface

\\\\\\\\

{{{ input int *_perm; # All permission variables (Tracks) input bool *_perm # KH permission variables input int trainNum; input bool cleanup; input bool debug; output bool *_req[]; # All request variables}}}

43

44

The train controller is composed of several //Station-2-Station// controllers. These are combined to form a complete schedule. Additionally the cleanup signal has to be watched to abort the schedule and return back to the initial position.

45

46

== Station-2-Station controller ==

47

48

Each station-2-station controller realizes the movement from one of the stations (IC,OC,KH) to a second station. All controllers using IC or OC parts have to respect the traveling directions. For the Kicking Horse Pass two separate controllers, forwards and backwards, are used.

49

50

The controllers starting from Kicking Horse Pass Station make an assumption of the direction of the train. These are dependent of the directions of the inner or outer circle, e.g. the KHIC controller starts backwards because this is the only valid direction to travel this path. To drive a train from the Kicking Horse Station (facing forward) to the Inner Circle we have to combine the KHOC and OCIC controllers.

51

52

[[image:attach:ICIC.png]]

53

54

When arriving on a station the train controller **must** first call the function //void railArrival(int train, int station)//. This starts the waiting timer for the train.

author	version	line-number	content
		1
		2
		3	{{toc/}}
		4
		5	We compose our railway controller from several train controllers, combined with controllers for mutual exclusion.
		6
		7	== Mutual Exclusion ==
		8
		9	=== Normal segments ===
		10
		11	For each block we generate one mutex controller, similar to the following pattern.
		12
		13	[[image:attach:Mutex.png]]
		14
		15	For each controlled train one state and the corresponding transitions are added.
		16
		17	A train must signal the wish to enter a segment by setting the variable bool <segment>_req[trainNum] to true.
		18	The right to enter a segement is given to the train by setting the variable int <segment>_perm to the train number.
		19	After leaving a segment the train must remove its request by setting <segment>_req[trainNum] to false again.
		20
		21	For a free track the _perm variable is set to -1 and all tracks, apart from starting positions, are initialized with -1. For the starting positions the _perm variables are set to the corresponding train number and the *_req variable for the train is set to true.
		22
		23	A train must not enter a segment or alter the settings of a segment without holding the lock for the segment. No exceptions from this rule are allowed.
		24
		25	=== Kicking Horse Pass ===
		26
		27	To prevent collisions on the track, a special controller manages the rights to enter or leave the Kicking Horse Pass.
		28
		29	[[image:attach:Mutex_KH.png]]
		30
		31	The controller splits the pass into two parts, //left// and //right//, corresponding to the track layout chart. [[(Simplified track layout)>>url:http://www.informatik.uni-kiel.de/~~railway/Downloads/kscheme.pdf\|\|shape="rect"]]
		32
		33	Each part has two operational modes, //in// and //out//, being active when trains are allowed to either enter or leave the pass. When entering the pass the controller counts the entering trains and only lets two trains enter (one after the other). When leaving the pass the trains are removed from the counter, freeing space for the next train.
		34
		35	== Train controller ==
		36
		37	Each train controller is set in a separate region with a referenced state. This state has the following interface
		38
		39
		40	\\\\\\\\
		41
		42	{{{ input int _perm; # All permission variables (Tracks) input bool _perm # KH permission variables input int trainNum; input bool cleanup; input bool debug; output bool *_req[]; # All request variables}}}
		43
		44	The train controller is composed of several //Station-2-Station// controllers. These are combined to form a complete schedule. Additionally the cleanup signal has to be watched to abort the schedule and return back to the initial position.
		45
		46	== Station-2-Station controller ==
		47
		48	Each station-2-station controller realizes the movement from one of the stations (IC,OC,KH) to a second station. All controllers using IC or OC parts have to respect the traveling directions. For the Kicking Horse Pass two separate controllers, forwards and backwards, are used.
		49
		50	The controllers starting from Kicking Horse Pass Station make an assumption of the direction of the train. These are dependent of the directions of the inner or outer circle, e.g. the KHIC controller starts backwards because this is the only valid direction to travel this path. To drive a train from the Kicking Horse Station (facing forward) to the Inner Circle we have to combine the KHOC and OCIC controllers.
		51
		52	[[image:attach:ICIC.png]]
		53
		54	When arriving on a station the train controller must first call the function //void railArrival(int train, int station)//. This starts the waiting timer for the train.
		55	Next the train must wait for// int railDeparture(int train)// to return 1.
		56	After the waiting has finished the controller can reach a final state and pass the control back to the train controller.
		57
		58	=== Structure ===
		59
		60	\|=(((
		61	{{{input int *_perm;}}}
		62
		63	{{{output bool *_req[11];}}}
		64
		65	{{{input int trainNum;}}}
		66
		67	{{{input int depTrack;}}}
		68
		69	{{{input int destTrack;}}}
		70
		71	{{{input bool cleanup;}}}
		72
		73	{{{input bool debug;}}}
		74
		75	{{{output int arrTrack;}}}
		76
		77	{{{int i_arrOnTrack;}}}
		78
		79	{{{ }}}
		80
		81	{{{initial state *_ST {}}}
		82
		83	{{{ entry debug / 'println([trainNum][ST-ST] ... )';}}}
		84
		85	{{{ }}}
		86
		87	{{{ initial state waitForPerm {}}}
		88
		89	{{{ entry / *_ST_4_req[trainNum] = true;}}}
		90
		91	{{{ entry / *_LN_0_req[trainNum] = true;}}}
		92
		93	{{{ }}}}
		94
		95	{{{ --> gotPerm with (_ST_4_perm == trainNum) & (_LN_0_perm == trainNum)}}}
		96
		97	{{{ --> backOff with (_ST_4_perm == trainNum) \| (_LN_0_perm == trainNum);}}}
		98
		99	{{{ }}}
		100
		101	{{{ state backOff}}}
		102
		103	{{{ --> backOff1;}}}
		104
		105	{{{ }}}
		106
		107	{{{ state backOff1 {}}}
		108
		109	{{{entry / *_ST_4_req[trainNum] = false;}}}
		110
		111	{{{entry / *_LN_0_req[trainNum] = false;}}}
		112
		113	{{{ }}}}
		114
		115	{{{ --> waitForPerm;}}}
		116
		117	{{{ }}}
		118
		119	{{{final state gotPerm;}}}
		120
		121	{{{}}}}
		122
		123	{{{>-> Dep_*_ST;}}}
		124
		125	{{{ }}}
		126
		127	{{{state Dep_IC_ST {}}}
		128
		129	{{{ entry / 'railPoint(*,STRAIGHT)';}}}
		130
		131	{{{ entry / 'railSignal(*_LN_0, FWD, RED)';}}}
		132
		133	{{{ entry / 'railTrack(*_LN_0,FWD,trainNum,NORMAL)';}}}
		134
		135	{{{ entry / 'railTrack(*_ST_4,FWD,trainNum,NORMAL)';}}}
		136
		137	{{{ entry depTrack == 1 / 'railSignal(*_ST_1, FWD, GREEN)';}}}
		138
		139	{{{ entry depTrack == 2 / 'railSignal(*_ST_2, FWD, GREEN)';}}}
		140
		141	{{{ entry depTrack == 3 / 'railSignal(*_ST_3, FWD, GREEN)';}}}
		142
		143	{{{ ..........}}}
		144
		145	{{{ } --> _LN_0 with 'railContact(_LN_0,0)';}}}
		146
		147	{{{ }}}
		148
		149	{{{ state *_LN_0 {}}}
		150
		151	{{{ entry / 'println("[trainNum][ST-ST] Entering *_LN_0")';}}}
		152
		153	{{{ entry debug / 'println("[trainNum][ST-ST] Requesting permission for *_LN_1")';}}}
		154
		155	{{{ entry depTrack == 1 / 'railSignal(*_ST_1, FWD, RED)';}}}
		156
		157	{{{ entry depTrack == 2 / 'railSignal(*_ST_2, FWD, RED)';}}}
		158
		159	{{{ entry depTrack == 3 / 'railSignal(*_ST_3, FWD, RED)';}}}
		160
		161	{{{ entry / *_LN_1_req[trainNum] = true;}}}
		162
		163	{{{ }}}
		164
		165	{{{ region Travel:}}}
		166
		167	{{{ initial state Entry}}}
		168
		169	{{{ --> Continue with 'railContact(_LN_0,0)' & (_LN_1_perm == trainNum)}}}
		170
		171	{{{ --> Slowdown with 'railContact(*_LN_0,0)';}}}
		172
		173	{{{ }}}
		174
		175	{{{ state Slowdown {}}}
		176
		177	{{{ entry debug / 'println("[trainNum][ST-ST] Slowing down on *_LN_0")';}}}
		178
		179	{{{ entry / 'railTrack(*_LN_0,FWD,trainNum,CAUTION)';}}}
		180
		181	{{{ }}}}
		182
		183	{{{ --> Waiting with 'railContact(*_LN_0,1)'}}}
		184
		185	{{{ --> Continue with *_LN_1_perm == trainNum;}}}
		186
		187	{{{ }}}
		188
		189	{{{ state Waiting {}}}
		190
		191	{{{ entry debug / 'println("[trainNum][ST-ST] Stopping on *_LN_0")';}}}
		192
		193	{{{ entry / 'railTrackBrake(*_LN_0)';}}}
		194
		195	{{{ }}}}
		196
		197	{{{ --> Continue with *_LN_1_perm == trainNum;}}}
		198
		199	{{{ }}}
		200
		201	{{{ final state Continue {}}}
		202
		203	{{{ entry debug / 'println("[trainNum][ST-ST] Continuing on *_LN_0")';}}}
		204
		205	{{{ entry / 'railSignal(*_LN_0,FWD,GREEN)';}}}
		206
		207	{{{ entry / 'railTrack(*_LN_0,FWD,trainNum,NORMAL)';}}}
		208
		209	{{{ entry / 'railTrack(*_LN_1,FWD,trainNum,NORMAL)';}}}
		210
		211	{{{ entry / 'railSignal(*_LN_1, FWD, RED)';}}}
		212
		213	{{{ };}}}
		214
		215	{{{ }}}
		216
		217	{{{ region Cleanup:}}}
		218
		219	{{{ initial state Entry}}}
		220
		221	{{{ --> cleanup with 'railContact(*_LN_0,0)';}}}
		222
		223	{{{ }}}
		224
		225	{{{ final state cleanup {}}}
		226
		227	{{{ entry debug / 'println("[trainNum][ST-ST] Entered *_LN_0 completely")';}}}
		228
		229	{{{ entry / 'railTrackOff(*_ST_4)';}}}
		230
		231	{{{ entry / *_ST_4_req[trainNum] = false;}}}
		232
		233	{{{ };}}}
		234
		235	{{{ }>-> _LN_0__LN_1;}}}
		236
		237	{{{ }}}
		238
		239	{{{ state IC_LN_0_IC_LN_1}}}
		240
		241	{{{ --> IC_LN_1 with 'railContact(IC_LN_1,0)';}}}
		242
		243	{{{ }}}
		244
		245	{{{// ...................}}}
		246
		247	{{{// Set of track segment controlling states such as before}}}
		248
		249	{{{// ...................}}}
		250
		251	{{{ }}}
		252
		253	{{{state *_LN_5 {}}}
		254
		255	{{{ int perm_all_next_segments = false;}}}
		256
		257	{{{ entry / 'println("[trainNum][ST-ST] Entering *_LN_5")';}}}
		258
		259	{{{ entry / 'railSignal(*_LN_4, FWD, RED)';}}}
		260
		261	{{{ }}}
		262
		263	{{{ region Travel:}}}
		264
		265	{{{ initial state Entry}}}
		266
		267	{{{ --> Continue with 'railContact(*_LN_5,0)' & perm_all_next_segments}}}
		268
		269	{{{ --> Slowdown with 'railContact(*_LN_5,0)';}}}
		270
		271	{{{ }}}
		272
		273	{{{ state Slowdown {}}}
		274
		275	{{{ entry debug / 'println("[trainNum][ST-ST] Slowing down on *_LN_5")';}}}
		276
		277	{{{ entry / 'railTrack(*_LN_5,FWD,trainNum,CAUTION)';}}}
		278
		279	{{{ }}}}
		280
		281	{{{ --> Waiting with 'railContact(*_LN_5,1)'}}}
		282
		283	{{{ --> Continue with perm_all_next_segments;}}}
		284
		285	{{{ }}}
		286
		287	{{{ state Waiting {}}}
		288
		289	{{{ entry debug / 'println("[trainNum][ST-ST] Stopping on *_LN_5")';}}}
		290
		291	{{{ entry / 'railTrackBrake(*_LN_5)';}}}
		292
		293	{{{ }}}}
		294
		295	{{{ --> Continue with perm_all_next_segments;}}}
		296
		297	{{{ }}}
		298
		299	{{{ final state Continue {}}}
		300
		301	{{{ entry debug / 'println("[trainNum][ST-ST] Continuing on *_LN_5")'; }}}
		302
		303	{{{ entry i_arrOnTrack == 1 / 'railTrack(*_ST_1,FWD,trainNum,NORMAL)';}}}
		304
		305	{{{ entry i_arrOnTrack == 2 / 'railTrack(*_ST_2,FWD,trainNum,NORMAL)';}}}
		306
		307	{{{ entry i_arrOnTrack == 3 / 'railTrack(*_ST_3,FWD,trainNum,NORMAL)';}}}
		308
		309	{{{ ----------}}}
		310
		311	{{{ entry / arrTrack = i_arrOnTrack;}}}
		312
		313	{{{ };}}}
		314
		315	{{{ }}}
		316
		317	{{{ region Cleanup:}}}
		318
		319	{{{ initial state Entry}}}
		320
		321	{{{ --> cleanup with 'railContact(*_LN_5,0)';}}}
		322
		323	{{{ }}}
		324
		325	{{{ final state cleanup {}}}
		326
		327	{{{ entry debug / 'println("[trainNum][ST-ST] Entered *_LN_5 completely")';}}}
		328
		329	{{{ entry / 'railTrackOff(*_LN_4)';}}}
		330
		331	{{{ entry / *_LN_4_req[trainNum] = false;}}}
		332
		333	{{{ };}}}
		334
		335	{{{ }}}
		336
		337	{{{ region Permissions:}}}
		338
		339	{{{ initial state checking {}}}
		340
		341	{{{ entry / *_ST_0_req[trainNum] = true;}}}
		342
		343	{{{ entry destTrack == 1 \| !cleanup / *_ST_1_req[trainNum] = true;}}}
		344
		345	{{{ entry destTrack == 2 \| !cleanup / *_ST_2_req[trainNum] = true;}}}
		346
		347	{{{ entry destTrack == 3 \| !cleanup / *_ST_3_req[trainNum] = true;}}}
		348
		349	{{{ }}}}
		350
		351	\\
		352
		353	{{{ --> success with destTrack == 1 & _ST_0_perm == trainNum & _ST_1_perm == trainNum / i_arrOnTrack = 1}}}
		354
		355	\\
		356
		357	{{{ --> success with destTrack == 2 & _ST_0_perm == trainNum & _ST_2_perm == trainNum / i_arrOnTrack = 2}}}
		358
		359	\\
		360
		361	{{{ --> success with destTrack == 3 & _ST_0_perm == trainNum & _ST_3_perm == trainNum / i_arrOnTrack = 3}}}
		362
		363	{{{ --> success with _ST_0_perm == trainNum & _ST_1_perm == trainNum / i_arrOnTrack = 1}}}
		364
		365	{{{ --> success with _ST_0_perm == trainNum & _ST_2_perm == trainNum / i_arrOnTrack = 2}}}
		366
		367	{{{ --> success with _ST_0_perm == trainNum & _ST_3_perm == trainNum / i_arrOnTrack = 3}}}
		368
		369
		370	\\
		371
		372	{{{ --> resolving with _ST_0_perm == trainNum \| _ST_3_perm == trainNum \| _ST_2_perm == trainNum \| _ST_1_perm == trainNum;}}}
		373
		374	{{{ }}}
		375
		376	{{{ state resolving}}}
		377
		378	{{{ --> resolving1;}}}
		379
		380	{{{ }}}
		381
		382	{{{ state resolving1 {}}}
		383
		384	{{{ entry / *_ST_0_req[trainNum] = false;}}}
		385
		386	{{{ entry / *_ST_1_req[trainNum] = false;}}}
		387
		388	{{{ entry / *_ST_2_req[trainNum] = false;}}}
		389
		390	{{{ entry / *_ST_3_req[trainNum] = false;}}}
		391
		392	{{{ }}}}
		393
		394	{{{ --> checking;}}}
		395
		396	{{{ }}}
		397
		398	{{{ state success}}}
		399
		400	{{{ --> success1;}}}
		401
		402	{{{ }}}
		403
		404	{{{ final state success1 {}}}
		405
		406	{{{ entry !(i_arrOnTrack == 1) / *_ST_1_req[trainNum] = false; }}}
		407
		408	{{{ entry !(i_arrOnTrack == 2) / *_ST_2_req[trainNum] = false;}}}
		409
		410	{{{ entry !(i_arrOnTrack == 3) / *_ST_3_req[trainNum] = false;}}}
		411
		412	{{{ entry / perm_all_next_segments = true;}}}
		413
		414	{{{ };}}}
		415
		416	{{{ }>-> _LN_5__ST;}}}
		417
		418	{{{ }}}
		419
		420	{{{ state _LN_5__ST}}}
		421
		422	{{{ --> Arr__ST with i_arrOnTrack == 1 & 'railContact(_ST_1,0)'}}}
		423
		424	{{{ --> Arr__ST with i_arrOnTrack == 2 & 'railContact(_ST_2,0)'}}}
		425
		426	{{{ --> Arr__ST with i_arrOnTrack == 3 & 'railContact(_ST_3,0)';}}}
		427
		428	{{{ }}}
		429
		430	{{{ state Arr_*_ST {}}}
		431
		432	{{{ entry / 'railSignal(*_LN_5, FWD, RED)';}}}
		433
		434	{{{ entry / 'railTrackOff(*C_LN_5)';}}}
		435
		436	{{{ entry / 'railTrack(*_ST_0,FWD,trainNum,SLOW)';}}}
		437
		438	{{{ entry i_arrOnTrack == 1 / 'railTrack(*_ST_1,FWD,trainNum,SLOW)';}}}
		439
		440	{{{ entry i_arrOnTrack == 2 / 'railTrack(*_ST_2,FWD,trainNum,SLOW)';}}}
		441
		442	{{{ entry i_arrOnTrack == 3 / 'railTrack(*_ST_3,FWD,trainNum,SLOW)';}}}
		443
		444	{{{ entry / *_LN_5_req[trainNum] = false;}}}
		445
		446	{{{ }}}
		447
		448	{{{ initial state SlowEntry}}}
		449
		450	{{{ --> Slow with i_arrOnTrack == 1 & 'railContact(*_ST_1,0)'}}}
		451
		452	{{{ --> Slow with i_arrOnTrack == 2 & 'railContact(*_ST_2,0)'}}}
		453
		454	{{{ --> Slow with i_arrOnTrack == 3 & 'railContact(*_ST_3,0)';}}}
		455
		456	{{{ }}}
		457
		458	{{{ state Slow {}}}
		459
		460	{{{ entry / 'railTrackOff(*_ST_0)';}}}
		461
		462	{{{ entry / *_ST_0_req[trainNum] = false;}}}
		463
		464	{{{ }}}}
		465
		466	{{{ --> Halt with i_arrOnTrack == 1 & 'railContact(*_ST_1,1)'}}}
		467
		468	{{{ --> Halt with i_arrOnTrack == 2 & 'railContact(*_ST_2,1)'}}}
		469
		470	{{{ --> Halt with i_arrOnTrack == 3 & 'railContact(*_ST_3,1)';}}}
		471
		472	{{{ }}}
		473
		474	{{{ final state Halt {}}}
		475
		476	{{{ entry i_arrOnTrack == 1 / 'railTrackBrake(*_ST_1)';}}}
		477
		478	{{{ entry i_arrOnTrack == 2 / 'railTrackBrake(*_ST_2)';}}}
		479
		480	{{{ entry i_arrOnTrack == 3 / 'railTrackBrake(*_ST_3)';}}}
		481
		482	{{{ entry i_arrOnTrack == 1 / 'railArrival(trainNum, *_ST_1)';}}}
		483
		484	{{{ entry i_arrOnTrack == 2 / 'railArrival(trainNum, *_ST_2)';}}}
		485
		486	{{{ entry i_arrOnTrack == 3 / 'railArrival(trainNum, *_ST_3)';}}}
		487
		488	{{{ };}}}
		489
		490	{{{ }}}}
		491
		492	{{{ >-> done;}}}
		493
		494	{{{ }}}
		495
		496	{{{ state done}}}
		497
		498	{{{ --> reallyDone with 'railDeparture(trainNum)';}}}
		499
		500	{{{ }}}
		501
		502	{{{ final state reallyDone;}}}
		503	)))\|=(((
		504	~/~/ All permissiions variables
		505
		506	~/~/ All request variables
		507
		508	~/~/ Train number
		509
		510	~/~/ Departure track number
		511
		512	~/~/ Destination track number
		513
		514	~/~/ Cleanup flag for selecting the track of destination
		515
		516	~/~/ Debug flag for additional output
		517
		518	~/~/ Arrival track
		519
		520	~/~/ Variable (arrival track) for selecting correct station elements
		521
		522
		523
		524	~/~/ Handles departing from a station
		525
		526	~/~/ Additional output for debugging
		527
		528
		529
		530	~/~/ State, which set requests for needed tracks
		531
		532
		533
		534
		535
		536
		537
		538	~/~/ Transition for received all needed permissions
		539
		540	~/~/ Tranisition for received some needed permissions
		541
		542
		543
		544	~/~/ State for waiting an additional Tick
		545
		546
		547
		548
		549
		550	~/~/ State, which releases the requests for needed tracks
		551
		552
		553
		554
		555
		556
		557
		558	~/~/ Transition to trying the requesting again
		559
		560
		561
		562
		563
		564
		565
		566	~/~/ Transition to the departure state
		567
		568
		569
		570	~/~/ State, which handles the train departure
		571
		572	~/~/ Set of entry-Actions to set tracks, points and signals according to depTrack
		573
		574
		575
		576
		577
		578
		579
		580
		581
		582
		583
		584
		585
		586
		587	~/~/ Transition to next track segment, if contact is readed
		588
		589
		590
		591	~/~/ State for handling the train on track *_LN_0
		592
		593	~/~/ Outputs for debugging
		594
		595
		596
		597	~/~/ Entry-Actions to set the previous signals to RED
		598
		599
		600
		601
		602
		603	~/~/ Requesting the next segment
		604
		605
		606
		607	~/~/ Region for handling train driving
		608
		609
		610
		611	~/~/ Transition to continuing state, if permitted
		612
		613	~/~/ Transition to slowing down else
		614
		615
		616
		617	~/~/ State for slowing down
		618
		619	~/~/ Addtitional output for debugging
		620
		621	~/~/ Entry-Action for slowing down the train
		622
		623
		624
		625	~/~/ Transition to waiting state
		626
		627	~/~/ Transition to continuing state, if permitted
		628
		629
		630
		631	~/~/ Waiting state
		632
		633	~/~/ Addtitional output for debugging
		634
		635	~/~/ Entry-Action for stopping the train
		636
		637
		638
		639	~/~/ Tranisition to continuing state
		640
		641
		642
		643	~/~/ State to continuing driving on the track
		644
		645	~/~/ Addtitional output for debugging
		646
		647	~/~/ Entry-Actions to set tracks and signals for driving
		648
		649
		650
		651
		652
		653
		654
		655
		656
		657
		658
		659	~/~/ Region for handling cleanup-functionalities
		660
		661
		662
		663	~/~/ Transition to cleanup state
		664
		665
		666
		667	~/~/ Cleanup state
		668
		669	~/~/ Addtitional output for debugging
		670
		671	~/~/ Entry-Action to switching off the previous track
		672
		673	~/~/ Entry-Action to release the previous track
		674
		675
		676
		677	~/~/ Transition to transitional state
		678
		679
		680
		681	~/~/ Transitional state
		682
		683	~/~/ Transition to next track segment, if contact is readed
		684
		685
		686
		687
		688
		689
		690
		691
		692
		693
		694
		695	~/~/ State for entering a station
		696
		697	~/~/ Variable for checking all needed permissions
		698
		699	~/~/ Output
		700
		701	~/~/ Setting signal to RED
		702
		703
		704
		705	~/~/ Region for handling train driving
		706
		707
		708
		709	~/~/ Transition to continuing state, if permitted
		710
		711	~/~/ Transition to slowing down else
		712
		713
		714
		715	~/~/ State for slowing down
		716
		717	~/~/ Addtitional output for debugging
		718
		719	~/~/ Entry-Action for slowing down the train
		720
		721
		722
		723	~/~/ Transition to waiting state
		724
		725	~/~/ Transition to continuing state, if permitted
		726
		727
		728
		729	~/~/ Waiting state
		730
		731	~/~/ Addtitional output for debugging
		732
		733	~/~/ Entry-Action for stopping the train
		734
		735
		736
		737	~/~/ Tranisition to continuing state
		738
		739
		740
		741	~/~/ State to continuing driving on the track
		742
		743	~/~/ Addtitional output for debugging
		744
		745	~/~/ Set of entry-Actions for setting tracks, points and signals according to i_arrOnTrack
		746
		747
		748
		749
		750
		751
		752
		753	~/~/ Setting the arrival track (output)
		754
		755
		756
		757
		758
		759	~/~/ Region for handling cleanup-functionalities
		760
		761
		762
		763	~/~/ Transition to cleanup state
		764
		765
		766
		767	~/~/ Cleanup state
		768
		769	~/~/ Addtitional output for debugging
		770
		771	~/~/ Entry-Action to switching off the previous tracks
		772
		773	~/~/ Entry-Action to release the previous tracks
		774
		775
		776
		777
		778
		779	~/~/ Region for handling permissions of all needed tracks
		780
		781	~/~/ State for requesting all needed tracks according to destination track and cleanup-Flag
		782
		783
		784
		785
		786
		787
		788
		789
		790
		791
		792
		793	~/~/ Transitions for permitted tracks match wished tracks
		794
		795
		796
		797
		798
		799	~/~/ Transitions for permitted tracks don't match wished tracks
		800
		801
		802
		803
		804
		805	~/~/ Transition for not all tracks permitted
		806
		807
		808
		809	~/~/ State for waiting an additional tick
		810
		811
		812
		813
		814
		815	~/~/ State for releasing track requests
		816
		817
		818
		819
		820
		821
		822
		823
		824
		825
		826
		827	~/~/ Transition for trying the requesting again
		828
		829
		830
		831	~/~/ State for waiting an additional tick
		832
		833
		834
		835
		836
		837	~/~/ State for releasing not used track requests and
		838
		839
		840
		841
		842
		843
		844
		845	~/~/ Settting perm_all_next_segments to true
		846
		847
		848
		849	~/~/ Transition to station entry states
		850
		851
		852
		853	~/~/ State waiting for station entry
		854
		855
		856
		857
		858
		859
		860
		861
		862
		863	~/~/ State for setting tracks, points and signals according to i_arrOnTrack
		864
		865	~/~/ and releasing previous track request
		866
		867
		868
		869
		870
		871
		872
		873
		874
		875
		876
		877
		878
		879
		880
		881	~/~/ State for slowing down, if train completely on track
		882
		883
		884
		885
		886
		887
		888
		889
		890
		891	~/~/ State for switching off previous track and releasing the request
		892
		893
		894
		895
		896
		897
		898
		899	~/~/ Transitions to halt states, if train at second contact of a track
		900
		901
		902
		903
		904
		905
		906
		907
		908
		909	~/~/ Entry-Actions for braking the train on correct track
		910
		911
		912
		913
		914
		915	~/~/ Entry-Actions for waiting for timer on correct track
		916
		917
		918
		919
		920
		921
		922
		923
		924
		925
		926
		927
		928
		929
		930
		931	~/~/ Transition to final state, if timer is ready
		932	)))

Wiki source code of Basic design

Navigation

Quick Links