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
|
-- lzb.lua
-- Enforced and/or automatic train override control, obeying signals
--[[
Documentation of train.lzb table
train.lzb = {
trav = Current index that the traverser has advanced so far
travsht = boolean indicating whether the train will be a shunt move at "trav"
travspd = speed restriction at end of traverser
travwspd = warning speed res.
oncoming = table containing oncoming signals, in order of appearance on the path
{
pos = position of the signal (not the IP!)
idx = where this is on the path
spd = speed allowed to pass (determined dynamically)
}
}
each step, for every item in "oncoming", we need to determine the location to start braking (+ some safety margin)
and, if we passed this point for at least one of the items, initiate brake.
When speed has dropped below, say 3, decrease the margin to zero, so that trains actually stop at the signal IP.
The spd variable and travsht need to be updated on every aspect change. it's probably best to reset everything when any aspect changes
The traverser stops at signals that result in spd==0, because changes beyond there are likely.
]]
local il = advtrains.interlocking
local BRAKE_SPACE = 10
local AWARE_ZONE = 50
local ADD_STAND = 2
local ADD_SLOW = 1
local ADD_FAST = 7
local ZONE_ROLL = 2
local ZONE_HOLD = 5 -- added on top of ZONE_ROLL
local ZONE_VSLOW = 2 -- When speed is <2, still allow accelerating
local SHUNT_SPEED_MAX = 4
local function look_ahead(id, train)
local acc = advtrains.get_acceleration(train, 1)
local vel = train.velocity
local brakedst = -(vel*vel) / (2*acc)
local brake_i = advtrains.path_get_index_by_offset(train, train.index, brakedst + BRAKE_SPACE)
--local aware_i = advtrains.path_get_index_by_offset(train, brake_i, AWARE_ZONE)
local lzb = train.lzb
local trav = lzb.trav
local travspd = lzb.travspd
local travwspd = lzb.travwspd
local lspd
--train.debug = lspd
while trav <= brake_i and (not lspd or lspd>0) do
trav = trav + 1
local pos = advtrains.path_get(train, trav)
local pts = advtrains.roundfloorpts(pos)
local cn = train.path_cn[trav]
-- check offtrack
if trav > train.path_trk_f then
lspd = 0
table.insert(lzb.oncoming, {
idx = trav-1,
spd = 0,
})
else
-- check for signal
local asp, spos = il.db.get_ip_signal_asp(pts, cn)
--atdebug("trav: ",pos, cn, asp, spos, "travsht=", lzb.travsht)
if asp then
local nspd = 0
--interpreting aspect and determining speed to proceed
if lzb.travsht then
--shunt move
if asp.shunt.free then
nspd = SHUNT_SPEED_MAX
elseif asp.shunt.proceed_as_main and asp.main.free then
nspd = asp.main.speed
lzb.travsht = false
end
else
--train move
if asp.main.free then
nspd = asp.main.speed
elseif asp.shunt.free then
nspd = SHUNT_SPEED_MAX
lzb.travsht = true
end
end
-- nspd can now be: 1. !=0: new speed restriction, 2. =0: stop here or 3. nil: keep travspd
if nspd then
if nspd == -1 then
travspd = nil
else
travspd = nspd
end
end
local nwspd = asp.info.w_speed
if nwspd then
if nwspd == -1 then
travwspd = nil
else
travwspd = nwspd
end
end
--atdebug("ns,wns,ts,wts", nspd, nwspd, travspd, travwspd)
lspd = travspd
if travwspd and (not lspd or lspd>travwspd) then
lspd = travwspd
end
table.insert(lzb.oncoming, {
pos = spos,
idx = trav,
spd = lspd,
})
end
end
end
lzb.trav = trav
lzb.travspd = travspd
lzb.travwspd = travwspd
--train.debug = dump(lzb)
end
--[[
Distance needed to accelerate from v0 to v1 with constant acceleration a:
v1 - v0 a / v1 - v0 \ 2
s = v0 * ------- + - * | ------- |
a 2 \ a /
]]
local function apply_control(id, train)
local lzb = train.lzb
local i = 1
while i<=#lzb.oncoming do
if lzb.oncoming[i].idx < train.index then
train.speed_restriction = lzb.oncoming[i].spd
table.remove(lzb.oncoming, i)
else
i = i + 1
end
end
for i, it in ipairs(lzb.oncoming) do
local a = advtrains.get_acceleration(train, 1) --should be negative
local v0 = train.velocity
local v1 = it.spd
if v1 and v1 <= v0 then
local f = (v1-v0) / a
local s = v0*f + a*f*f/2
local st = s + ADD_SLOW
if v0 > 3 then
st = s + ADD_FAST
end
if v0<=0 then
st = s + ADD_STAND
end
local i = advtrains.path_get_index_by_offset(train, it.idx, -st)
--train.debug = dump({v0f=v0*f, aff=a*f*f,v0=v0, v1=v1, f=f, a=a, s=s, st=st, i=i, idx=train.index})
if i <= train.index then
-- Gotcha! Braking...
train.ctrl.lzb = 1
--train.debug = train.debug .. "BRAKE!!!"
return
end
if v1==0 and v0<2 then
i = advtrains.path_get_index_by_offset(train, i, -ZONE_VSLOW)
if i <= train.index then
-- roll control
train.ctrl.lzb = 2
return
end
else
i = advtrains.path_get_index_by_offset(train, i, -ZONE_ROLL)
if i <= train.index then
-- roll control
train.ctrl.lzb = 2
return
end
i = advtrains.path_get_index_by_offset(train, i, -ZONE_HOLD)
if i <= train.index then
-- hold speed
train.ctrl.lzb = 3
return
end
end
end
end
train.ctrl.lzb = nil
end
local function invalidate(train)
train.lzb = {
trav = atfloor(train.index),
travsht = train.is_shunt,
oncoming = {}
}
train.ctrl.lzb = nil
end
function advtrains.interlocking.lzb_invalidate(train)
invalidate(train)
end
advtrains.te_register_on_new_path(function(id, train)
invalidate(train)
look_ahead(id, train)
end)
advtrains.te_register_on_update(function(id, train)
look_ahead(id, train)
apply_control(id, train)
end)
|
