joylink/rts-sim-testing-service
6
0
Fork 0
Code Issues 8 Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: joylink:58ebf3842a150361ee5f7f732a97993f2a853823
Branches Tags
joylink:master
joylink:develop
joylink:local-test
...
compare: joylink:844560ae1e71949361dd034ede3555fa24a37e14
Branches Tags
joylink:develop
joylink:local-test
joylink:master

2 Commits
58ebf3842a ... 844560ae1e

Author SHA1 Message Date
thesai
844560ae1e Merge remote-tracking branch 'origin/develop' into develop 
# Conflicts:
#	rts-sim-module
 2024-08-07 14:54:37 +08:00
thesai
5fa5345981 [补充]11号线联锁通信 2024-08-07 14:53:57 +08:00
10 changed files with 710 additions and 433 deletions
Show Stats Expand all files Collapse all files

1
config/config.go
View File

@ -126,6 +126,7 @@ type InterlockConfig struct {
RemotePort int `json:"remotePort" description:"远端接收采集信息端口"` RemotePort int `json:"remotePort" description:"远端接收采集信息端口"`
Code string `json:"code" description:"所属集中站"` Code string `json:"code" description:"所属集中站"`
Line string `json:"line" description:"联锁通信协议所属线路"` Line string `json:"line" description:"联锁通信协议所属线路"`
Period int `json:"period" description:"采集任务执行周期（ms）"`
} }
type ElectricMachineryConfig struct { type ElectricMachineryConfig struct {
Ip string `json:"ip" description:"IP配置"` Ip string `json:"ip" description:"IP配置"`

2
rts-sim-module

@ -1 +1 @@
Subproject commit 8c6bfb2aeec50afc347b6276b9f8012072811b7e Subproject commit efa7d1655ed781512c8b0ce56685954fa3cc9903

2
rts-sim-testing-message

@ -1 +1 @@
Subproject commit 0c2a7613104f859e83091d1f6379e6e2fa1990ad Subproject commit 47ecc9c79f31758a6421dab4a7099690a3c7b649

180
third_party/interlock/beijing11/msg.go vendored
View File

@ -4,11 +4,24 @@ import (
"encoding/binary" "encoding/binary"
) )
const ( //不知道对不对，问也不回，先瞎写吧
ON = 0x55 //按钮-按下；道岔-定位；屏蔽门-关门；计轴区段-占用
OFF = 0xAA //按钮-抬起；道岔-反位；屏蔽门-开门；计轴区段-出清
)
func GetStateByte(state bool) byte {
if state {
return ON
} else {
return OFF
}
}
// FromInterlockFrame 来自联锁的数据帧 // FromInterlockFrame 来自联锁的数据帧
type FromInterlockFrame struct { type FromInterlockFrame struct {
Len uint16 Len uint16
InterlockCode uint16 //联锁ID InterlockCode uint16 //联锁编号（联锁->轨旁：OC的编号，轨旁->联锁：联锁站编号）
WaysideCode uint16 //轨旁ID WaysideCode uint16 //轨旁编号
TurnoutData *DeviceData //道岔数据 TurnoutData *DeviceData //道岔数据
PSDData *DeviceData //屏蔽门数据 PSDData *DeviceData //屏蔽门数据
ESBData *ESBData //紧急停车按钮数据 ESBData *ESBData //紧急停车按钮数据
@ -187,75 +200,66 @@ type DeviceCmd struct {
// ToInterlockFrame 发往联锁的数据帧 // ToInterlockFrame 发往联锁的数据帧
type ToInterlockFrame struct { type ToInterlockFrame struct {
Len uint16 WaysideCode uint16
WaysideCode uint16 InterlockCode uint16
InterlockCode uint16 TurnoutStates []*TurnoutState //道岔状态
TurnoutData *ToInterlockTurnoutData //道岔数据 PsdStates []*PSDState //屏蔽门状态
PSDData *ToInterlockPSDData //屏蔽门数据 ESBStates []*ESBState //紧急停车按钮状态
ESBData *ToInterlockESBData //紧急停车按钮数据 //HoldTrainData []*HoldTrainState //扣车按钮状态（数量0）
HoldTrainData *ToInterlockHoldTrainData //扣车按钮数据 SignalStates []*SignalState //信号机状态
SignalData *ToInterlockSignalData //信号机数据 AxleSectionStates []*AxleSectionState //计轴区段状态
AxleSectionData *ToInterlockAxleSectionData //计轴区段数据 //WrzfData []*WrzfState //无人折返状态（数量0）
WrzfData *ToInterlockWrzfData //无人折返数据 //FymData []*FymState //防淹门状态（数量0）
FymData *ToInterlockFymData //防淹门数据 SPKSStates []*SPKSState //SPKS状态
SPKSData *ToInterlockSPKSData //SPKS数据 //CkmData []*CkmState //车库门状态（数量0）
CkmData *ToInterlockCkmData //车库门数据 //XcjData []*XcjState //洗车机状态（无）
XcjData *ToInterlockXcjData //洗车机数据
} }
type ToInterlockTurnoutData struct { func (t *ToInterlockFrame) encode() []byte {
Num uint16 //该联锁集中区包含的道岔数量 data := make([]byte, 0, 128)
StateList []*TurnoutState data = append(data, 0x83) //报文类型
} data = append(data, 0, 0) //报文长度占位
data = binary.BigEndian.AppendUint16(data, t.WaysideCode)
type ToInterlockPSDData struct { data = binary.BigEndian.AppendUint16(data, t.InterlockCode)
Num uint16 //该联锁集中区包含的屏蔽门数量 //道岔
StateList []*PSDState data = binary.BigEndian.AppendUint16(data, uint16(len(t.TurnoutStates)))
} for _, state := range t.TurnoutStates {
data = state.encode(data)
type ToInterlockESBData struct { }
Num uint16 //紧急停车按钮数量 //屏蔽门
StateList []*ESBState data = binary.BigEndian.AppendUint16(data, uint16(len(t.PsdStates)))
} for _, state := range t.PsdStates {
data = state.encode(data)
type ToInterlockHoldTrainData struct { }
Num uint16 //扣车数量 //紧急停车
StateList []*HoldTrainState data = binary.BigEndian.AppendUint16(data, uint16(len(t.ESBStates)))
} for _, state := range t.ESBStates {
data = state.encode(data)
type ToInterlockSignalData struct { }
Num uint16 //该联锁集中区信号机的数量 //扣车，数量0
StateList []*SignalState data = binary.BigEndian.AppendUint16(data, 0)
} //信号机状态
binary.BigEndian.AppendUint16(data, uint16(len(t.SignalStates)))
type ToInterlockAxleSectionData struct { for _, state := range t.SignalStates {
Num uint16 //该联锁集中区计轴区段的数量 data = state.encode(data)
StateList []*AxleSectionState }
} //计轴区段
binary.BigEndian.AppendUint16(data, uint16(len(t.AxleSectionStates)))
type ToInterlockWrzfData struct { for _, state := range t.AxleSectionStates {
Num uint16 //该联锁集中区无人折返的数量 data = state.encode(data)
StateList []*WrzfState }
} //无人折返，数量0
data = binary.BigEndian.AppendUint16(data, 0)
type ToInterlockFymData struct { //防淹门，数量0
Num uint16 //该联锁集中区防<E58CBA><E998B2>门的数量 data = binary.BigEndian.AppendUint16(data, 0)
StateList []*FymState //SPKS
} data = binary.BigEndian.AppendUint16(data, uint16(len(t.SPKSStates)))
for _, state := range t.SPKSStates {
type ToInterlockSPKSData struct { data = state.encode(data)
Num uint16 //SPKS数量 }
StateList []*SPKSState //车库门，数量0
} data = binary.BigEndian.AppendUint16(data, 0)
return data
type ToInterlockCkmData struct {
Num uint16 //车库门数量
StateList []*CkmState
}
type ToInterlockXcjData struct {
Num uint16 //洗车机数量
StateList []*XcjState
} }
type TurnoutState struct { type TurnoutState struct {
@ -266,6 +270,12 @@ type TurnoutState struct {
Current2 byte //转辙机2电流值，单位A Current2 byte //转辙机2电流值，单位A
} }
func (s *TurnoutState) encode(data []byte) []byte {
data = binary.BigEndian.AppendUint16(data, s.Id)
data = append(data, s.State, s.Alarm, s.Current1, s.Current2)
return data
}
type PSDState struct { type PSDState struct {
Id uint16 //屏蔽门ID Id uint16 //屏蔽门ID
State byte //屏蔽门开关门状态 State byte //屏蔽门开关门状态
@ -275,11 +285,23 @@ type PSDState struct {
DPB byte //DPB状态 DPB byte //DPB状态
} }
func (s *PSDState) encode(data []byte) []byte {
data = binary.BigEndian.AppendUint16(data, s.Id)
data = append(data, s.State, s.Hsjc, s.PCB, s.POB, s.DPB)
return data
}
type ESBState struct { type ESBState struct {
Id uint16 //紧急停车ID Id uint16 //紧急停车ID
State byte //紧急停车按钮状态 State byte //紧急停车按钮状态
PlState byte //紧急停车按钮旁路状态 PlState byte //紧急停车按钮旁路状态
ESS byte //ESS状态（按下55，抬起aa） //ESS byte //ESS状态（按下55，抬起aa）（解析驱动数据，没有此状态对应的驱动）
}
func (s *ESBState) encode(data []byte) []byte {
data = binary.BigEndian.AppendUint16(data, s.Id)
data = append(data, s.State, s.PlState)
return data
} }
type HoldTrainState struct { type HoldTrainState struct {
@ -296,11 +318,23 @@ type SignalState struct {
Current byte //信号机当前亮灯的电流值 Current byte //信号机当前亮灯的电流值
} }
func (s *SignalState) encode(data []byte) []byte {
data = binary.BigEndian.AppendUint16(data, s.Id)
data = append(data, s.State, s.Current)
return data
}
type AxleSectionState struct { type AxleSectionState struct {
Id uint16 //计轴区段Id Id uint16 //计轴区段Id
State byte //计轴区段的采集状态 State byte //计轴区段的采集状态
} }
func (s *AxleSectionState) encode(data []byte) []byte {
data = binary.BigEndian.AppendUint16(data, s.Id)
data = append(data, s.State)
return data
}
type WrzfState struct { type WrzfState struct {
Id uint16 //无人折返ID Id uint16 //无人折返ID
State byte //无人折返的采集状态 State byte //无人折返的采集状态
@ -318,6 +352,12 @@ type SPKSState struct {
PlState byte //SPKSPL按钮状态 PlState byte //SPKSPL按钮状态
} }
func (s *SPKSState) encode(data []byte) []byte {
data = binary.BigEndian.AppendUint16(data, s.Id)
data = append(data, s.State, s.PlState)
return data
}
type CkmState struct { type CkmState struct {
Id uint16 //车库门ID Id uint16 //车库门ID
State byte //车库门采集状态 State byte //车库门采集状态

2
third_party/interlock/beijing11/msg_test.go vendored
View File

@ -43,7 +43,7 @@ func TestFromInterlockFrame_Decode(t *testing.T) {
} }
marshal, _ := json.Marshal(f) marshal, _ := json.Marshal(f)
fmt.Println(string(marshal)) fmt.Println(string(marshal))
//if f.InterlockCode != interlockCode { //if f.WaysideCode != interlockCode {
// t.Error() // t.Error()
//} //}
//if f.WaysideCode != waysideCode { //if f.WaysideCode != waysideCode {

70
third_party/interlock/beijing11/repo.go vendored
View File

@ -1,35 +1,49 @@
package beijing11 package beijing11
// StationDeviceIndexRepo 联锁站设备索引映射 // StationDeviceIndexTable 联锁站设备索引表
// key为联锁编号，val为uid type StationDeviceIndexTable struct {
type StationDeviceIndexRepo struct { StationName string //地图数据中车站的Code属性
StationName string WaysideCode string //通信数据中的“轨旁编号”
TurnoutMap map[uint32]string TurnoutMap map[uint32]*Row
PsdMap map[uint32]string PsdMap map[uint32]*Row
EsbMap map[uint32]string EsbMap map[uint32]*Row
HoldTrainMap map[uint32]string HoldTrainMap map[uint32]*Row
SignalMap map[uint32]string SignalMap map[uint32]*Row
AxleSectionMap map[uint32]string AxleSectionMap map[uint32]*Row
WrzfMap map[uint32]string WrzfMap map[uint32]*Row
FymMap map[uint32]string FymMap map[uint32]*Row
SpksMap map[uint32]string SpksMap map[uint32]*Row
CkmMap map[uint32]string CkmMap map[uint32]*Row
XcjMap map[uint32]string XcjMap map[uint32]*Row
} }
func NewStationDeviceIndexRepo() *StationDeviceIndexRepo { func NewStationDeviceIndexTable() *StationDeviceIndexTable {
return &StationDeviceIndexRepo{ return &StationDeviceIndexTable{
StationName: "", StationName: "",
TurnoutMap: make(map[uint32]string), WaysideCode: "",
PsdMap: make(map[uint32]string), TurnoutMap: make(map[uint32]*Row),
EsbMap: make(map[uint32]string), PsdMap: make(map[uint32]*Row),
HoldTrainMap: make(map[uint32]string), EsbMap: make(map[uint32]*Row),
SignalMap: make(map[uint32]string), HoldTrainMap: make(map[uint32]*Row),
AxleSectionMap: make(map[uint32]string), SignalMap: make(map[uint32]*Row),
WrzfMap: make(map[uint32]string), AxleSectionMap: make(map[uint32]*Row),
FymMap: make(map[uint32]string), WrzfMap: make(map[uint32]*Row),
SpksMap: make(map[uint32]string), FymMap: make(map[uint32]*Row),
CkmMap: make(map[uint32]string), SpksMap: make(map[uint32]*Row),
XcjMap: make(map[uint32]string), CkmMap: make(map[uint32]*Row),
XcjMap: make(map[uint32]*Row),
} }
} }
type Row struct {
commonId uint32 //地图中设备的ID
uid string //模型仓库中的设备模型ID
index uint16 //联锁通信中的设备ID
relateDeviceMap map[string]string //此设备关联的其它设备 key-查找设备所用的标识，val-uid
}
const (
POB = "POB"
PCB = "PCB"
DPB = "DPB"
)

409
third_party/interlock/beijing11/service.go vendored
View File

@ -2,133 +2,342 @@
package beijing11 package beijing11
import ( import (
"encoding/json" "context"
"fmt" "fmt"
"joylink.club/bj-rtsts-server/config" "joylink.club/bj-rtsts-server/config"
"joylink.club/bj-rtsts-server/dto/data_proto" "joylink.club/bj-rtsts-server/dto/data_proto"
"joylink.club/bj-rtsts-server/third_party/udp" "joylink.club/bj-rtsts-server/third_party/udp"
"joylink.club/bj-rtsts-server/ts/simulation/wayside/memory" "joylink.club/bj-rtsts-server/ts/simulation/wayside/memory"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/entity"
"log/slog" "log/slog"
"runtime/debug"
"sync" "sync"
"time"
) )
const logTag = "[北京11号线联锁通信]"
var ( var (
initMutex = sync.Mutex{} logTag = "[北京11号线联锁通信]"
running = false privateLogger *slog.Logger
server udp.UdpServer loggerInit sync.Once
sim *memory.VerifySimulation //启动服务所使用的仿真
iConfig *config.InterlockConfig //启动服务使用的联锁配置
//联锁区设备的联锁编号与uid的映射
stationMap map[string]*StationDeviceIndexRepo
) )
func init() { var (
memory.RegisterListener(func(uidStructure *memory.StationUidStructure, data *data_proto.RtssGraphicStorage) { mu = sync.Mutex{} //启动任务时使用，避免重复启动任务
//if data.LianSuoData == nil { serviceContextMap = make(map[string]*serviceContext) //每个集中站的服务上下文，key-集中站code
// return )
//}
////初始化所有集中站设备映射结构体；建立车站和集中站的comId映射关系 type serviceContext struct {
//station_concentration_map := make(map[uint32]uint32) cancelFunc context.CancelFunc //用来结束各个协程的函数
//for _, station := range data.Stations { client udp.UdpClient //向联锁发送数据的客户端
// if station.ConcentrationStations { server udp.UdpServer //接收联锁数据的服务端
// stationMap[station.StationName] = NewStationDeviceIndexRepo() sim *memory.VerifySimulation //启动服务所使用的仿真
// for _, manageStation := range station.ManageStations { iConfig *config.InterlockConfig //启动服务使用的联锁配置
// station_concentration_map[manageStation] = station.Common.Id deviceTable *StationDeviceIndexTable //联锁站的设备ID表，key-车站名
// }
// }
//}
////建立站台和集中站的comId映射
//platform_station_map := make(map[uint32]uint32)
//for _, platform := range data.Platforms {
// platform_station_map[platform.Common.Id] = station_concentration_map[platform.RefStationId]
//}
////填充
//stationIdMap := uidStructure.StationIds
////道岔
//turnoutUidMap := uidStructure.TurnoutIds
//turnoutIndexMap := make(map[uint32]uint32)
//for _, turnout := range data.LianSuoData.Switchs {
// turnoutIndexMap[turnout.Id] = turnout.Index
//}
//for _, turnout := range data.Turnouts {
// for _, stationComId := range turnout.CentralizedStations {
// stationIdStruct := stationIdMap[stationComId]
// stationDeviceIndexRepo := stationMap[stationIdStruct.Code]
// index := turnoutIndexMap[turnout.Common.Id]
// stationDeviceIndexRepo.TurnoutMap[index] = turnoutUidMap[turnout.Common.Id].Uid
// }
//}
////屏蔽门
//psdUidMap := uidStructure.PsdIds
//psdIndexMap := make(map[uint32]uint32)
//for _, psd := range data.LianSuoData.ScreenDoors {
// psdIndexMap[psd.Id] = psd.Index
//}
//for _, psd := range data.ScreenDoors {
// stationComId := platform_station_map[psd.RefPlatformId]
// stationIdStruct := stationIdMap[stationComId]
// stationDeviceIndexRepo := stationMap[stationIdStruct.Code]
// index := psdIndexMap[psd.Common.Id]
// stationDeviceIndexRepo.PsdMap[index] = psdUidMap[psd.Common.Id].Uid
//}
////紧急停车
//uidStructure.
})
} }
func Start(interlockConfig *config.InterlockConfig, simulation *memory.VerifySimulation) { func Start(interlockConfig *config.InterlockConfig, simulation *memory.VerifySimulation) {
if interlockConfig == nil || interlockConfig.Ip == "" || !interlockConfig.Open { if interlockConfig == nil || interlockConfig.Ip == "" || !interlockConfig.Open {
return return
} }
if running { mu.Lock()
defer mu.Unlock()
//制表
table := makeTable(simulation, interlockConfig.Code)
if table == nil { //当前仿真内没有11号线联锁通信所需数据
return return
} }
initMutex.Lock() serviceCtx := serviceContextMap[interlockConfig.Code]
defer initMutex.Unlock() if serviceCtx != nil {
if running { panic(fmt.Sprintf("%s重复启动联锁站[%s]通信服务", logTag, interlockConfig.Code))
return
} }
//UDP通信设施 //UDP客户端
server = udp.NewServer(fmt.Sprintf(":%d", interlockConfig.LocalPort), func(b []byte) { client := udp.NewClient(fmt.Sprintf("%s:%d", interlockConfig.Ip, interlockConfig.RemotePort))
slog.Info(fmt.Sprintf("%s收到消息：%x", logTag, b))
frame := &FromInterlockFrame{} ctx, cancelFunc := context.WithCancel(context.Background())
err := frame.Decode(b) serviceCtx = &serviceContext{
if err != nil { cancelFunc: cancelFunc,
slog.Error(fmt.Sprintf("%s解析数据出错：%s", logTag, err)) client: client,
} else { sim: simulation,
marshal, err := json.Marshal(frame) iConfig: interlockConfig,
if err != nil { deviceTable: table,
slog.Error(fmt.Sprintf("%s解析为json出错：%s", logTag, err)) }
} else { //UDP服务端
slog.Info(fmt.Sprintf("%s解析为json：%s", logTag, string(marshal))) server := udp.NewServer(fmt.Sprintf(":%d", interlockConfig.LocalPort), serviceCtx.handleDriveMsg)
} serviceCtx.server = server
}
})
err := server.Listen() err := server.Listen()
if err != nil { if err != nil {
panic(fmt.Sprintf("%s启动UDP服务失败：%s", logTag, err)) panic(fmt.Sprintf("%s启动UDP服务失败：%s", logTag, err))
} }
running = true
sim = simulation serviceCtx.runCollectTask(ctx)
iConfig = interlockConfig serviceContextMap[interlockConfig.Code] = serviceCtx
} }
func Stop() { func (s *serviceContext) handleDriveMsg(data []byte) {
initMutex.Lock() logger().Info(fmt.Sprintf("收到消息：%x", data))
defer initMutex.Unlock() frame := &FromInterlockFrame{}
running = false err := frame.Decode(data)
if server != nil { if err != nil {
server.Close() logger().Error("解析数据出错", "error", err)
server = nil return
}
}
func Stop(stationCode string) {
mu.Lock()
defer mu.Unlock()
context := serviceContextMap[stationCode]
if context != nil {
if context.client != nil {
context.client.Close()
}
if context.server != nil {
context.server.Close()
}
delete(serviceContextMap, stationCode)
} }
} }
//func CollectRelayInfo() *FromInterlockFrame { func makeTable(sim *memory.VerifySimulation, stationCode string) *StationDeviceIndexTable {
// sim.World for _, mapId := range sim.MapIds {
//} giType := memory.QueryGiType(mapId)
// if giType != data_proto.PictureType_StationLayout {
//func HandleDriveInfo(frame *FromInterlockFrame) { continue
// }
//} stationGi := memory.QueryGiData[*data_proto.RtssGraphicStorage](mapId)
if stationGi.LianSuoData == nil {
continue
}
uids := memory.QueryUidStructure[*memory.StationUidStructure](mapId)
table := NewStationDeviceIndexTable()
//道岔
for _, data := range stationGi.LianSuoData.Switchs {
for _, station := range uids.TurnoutIds[data.Id].CentralizedStations {
if station.Code == stationCode {
table.TurnoutMap[data.Id] = &Row{
commonId: data.Id,
uid: uids.TurnoutIds[data.Id].Uid,
index: uint16(data.Index),
relateDeviceMap: nil,
}
}
}
}
//屏蔽门
for _, data := range stationGi.LianSuoData.ScreenDoors {
for _, station := range uids.PsdIds[data.Id].CentralizedStations {
if station.Code == stationCode {
relateDeviceMap := make(map[string]string)
for _, mkx := range sim.Repo.MkxList() {
if mkx.Psd().Id() == uids.PsdIds[data.Id].Uid {
relateDeviceMap[POB] = mkx.Pobj().Id()
relateDeviceMap[PCB] = mkx.Pcbj().Id()
relateDeviceMap[DPB] = mkx.Pabj().Id()
}
}
table.PsdMap[data.Id] = &Row{
commonId: data.Id,
uid: uids.PsdIds[data.Id].Uid,
index: uint16(data.Index),
relateDeviceMap: relateDeviceMap,
}
}
}
}
//紧急停车
for _, data := range stationGi.LianSuoData.EsbButtons {
for _, station := range uids.EsbIds[data.Id].CentralizedStations {
if station.Code == stationCode {
table.EsbMap[data.Id] = &Row{
commonId: data.Id,
uid: uids.EsbIds[data.Id].Uid,
index: uint16(data.Index),
relateDeviceMap: nil,
}
}
}
}
//扣车，实际数据中数量为0
//信号机
for _, data := range stationGi.LianSuoData.Signals {
for _, station := range uids.SignalIds[data.Id].CentralizedStations {
if station.Code == stationCode {
table.SignalMap[data.Id] = &Row{
commonId: data.Id,
uid: uids.SignalIds[data.Id].Uid,
index: uint16(data.Index),
relateDeviceMap: nil,
}
}
}
}
//计轴区段
for _, data := range stationGi.LianSuoData.Sections {
for _, station := range uids.PhysicalSectionIds[data.Id].CentralizedStations {
if station.Code == stationCode {
table.AxleSectionMap[data.Id] = &Row{
commonId: data.Id,
uid: uids.PhysicalSectionIds[data.Id].Uid,
index: uint16(data.Index),
relateDeviceMap: nil,
}
}
}
}
//无人折返，实际数据中数量为0
//防淹门，实际数据中数量为0
//人员防护
for _, data := range stationGi.LianSuoData.SpksSwitchs {
for _, station := range uids.SpksIds[data.Id].CentralizedStations {
if station.Code == stationCode {
table.SpksMap[data.Id] = &Row{
commonId: data.Id,
uid: uids.SpksIds[data.Id].Uid,
index: uint16(data.Index),
relateDeviceMap: nil,
}
}
}
}
//车库门，实际数据中数量为0
//洗车机，实际数据中没有
return table
}
return nil
}
func (s *serviceContext) runCollectTask(ctx context.Context) {
go func() {
defer func() {
if err := recover(); err != nil {
logger().Error("状态收集任务出错，记录后重启", "error", err, "stack", string(debug.Stack()))
s.runCollectTask(nil)
}
}()
}()
for range time.Tick(time.Duration(s.iConfig.Period) * time.Millisecond) {
select {
case <-ctx.Done():
return
default:
frame := s.collectDeviceState()
err := s.client.Send(frame.encode())
if err != nil {
logger().Error("向联锁发送数据失败", "error", err)
}
}
}
}
func (s *serviceContext) collectDeviceState() *ToInterlockFrame {
wd := entity.GetWorldData(s.sim.World)
frame := &ToInterlockFrame{}
//道岔
for _, row := range s.deviceTable.TurnoutMap {
entry := wd.EntityMap[row.uid]
pos := component.TurnoutPositionType.Get(entry)
state := GetStateByte(pos.Db)
var current1 byte
var current2 byte
if entry.HasComponent(component.TurnoutZzjType) {
zzjList := component.TurnoutZzjType.Get(entry).ZzjList
for i, zzj := range zzjList {
speed := component.FixedPositionTransformType.Get(zzj).Speed
if speed != 0 {
switch i {
case 0:
current1 = 100
case 1:
current2 = 100
}
}
}
}
frame.TurnoutStates = append(frame.TurnoutStates, &TurnoutState{
Id: row.index,
State: state,
Alarm: 0,
Current1: current1,
Current2: current2,
})
}
//屏蔽门
for _, row := range s.deviceTable.PsdMap {
entry := wd.EntityMap[row.uid]
psdState := component.PsdStateType.Get(entry)
mkxBytes := make([]byte, 0, 3)
for _, mkxRelayUid := range []string{row.relateDeviceMap[POB], row.relateDeviceMap[PCB], row.relateDeviceMap[DPB]} {
if mkxRelayUid == "" {
continue
}
mkxBytes = append(mkxBytes, GetStateByte(component.BitStateType.Get(wd.EntityMap[mkxRelayUid]).Val))
}
frame.PsdStates = append(frame.PsdStates, &PSDState{
Id: row.index,
State: GetStateByte(psdState.Close),
Hsjc: GetStateByte(psdState.InterlockRelease),
PCB: mkxBytes[0],
POB: mkxBytes[1],
DPB: mkxBytes[2],
})
}
//紧急停车
for _, row := range s.deviceTable.EsbMap {
esb := s.sim.Repo.FindEsb(row.uid)
relay := wd.EntityMap[esb.RelayId()]
pla := wd.EntityMap[esb.PlaId()]
frame.ESBStates = append(frame.ESBStates, &ESBState{
Id: row.index,
State: GetStateByte(!component.BitStateType.Get(relay).Val),
PlState: GetStateByte(component.BitStateType.Get(pla).Val),
})
}
//信号机
for _, row := range s.deviceTable.SignalMap {
entry := wd.EntityMap[row.uid]
lights := component.SignalLightsType.Get(entry)
var current byte
for _, light := range lights.Lights {
if component.BitStateType.Get(light).Val {
current = 100
break
}
}
frame.SignalStates = append(frame.SignalStates, &SignalState{
Id: row.index,
State: 0, //目前还不知道每种显示对应什么字节，先这样
Current: current,
})
}
//计轴区段
for _, row := range s.deviceTable.AxleSectionMap {
entry := wd.EntityMap[row.uid]
axleManager := component.AxleManagerType.Get(entry)
frame.AxleSectionStates = append(frame.AxleSectionStates, &AxleSectionState{
Id: row.index,
State: GetStateByte(axleManager.Occupied),
})
}
//SPKS
for _, row := range s.deviceTable.SpksMap {
spks := s.sim.Repo.FindSpks(row.uid)
relay := wd.EntityMap[spks.Relay()]
pla := wd.EntityMap[spks.PlaId()]
frame.SPKSStates = append(frame.SPKSStates, &SPKSState{
Id: row.index,
State: GetStateByte(component.BitStateType.Get(relay).Val),
PlState: GetStateByte(component.BitStateType.Get(pla).Val),
})
}
return frame
}
func logger() *slog.Logger {
loggerInit.Do(func() {
privateLogger = slog.Default().With("tag", logTag)
})
return privateLogger
}

350
ts/simulation/wayside/memory/wayside_memory_map_init.go
View File

@ -13,59 +13,60 @@ import (
"joylink.club/rtsssimulation/repository" "joylink.club/rtsssimulation/repository"
) )
// 地图数据处理方法。目前用于不同通信协议所需数据的预处理
type MapDataHandler func(uidStructure *StationUidStructure, data *data_proto.RtssGraphicStorage)
var mapDataHandlerList = make([]MapDataHandler, 0)
func RegisterListener(handler MapDataHandler) {
mapDataHandlerList = append(mapDataHandlerList, handler)
}
var giUidMap sync.Map var giUidMap sync.Map
type elementIdStructure struct { // 设备的联系
type DeviceRelationship struct {
CommonId uint32 CommonId uint32
Code string Code string
Uid string Uid string
//设备所属集中站（此字段暂时仅给急需的设备赋值了）
CentralizedStations []*data_proto.Station
}
func (d *DeviceRelationship) GetCentralizedStations() []*data_proto.Station {
if d == nil {
return nil
}
return d.CentralizedStations
} }
// 列车控制 // 列车控制
type TccUidStructure struct { type TccUidStructure struct {
ButtonIds map[uint32]*elementIdStructure ButtonIds map[uint32]*DeviceRelationship
Keys map[uint32]*elementIdStructure Keys map[uint32]*DeviceRelationship
Handler map[uint32]*elementIdStructure Handler map[uint32]*DeviceRelationship
} }
// 数组为Index为 common.ButtonCode, index, uid // 数组为Index为 common.ButtonCode, index, uid
type StationUidStructure struct { type StationUidStructure struct {
AxlePointIds map[uint32]*elementIdStructure AxlePointIds map[uint32]*DeviceRelationship
TurnoutIds map[uint32]*elementIdStructure TurnoutIds map[uint32]*DeviceRelationship
PhysicalSectionIds map[uint32]*elementIdStructure PhysicalSectionIds map[uint32]*DeviceRelationship
SignalIds map[uint32]*elementIdStructure SignalIds map[uint32]*DeviceRelationship
TransponderIds map[uint32]*elementIdStructure TransponderIds map[uint32]*DeviceRelationship
SlopeIds map[uint32]*elementIdStructure SlopeIds map[uint32]*DeviceRelationship
CurvatureIds map[uint32]*elementIdStructure CurvatureIds map[uint32]*DeviceRelationship
ButtonIds map[uint32]*elementIdStructure EsbIds map[uint32]*DeviceRelationship
StationIds map[uint32]*elementIdStructure StationIds map[uint32]*DeviceRelationship
PlatformIds map[uint32]*elementIdStructure PlatformIds map[uint32]*DeviceRelationship
PsdIds map[uint32]*elementIdStructure PsdIds map[uint32]*DeviceRelationship
PslIds map[uint32]*elementIdStructure PslIds map[uint32]*DeviceRelationship
SpksSwitchIds map[uint32]*elementIdStructure SpksIds map[uint32]*DeviceRelationship
IbpIds map[uint32]*elementIdStructure IbpIds map[uint32]*DeviceRelationship
CkmIds map[uint32]*elementIdStructure CkmIds map[uint32]*DeviceRelationship
XcjIds map[uint32]*elementIdStructure XcjIds map[uint32]*DeviceRelationship
} }
type RelayUidStructure struct { type RelayUidStructure struct {
RelayIds map[uint32]*elementIdStructure RelayIds map[uint32]*DeviceRelationship
} }
type IBPUidStructure struct { type IBPUidStructure struct {
IbpButtonIds map[uint32]*elementIdStructure IbpButtonIds map[uint32]*DeviceRelationship
IbpAlarmIds map[uint32]*elementIdStructure IbpAlarmIds map[uint32]*DeviceRelationship
IbpKeyIds map[uint32]*elementIdStructure IbpKeyIds map[uint32]*DeviceRelationship
IbpLightIds map[uint32]*elementIdStructure IbpLightIds map[uint32]*DeviceRelationship
} }
// 获取继电器的关联关系 // 获取继电器的关联关系
@ -93,10 +94,11 @@ func getMapELementCode(id uint32, code ...string) string {
return strconv.Itoa(int(id)) return strconv.Itoa(int(id))
} }
// 获取关联的车站名 // 获取车站信息
func handleRefStationName(stationMap map[uint32]*data_proto.Station, sid []uint32) []string { func findStationInfos(stationMap map[uint32]*data_proto.Station, stationIds []uint32) ([]string, []*data_proto.Station) {
var stationNames []string var stationNames []string
for _, id := range sid { var stations []*data_proto.Station
for _, id := range stationIds {
if id == 0 { if id == 0 {
continue continue
} }
@ -104,8 +106,9 @@ func handleRefStationName(stationMap map[uint32]*data_proto.Station, sid []uint3
continue continue
} }
stationNames = append(stationNames, stationMap[id].StationName) stationNames = append(stationNames, stationMap[id].StationName)
stations = append(stations, stationMap[id])
} }
return stationNames return stationNames, stations
} }
// 获取UID的前缀信息 // 获取UID的前缀信息
@ -249,22 +252,22 @@ func filterOtherLineDevice(data *data_proto.RtssGraphicStorage) {
// 初始化平面布置图 UID // 初始化平面布置图 UID
func initStationUid(data *data_proto.RtssGraphicStorage) *StationUidStructure { func initStationUid(data *data_proto.RtssGraphicStorage) *StationUidStructure {
gus := &StationUidStructure{ gus := &StationUidStructure{
AxlePointIds: make(map[uint32]*elementIdStructure, len(data.AxleCountings)), AxlePointIds: make(map[uint32]*DeviceRelationship, len(data.AxleCountings)),
TurnoutIds: make(map[uint32]*elementIdStructure, len(data.Turnouts)), TurnoutIds: make(map[uint32]*DeviceRelationship, len(data.Turnouts)),
PhysicalSectionIds: make(map[uint32]*elementIdStructure, len(data.Section)), PhysicalSectionIds: make(map[uint32]*DeviceRelationship, len(data.Section)),
SignalIds: make(map[uint32]*elementIdStructure, len(data.Signals)), SignalIds: make(map[uint32]*DeviceRelationship, len(data.Signals)),
TransponderIds: make(map[uint32]*elementIdStructure, len(data.Transponders)), TransponderIds: make(map[uint32]*DeviceRelationship, len(data.Transponders)),
SlopeIds: make(map[uint32]*elementIdStructure, len(data.Slopes)), SlopeIds: make(map[uint32]*DeviceRelationship, len(data.Slopes)),
CurvatureIds: make(map[uint32]*elementIdStructure, len(data.Curvatures)), CurvatureIds: make(map[uint32]*DeviceRelationship, len(data.Curvatures)),
ButtonIds: make(map[uint32]*elementIdStructure, len(data.EsbButtons)), EsbIds: make(map[uint32]*DeviceRelationship, len(data.EsbButtons)),
StationIds: make(map[uint32]*elementIdStructure, len(data.Stations)), StationIds: make(map[uint32]*DeviceRelationship, len(data.Stations)),
PlatformIds: make(map[uint32]*elementIdStructure, len(data.Platforms)), PlatformIds: make(map[uint32]*DeviceRelationship, len(data.Platforms)),
PsdIds: make(map[uint32]*elementIdStructure, len(data.ScreenDoors)), PsdIds: make(map[uint32]*DeviceRelationship, len(data.ScreenDoors)),
PslIds: make(map[uint32]*elementIdStructure, len(data.GateBoxs)), PslIds: make(map[uint32]*DeviceRelationship, len(data.GateBoxs)),
//SpksSwitchIds: make(map[uint32]*elementIdStructure, len(data.SpksSwitchs)), SpksIds: make(map[uint32]*DeviceRelationship, len(data.SpksSwitchs)),
IbpIds: make(map[uint32]*elementIdStructure, len(data.IbpBoxs)), IbpIds: make(map[uint32]*DeviceRelationship, len(data.IbpBoxs)),
CkmIds: make(map[uint32]*elementIdStructure, len(data.GarageDoors)), CkmIds: make(map[uint32]*DeviceRelationship, len(data.GarageDoors)),
XcjIds: make(map[uint32]*elementIdStructure, len(data.CarWashings)), XcjIds: make(map[uint32]*DeviceRelationship, len(data.CarWashings)),
} }
city, lineId, _ := getUIdPrefix(data.UniqueIdPrefix) city, lineId, _ := getUIdPrefix(data.UniqueIdPrefix)
// 处理车站信息 // 处理车站信息
@ -273,81 +276,135 @@ func initStationUid(data *data_proto.RtssGraphicStorage) *StationUidStructure {
eid := GetMapElementId(s.Common) eid := GetMapElementId(s.Common)
stationName := getMapELementCode(eid, s.StationName, s.Code) stationName := getMapELementCode(eid, s.StationName, s.Code)
stationMap[eid] = s stationMap[eid] = s
gus.StationIds[eid] = &elementIdStructure{ gus.StationIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: stationName, Code: stationName,
Uid: GenerateElementUid(city, lineId, nil, stationName), Uid: BuildUid(city, lineId, stationName),
}
}
for _, station := range data.Stations {
if station.ConcentrationStations {
for _, subStation := range station.ManageStations {
gus.StationIds[subStation].CentralizedStations = append(gus.StationIds[subStation].CentralizedStations, station)
}
} }
} }
// 初始化计轴信息 // 初始化计轴信息
for _, a := range data.AxleCountings { for _, a := range data.AxleCountings {
eid := GetMapElementId(a.Common) eid := GetMapElementId(a.Common)
code := getMapELementCode(eid, a.Code) code := getMapELementCode(eid, a.Code)
stationNames := handleRefStationName(stationMap, a.CentralizedStations) cenStationNames, cenStations := findStationInfos(stationMap, a.CentralizedStations)
gus.AxlePointIds[eid] = &elementIdStructure{ gus.AxlePointIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: code, Code: code,
Uid: GenerateElementUid(city, lineId, stationNames, code), Uid: GenerateElementUid(city, lineId, cenStationNames, code),
CentralizedStations: cenStations,
} }
} }
// 初始化道岔信息 // 初始化道岔信息
for _, t := range data.Turnouts { for _, t := range data.Turnouts {
eid := GetMapElementId(t.Common) eid := GetMapElementId(t.Common)
code := getMapELementCode(eid, t.Code) code := getMapELementCode(eid, t.Code)
stationNames := handleRefStationName(stationMap, t.CentralizedStations) cenStationNames, cenStations := findStationInfos(stationMap, t.CentralizedStations)
gus.TurnoutIds[eid] = &elementIdStructure{ gus.TurnoutIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: code, Code: code,
Uid: GenerateElementUid(city, lineId, stationNames, code), Uid: GenerateElementUid(city, lineId, cenStationNames, code),
CentralizedStations: cenStations,
} }
} }
// 初始化物理区段信息 // 初始化物理区段信息
for _, s := range data.Section { for _, s := range data.Section {
eid := GetMapElementId(s.Common) eid := GetMapElementId(s.Common)
code := getMapELementCode(eid, s.Code) code := getMapELementCode(eid, s.Code)
stationNames := handleRefStationName(stationMap, s.CentralizedStations) cenStationNames, cenStations := findStationInfos(stationMap, s.CentralizedStations)
gus.PhysicalSectionIds[eid] = &elementIdStructure{ gus.PhysicalSectionIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: code, Code: code,
Uid: GenerateElementUid(city, lineId, stationNames, code), Uid: GenerateElementUid(city, lineId, cenStationNames, code),
CentralizedStations: cenStations,
} }
} }
// 初始化信号机信息 // 初始化信号机信息
for _, s := range data.Signals { for _, s := range data.Signals {
eid := GetMapElementId(s.Common) eid := GetMapElementId(s.Common)
code := getMapELementCode(eid, s.Code) code := getMapELementCode(eid, s.Code)
stationNames := handleRefStationName(stationMap, s.CentralizedStations) cenStationNames, cenStations := findStationInfos(stationMap, s.CentralizedStations)
gus.SignalIds[eid] = &elementIdStructure{ gus.SignalIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: code, Code: code,
Uid: GenerateElementUid(city, lineId, stationNames, code), Uid: GenerateElementUid(city, lineId, cenStationNames, code),
CentralizedStations: cenStations,
} }
} }
// 初始化应答器 // 初始化应答器
for _, t := range data.Transponders { for _, t := range data.Transponders {
eid := GetMapElementId(t.Common) eid := GetMapElementId(t.Common)
code := getMapELementCode(eid, t.Code) code := getMapELementCode(eid, t.Code)
stationNames := handleRefStationName(stationMap, t.CentralizedStations) cenStationNames, cenStations := findStationInfos(stationMap, t.CentralizedStations)
gus.TransponderIds[eid] = &elementIdStructure{ gus.TransponderIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: code, Code: code,
Uid: GenerateElementUid(city, lineId, stationNames, code), Uid: GenerateElementUid(city, lineId, cenStationNames, code),
CentralizedStations: cenStations,
} }
} }
// 初始化坡度 // 初始化坡度
for _, s := range data.Slopes { for _, s := range data.Slopes {
eid := GetMapElementId(s.Common) eid := GetMapElementId(s.Common)
gus.SlopeIds[eid] = &elementIdStructure{ gus.SlopeIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Uid: GenerateElementUid(city, lineId, nil, strconv.Itoa(int(eid))), Uid: BuildUid(city, lineId, strconv.Itoa(int(eid))),
} }
} }
// 初始化曲线 // 初始化曲线
for _, c := range data.Curvatures { for _, c := range data.Curvatures {
eid := GetMapElementId(c.Common) eid := GetMapElementId(c.Common)
gus.CurvatureIds[eid] = &elementIdStructure{ gus.CurvatureIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Uid: GenerateElementUid(city, lineId, nil, strconv.Itoa(int(eid))), Uid: BuildUid(city, lineId, strconv.Itoa(int(eid))),
}
}
// 站台
platformMap := make(map[uint32]*data_proto.Platform)
for _, platform := range data.Platforms {
comId := platform.Common.Id
platformMap[comId] = platform
gus.PlatformIds[comId] = &DeviceRelationship{
CommonId: comId,
Code: platform.Code,
Uid: BuildUid(city, lineId, platform.Code),
CentralizedStations: gus.StationIds[platform.RefStationId].GetCentralizedStations(),
}
}
// 屏蔽门
for _, door := range data.ScreenDoors {
comId := door.Common.Id
gus.PsdIds[comId] = &DeviceRelationship{
CommonId: comId,
Code: door.Code,
Uid: BuildUid(city, lineId, gus.PlatformIds[door.RefPlatformId].Code, door.Code),
CentralizedStations: gus.PlatformIds[door.RefPlatformId].GetCentralizedStations(),
}
}
// 紧急停车
for _, esb := range data.EsbButtons {
comId := esb.Common.Id
gus.EsbIds[comId] = &DeviceRelationship{
CommonId: comId,
Code: esb.Code,
Uid: BuildUid(city, lineId, gus.PlatformIds[esb.RefStand].Code, esb.Code),
CentralizedStations: gus.PlatformIds[esb.RefStand].GetCentralizedStations(),
}
}
// SPKS
for _, spks := range data.SpksSwitchs {
commonId := spks.Common.Id
gus.SpksIds[commonId] = &DeviceRelationship{
CommonId: commonId,
Code: spks.Code,
Uid: BuildUid(city, lineId, gus.PlatformIds[spks.RefStand].Code, spks.Code),
CentralizedStations: gus.PlatformIds[spks.RefStand].GetCentralizedStations(),
} }
} }
//处理车站关联的组合信息 //处理车站关联的组合信息
@ -360,62 +417,25 @@ func initStationUid(data *data_proto.RtssGraphicStorage) *StationUidStructure {
} }
} }
} }
// 初始化站场图按钮
for _, b := range data.EsbButtons {
eid := GetMapElementId(b.Common)
p := refMap[eid]
code := b.Code
if p != nil {
code = p.deviceCode + "_" + p.typeCode + "_" + b.Code
}
gus.ButtonIds[eid] = &elementIdStructure{
CommonId: eid,
Code: b.Code,
Uid: GenerateElementUid(city, lineId, nil, code),
}
}
// 站台
platformMap := make(map[uint32]*data_proto.Platform)
for _, platform := range data.Platforms {
eid := GetMapElementId(platform.Common)
platformMap[eid] = platform
gus.PlatformIds[eid] = &elementIdStructure{
CommonId: eid,
Code: platform.Code,
Uid: GenerateElementUid(city, lineId, nil, platform.Code),
}
}
// 屏蔽门
for _, door := range data.ScreenDoors {
station := stationMap[platformMap[door.RefPlatformId].GetRefStationId()]
if station == nil { //线路数据有问题
continue
}
eid := GetMapElementId(door.Common)
gus.PsdIds[eid] = &elementIdStructure{
CommonId: eid,
Code: door.Code,
Uid: GenerateElementUid(city, lineId, []string{station.StationName}, door.Code),
}
}
// PSL // PSL
for _, box := range data.PslBoxs { for _, box := range data.PslBoxs {
stationName := stationMap[platformMap[box.RefPlatformId].RefStationId].StationName stationName := stationMap[platformMap[box.RefPlatformId].RefStationId].StationName
eid := GetMapElementId(box.Common) eid := GetMapElementId(box.Common)
gus.PslIds[eid] = &elementIdStructure{ gus.PslIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: box.Code, Code: box.Code,
Uid: GenerateElementUid(city, lineId, []string{stationName}, box.Code), Uid: BuildUid(city, lineId, stationName, box.Code),
} }
} }
// IBP // IBP
for _, box := range data.IbpBoxs { for _, box := range data.IbpBoxs {
stationName := stationMap[box.RefStationId].StationName stationName := stationMap[box.RefStationId].StationName
eid := GetMapElementId(box.Common) eid := GetMapElementId(box.Common)
gus.IbpIds[eid] = &elementIdStructure{ gus.IbpIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: box.Code, Code: box.Code,
Uid: GenerateElementUid(city, lineId, []string{stationName}, box.Code), Uid: BuildUid(city, lineId, stationName, box.Code),
} }
} }
// 车库门 // 车库门
@ -429,27 +449,23 @@ func initStationUid(data *data_proto.RtssGraphicStorage) *StationUidStructure {
// 洗车机 // 洗车机
for _, xcj := range data.CarWashings { for _, xcj := range data.CarWashings {
eid := GetMapElementId(xcj.Common) eid := GetMapElementId(xcj.Common)
gus.XcjIds[eid] = &elementIdStructure{ gus.XcjIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: xcj.Code, Code: xcj.Code,
Uid: GenerateElementUid(city, lineId, nil, xcj.Code), Uid: BuildUid(city, lineId, xcj.Code),
} }
} }
//通信协议预处理所需数据
for _, handler := range mapDataHandlerList {
handler(gus, data)
}
return gus return gus
} }
func fillCkmInfo(ckm *data_proto.GarageDoor, gus *StationUidStructure, city string, lineId string) { func fillCkmInfo(ckm *data_proto.GarageDoor, gus *StationUidStructure, city string, lineId string) {
eid := GetMapElementId(ckm.Common) eid := GetMapElementId(ckm.Common)
gus.CkmIds[eid] = &elementIdStructure{ gus.CkmIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: ckm.Code, Code: ckm.Code,
Uid: GenerateElementUid(city, lineId, nil, ckm.Code), Uid: BuildUid(city, lineId, ckm.Code),
} }
gus.PslIds[eid] = &elementIdStructure{ gus.PslIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: ckm.Code, Code: ckm.Code,
Uid: BuildUid(city, lineId, ckm.Code, "PSL"), Uid: BuildUid(city, lineId, ckm.Code, "PSL"),
@ -458,22 +474,22 @@ func fillCkmInfo(ckm *data_proto.GarageDoor, gus *StationUidStructure, city stri
// 初始化列车控制 // 初始化列车控制
func initTccUid(tcc *data_proto.TccGraphicStorage) *TccUidStructure { func initTccUid(tcc *data_proto.TccGraphicStorage) *TccUidStructure {
tc := &TccUidStructure{ButtonIds: make(map[uint32]*elementIdStructure), Keys: make(map[uint32]*elementIdStructure), Handler: make(map[uint32]*elementIdStructure)} tc := &TccUidStructure{ButtonIds: make(map[uint32]*DeviceRelationship), Keys: make(map[uint32]*DeviceRelationship), Handler: make(map[uint32]*DeviceRelationship)}
for _, d := range tcc.TccButtons { for _, d := range tcc.TccButtons {
id := GetMapElementId(d.Common) id := GetMapElementId(d.Common)
tc.ButtonIds[id] = &elementIdStructure{CommonId: id, tc.ButtonIds[id] = &DeviceRelationship{CommonId: id,
Code: d.Code} Code: d.Code}
} }
for _, d := range tcc.TccKeys { for _, d := range tcc.TccKeys {
id := GetMapElementId(d.Common) id := GetMapElementId(d.Common)
tc.Keys[id] = &elementIdStructure{CommonId: id, tc.Keys[id] = &DeviceRelationship{CommonId: id,
Code: d.Code} Code: d.Code}
} }
for _, d := range tcc.TccHandles { for _, d := range tcc.TccHandles {
id := GetMapElementId(d.Common) id := GetMapElementId(d.Common)
tc.Handler[id] = &elementIdStructure{CommonId: id, tc.Handler[id] = &DeviceRelationship{CommonId: id,
Code: d.Code} Code: d.Code}
} }
@ -483,7 +499,7 @@ func initTccUid(tcc *data_proto.TccGraphicStorage) *TccUidStructure {
// 初始化继电器柜 UID // 初始化继电器柜 UID
func initRelayCabinetUid(data *data_proto.RelayCabinetGraphicStorage) *RelayUidStructure { func initRelayCabinetUid(data *data_proto.RelayCabinetGraphicStorage) *RelayUidStructure {
rus := &RelayUidStructure{ rus := &RelayUidStructure{
RelayIds: make(map[uint32]*elementIdStructure, len(data.Relays)), RelayIds: make(map[uint32]*DeviceRelationship, len(data.Relays)),
} }
// 继电器所属设备 // 继电器所属设备
refMap := make(map[uint32]*deviceRelateUidPriex, len(data.Relays)) refMap := make(map[uint32]*deviceRelateUidPriex, len(data.Relays))
@ -507,14 +523,16 @@ func initRelayCabinetUid(data *data_proto.RelayCabinetGraphicStorage) *RelayUidS
if p != nil { if p != nil {
code = p.deviceCode + "_" + p.typeCode + "_" + r.Code code = p.deviceCode + "_" + p.typeCode + "_" + r.Code
} }
stationArr := []string{station} var uid string
if p != nil && (p.isStation || p.isPSD) { if p != nil && (p.isStation || p.isPSD) {
stationArr = nil uid = BuildUid(city, lineId, code)
} else {
uid = BuildUid(city, lineId, station, code)
} }
rus.RelayIds[eid] = &elementIdStructure{ rus.RelayIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: r.Code, Code: r.Code,
Uid: GenerateElementUid(city, lineId, stationArr, code), Uid: uid,
} }
} }
for _, r := range data.PhaseFailureProtectors { for _, r := range data.PhaseFailureProtectors {
@ -524,14 +542,14 @@ func initRelayCabinetUid(data *data_proto.RelayCabinetGraphicStorage) *RelayUidS
if p != nil { if p != nil {
code = p.deviceCode + "_" + p.typeCode + "_" + r.Code code = p.deviceCode + "_" + p.typeCode + "_" + r.Code
} }
stationArr := []string{station} stationName := station
if p != nil && (p.isStation || p.isPSD) { if p != nil && (p.isStation || p.isPSD) {
stationArr = nil stationName = ""
} }
rus.RelayIds[eid] = &elementIdStructure{ rus.RelayIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: r.Code, Code: r.Code,
Uid: GenerateElementUid(city, lineId, stationArr, code), Uid: BuildUid(city, lineId, stationName, code),
} }
} }
return rus return rus
@ -540,10 +558,10 @@ func initRelayCabinetUid(data *data_proto.RelayCabinetGraphicStorage) *RelayUidS
// 初始化IBP地图UID // 初始化IBP地图UID
func initIBPUid(data *data_proto.IBPGraphicStorage) *IBPUidStructure { func initIBPUid(data *data_proto.IBPGraphicStorage) *IBPUidStructure {
rus := &IBPUidStructure{ rus := &IBPUidStructure{
IbpButtonIds: make(map[uint32]*elementIdStructure), IbpButtonIds: make(map[uint32]*DeviceRelationship),
IbpAlarmIds: make(map[uint32]*elementIdStructure), IbpAlarmIds: make(map[uint32]*DeviceRelationship),
IbpKeyIds: make(map[uint32]*elementIdStructure), IbpKeyIds: make(map[uint32]*DeviceRelationship),
IbpLightIds: make(map[uint32]*elementIdStructure), IbpLightIds: make(map[uint32]*DeviceRelationship),
} }
//处理继电器关联信息 //处理继电器关联信息
refMap := make(map[uint32]string) refMap := make(map[uint32]string)
@ -564,7 +582,7 @@ func initIBPUid(data *data_proto.IBPGraphicStorage) *IBPUidStructure {
// 处理按钮Uid // 处理按钮Uid
for _, d := range data.IbpButtons { for _, d := range data.IbpButtons {
eid := GetMapElementId(d.Common) eid := GetMapElementId(d.Common)
rus.IbpButtonIds[eid] = &elementIdStructure{ rus.IbpButtonIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: d.Code, Code: d.Code,
Uid: "button_" + codeFun(eid, d.Code), Uid: "button_" + codeFun(eid, d.Code),
@ -573,7 +591,7 @@ func initIBPUid(data *data_proto.IBPGraphicStorage) *IBPUidStructure {
// 处理钥匙Uid // 处理钥匙Uid
for _, d := range data.IbpKeys { for _, d := range data.IbpKeys {
eid := GetMapElementId(d.Common) eid := GetMapElementId(d.Common)
rus.IbpKeyIds[eid] = &elementIdStructure{ rus.IbpKeyIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: d.Code, Code: d.Code,
Uid: "key_" + codeFun(eid, d.Code), Uid: "key_" + codeFun(eid, d.Code),
@ -582,7 +600,7 @@ func initIBPUid(data *data_proto.IBPGraphicStorage) *IBPUidStructure {
// 处理报警器Uid // 处理报警器Uid
for _, d := range data.IbpAlarms { for _, d := range data.IbpAlarms {
eid := GetMapElementId(d.Common) eid := GetMapElementId(d.Common)
rus.IbpAlarmIds[eid] = &elementIdStructure{ rus.IbpAlarmIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: d.Code, Code: d.Code,
Uid: "alarm_" + codeFun(eid, d.Code), Uid: "alarm_" + codeFun(eid, d.Code),
@ -591,7 +609,7 @@ func initIBPUid(data *data_proto.IBPGraphicStorage) *IBPUidStructure {
// 处理指示灯Uid // 处理指示灯Uid
for _, d := range data.IbpLights { for _, d := range data.IbpLights {
eid := GetMapElementId(d.Common) eid := GetMapElementId(d.Common)
rus.IbpLightIds[eid] = &elementIdStructure{ rus.IbpLightIds[eid] = &DeviceRelationship{
CommonId: eid, CommonId: eid,
Code: d.Code, Code: d.Code,
Uid: "light_" + codeFun(eid, d.Code), Uid: "light_" + codeFun(eid, d.Code),
@ -601,12 +619,12 @@ func initIBPUid(data *data_proto.IBPGraphicStorage) *IBPUidStructure {
} }
// 构建仿真内所有地图UID映射信号布置图ID,这里为了解决多地图时根据UID反向寻找，避免多次循环地图，直接获取平面布置图元素 // 构建仿真内所有地图UID映射信号布置图ID,这里为了解决多地图时根据UID反向寻找，避免多次循环地图，直接获取平面布置图元素
func buildRepositoryAllUidsMap(mapIds []int32, repo *repository.Repository) map[string]*elementIdStructure { func buildRepositoryAllUidsMap(mapIds []int32, repo *repository.Repository) map[string]*DeviceRelationship {
mapLen := len(repo.CheckPointList()) + len(repo.PhysicalSectionList()) + len(repo.SignalList()) + mapLen := len(repo.CheckPointList()) + len(repo.PhysicalSectionList()) + len(repo.SignalList()) +
len(repo.TurnoutList()) + len(repo.ResponderList()) + len(repo.SlopeList()) + len(repo.TurnoutList()) + len(repo.ResponderList()) + len(repo.SlopeList()) +
len(repo.SectionalCurvatureList()) len(repo.SectionalCurvatureList())
allUidMap := make(map[string]*elementIdStructure, mapLen) allUidMap := make(map[string]*DeviceRelationship, mapLen)
saveToAllUidMap := func(es map[uint32]*elementIdStructure) { saveToAllUidMap := func(es map[uint32]*DeviceRelationship) {
for _, e := range es { for _, e := range es {
allUidMap[e.Uid] = e allUidMap[e.Uid] = e
} }
@ -625,8 +643,8 @@ func buildRepositoryAllUidsMap(mapIds []int32, repo *repository.Repository) map[
saveToAllUidMap(u.TurnoutIds) saveToAllUidMap(u.TurnoutIds)
saveToAllUidMap(u.SlopeIds) saveToAllUidMap(u.SlopeIds)
saveToAllUidMap(u.CurvatureIds) saveToAllUidMap(u.CurvatureIds)
saveToAllUidMap(u.ButtonIds) saveToAllUidMap(u.EsbIds)
saveToAllUidMap(u.SpksSwitchIds) saveToAllUidMap(u.SpksIds)
saveToAllUidMap(u.StationIds) saveToAllUidMap(u.StationIds)
continue continue
} }
@ -644,7 +662,7 @@ func QueryUidStructure[T *StationUidStructure | *RelayUidStructure | *IBPUidStru
} }
// 获取设备类型获取对应字段 // 获取设备类型获取对应字段
func getUidMapByType(uidData any, m interface{}) map[uint32]*elementIdStructure { func getUidMapByType(uidData any, m interface{}) map[uint32]*DeviceRelationship {
switch m.(type) { switch m.(type) {
case *data_proto.AxleCounting: case *data_proto.AxleCounting:
return (uidData.(*StationUidStructure)).AxlePointIds return (uidData.(*StationUidStructure)).AxlePointIds
@ -663,11 +681,11 @@ func getUidMapByType(uidData any, m interface{}) map[uint32]*elementIdStructure
case *data_proto.Relay: case *data_proto.Relay:
return (uidData.(*RelayUidStructure)).RelayIds return (uidData.(*RelayUidStructure)).RelayIds
case *data_proto.EsbButton: case *data_proto.EsbButton:
return (uidData.(*StationUidStructure)).ButtonIds return (uidData.(*StationUidStructure)).EsbIds
case *data_proto.Station: case *data_proto.Station:
return (uidData.(*StationUidStructure)).StationIds return (uidData.(*StationUidStructure)).StationIds
case *data_proto.SpksSwitch: case *data_proto.SpksSwitch:
return (uidData.(*StationUidStructure)).SpksSwitchIds return (uidData.(*StationUidStructure)).SpksIds
case *data_proto.ScreenDoor: case *data_proto.ScreenDoor:
return (uidData.(*StationUidStructure)).PsdIds return (uidData.(*StationUidStructure)).PsdIds
case *data_proto.PslBox: case *data_proto.PslBox:
@ -684,7 +702,7 @@ func getUidMapByType(uidData any, m interface{}) map[uint32]*elementIdStructure
} }
// 根据地图ID跟设备类型获取UID集合 // 根据地图ID跟设备类型获取UID集合
func QueryMapUidMapByType(mapId int32, m interface{}) map[uint32]*elementIdStructure { func QueryMapUidMapByType(mapId int32, m interface{}) map[uint32]*DeviceRelationship {
uidData, ok := giUidMap.Load(mapId) uidData, ok := giUidMap.Load(mapId)
if !ok { if !ok {
panic(&dto.ErrorDto{Code: dto.DataNotExist, Message: fmt.Sprintf("地图【id:%d】不存在uid缓存", mapId)}) panic(&dto.ErrorDto{Code: dto.DataNotExist, Message: fmt.Sprintf("地图【id:%d】不存在uid缓存", mapId)})

125
ts/simulation/wayside/memory/wayside_simulation.go
View File

@ -43,7 +43,7 @@ type VerifySimulation struct {
//Rtss仿真世界的 //Rtss仿真世界的
World ecs.World World ecs.World
//设备UID映射 key-uid //设备UID映射 key-uid
UidMap map[string]*elementIdStructure UidMap map[string]*DeviceRelationship
// 运行环境配置 // 运行环境配置
runConfig *config.ThirdPartyConfig runConfig *config.ThirdPartyConfig
} }
@ -114,26 +114,6 @@ func CreateSimulation(projectId int32, mapIds []int32, runConfig *dto.ProjectRun
return verifySimulation, nil return verifySimulation, nil
} }
// // 启动
// func (s *VerifySimulation) Start() {
// s.runState = state_proto.SimulationStatus_START
// }
// // 销毁
// func (s *VerifySimulation) Destroy() {
// s.runState = state_proto.SimulationStatus_DESTROY
// }
// // 暂停
// func (s *VerifySimulation) Pause() {
// s.runState = state_proto.SimulationStatus_PAUSE
// }
// // 获取状态
// func (s *VerifySimulation) GetRunState() state_proto.SimulationStatus_SimulationState {
// return s.runState
// }
// 获取仿真世界信息 // 获取仿真世界信息
func (s *VerifySimulation) GetComIdByUid(uid string) uint32 { func (s *VerifySimulation) GetComIdByUid(uid string) uint32 {
es := s.UidMap es := s.UidMap
@ -185,7 +165,7 @@ func (s *VerifySimulation) GetBtmVobcConfig() config.BtmVobcConfig {
// GetSectionCodePoints 获取集中站的区段码表 // GetSectionCodePoints 获取集中站的区段码表
func (s *VerifySimulation) GetSectionCodePoints(city string, lineId string, centralizedStation string) []*proto.CiSectionCodePoint { func (s *VerifySimulation) GetSectionCodePoints(city string, lineId string, centralizedStation string) []*proto.CiSectionCodePoint {
stationUid := GenerateElementUid(city, lineId, nil, centralizedStation) stationUid := BuildUid(city, lineId, centralizedStation)
ref := s.Repo.GetCentralizedStationRef(stationUid) ref := s.Repo.GetCentralizedStationRef(stationUid)
if ref == nil { if ref == nil {
return nil return nil
@ -196,7 +176,7 @@ func (s *VerifySimulation) GetSectionCodePoints(city string, lineId string, cent
// CollectSectionStatus 收集仿真中计轴区段状态 // CollectSectionStatus 收集仿真中计轴区段状态
func (s *VerifySimulation) CollectSectionStatus(city string, lineId string, centralizedStation string) ([]*message.SectionStatusMsg, error) { func (s *VerifySimulation) CollectSectionStatus(city string, lineId string, centralizedStation string) ([]*message.SectionStatusMsg, error) {
stationUid := GenerateElementUid(city, lineId, nil, centralizedStation) stationUid := BuildUid(city, lineId, centralizedStation)
// //
codePoints := s.GetSectionCodePoints(city, lineId, centralizedStation) codePoints := s.GetSectionCodePoints(city, lineId, centralizedStation)
if len(codePoints) <= 0 { if len(codePoints) <= 0 {
@ -682,7 +662,7 @@ func buildAndRelateElectronicComponent(repo *proto.Repository, relayGi *data_pro
city := relayGi.UniqueIdPrefix.City city := relayGi.UniqueIdPrefix.City
lineId := relayGi.UniqueIdPrefix.LineId lineId := relayGi.UniqueIdPrefix.LineId
station := relayGi.UniqueIdPrefix.BelongsConcentrationStation station := relayGi.UniqueIdPrefix.BelongsConcentrationStation
stationUid := GenerateElementUid(city, lineId, nil, station) stationUid := BuildUid(city, lineId, station)
relayMap := make(map[string]*proto.Relay) relayMap := make(map[string]*proto.Relay)
for _, relay := range relayGi.Relays { for _, relay := range relayGi.Relays {
rid := GetMapElementId(relay.Common) rid := GetMapElementId(relay.Common)
@ -751,7 +731,7 @@ func buildAndRelateElectronicComponent(repo *proto.Repository, relayGi *data_pro
for _, relationship := range relayGi.DeviceRelateRelayList { for _, relationship := range relayGi.DeviceRelateRelayList {
switch relationship.DeviceType { switch relationship.DeviceType {
case data_proto.RelatedRef_Turnout: case data_proto.RelatedRef_Turnout:
turnout := turnoutMap[GenerateElementUid(city, lineId, []string{station}, relationship.Code)] turnout := turnoutMap[BuildUid(city, lineId, station, relationship.Code)]
if turnout == nil { if turnout == nil {
continue continue
} }
@ -770,7 +750,7 @@ func buildAndRelateElectronicComponent(repo *proto.Repository, relayGi *data_pro
}) })
} }
case data_proto.RelatedRef_signal: case data_proto.RelatedRef_signal:
signal := signalMap[GenerateElementUid(city, lineId, []string{station}, relationship.Code)] signal := signalMap[BuildUid(city, lineId, station, relationship.Code)]
if signal == nil { if signal == nil {
continue continue
} }
@ -793,7 +773,7 @@ func buildAndRelateElectronicComponent(repo *proto.Repository, relayGi *data_pro
ComponentIds: componentIds, ComponentIds: componentIds,
}) })
case data_proto.RelatedRef_station: case data_proto.RelatedRef_station:
station := stationMap[GenerateElementUid(city, lineId, nil, relationship.Code)] station := stationMap[BuildUid(city, lineId, relationship.Code)]
if station == nil { if station == nil {
continue continue
} }
@ -811,7 +791,7 @@ func buildAndRelateElectronicComponent(repo *proto.Repository, relayGi *data_pro
station.ElectronicGroup = append(station.ElectronicGroup, d) station.ElectronicGroup = append(station.ElectronicGroup, d)
} }
case data_proto.RelatedRef_ScreenDoor: case data_proto.RelatedRef_ScreenDoor:
psd, ok := psdMap[GenerateElementUid(city, lineId, nil, relationship.Code)] psd, ok := psdMap[BuildUid(city, lineId, relationship.Code)]
if !ok { if !ok {
continue continue
} }
@ -855,7 +835,7 @@ func buildAndRelateElectronicComponent(repo *proto.Repository, relayGi *data_pro
} }
case data_proto.RelatedRef_GarageDoor, data_proto.RelatedRef_FloodGate: //车库门||防淹门 case data_proto.RelatedRef_GarageDoor, data_proto.RelatedRef_FloodGate: //车库门||防淹门
{ {
ckm, ok := ckmMap[GenerateElementUid(city, lineId, nil, relationship.Code)] ckm, ok := ckmMap[BuildUid(city, lineId, relationship.Code)]
if !ok { if !ok {
continue continue
} }
@ -876,7 +856,7 @@ func buildAndRelateElectronicComponent(repo *proto.Repository, relayGi *data_pro
} }
case data_proto.RelatedRef_CarWashing: case data_proto.RelatedRef_CarWashing:
{ {
xcj, ok := xcjMap[GenerateElementUid(city, lineId, nil, relationship.Code)] xcj, ok := xcjMap[BuildUid(city, lineId, relationship.Code)]
if !ok { if !ok {
continue continue
} }
@ -968,7 +948,7 @@ func buildAndRelateElectronicComponent(repo *proto.Repository, relayGi *data_pro
mkx.PcbjId = relay.Id mkx.PcbjId = relay.Id
} else if strings.Contains(relay.GetCode(), "POB") { } else if strings.Contains(relay.GetCode(), "POB") {
mkx.PobjId = relay.Id mkx.PobjId = relay.Id
} else if strings.Contains(relay.GetCode(), "PAB") || strings.Contains(relay.GetCode(), "PDB") { } else if strings.Contains(relay.GetCode(), "PAB") || strings.Contains(relay.GetCode(), "DPB") {
mkx.PabjId = relay.Id mkx.PabjId = relay.Id
} else if strings.Contains(relay.GetCode(), "WRZF") { } else if strings.Contains(relay.GetCode(), "WRZF") {
mkx.WrzfjId = relay.Id mkx.WrzfjId = relay.Id
@ -981,7 +961,7 @@ func buildAndRelateElectronicComponent(repo *proto.Repository, relayGi *data_pro
} }
} }
// 处理该集中站采集、驱动配置信息 // 处理该集中站采集、驱动配置信息
centralizedStationId := GenerateElementUid(city, lineId, nil, station) centralizedStationId := BuildUid(city, lineId, station)
ref := queryCentralizedStationRef(centralizedStationId, repo) ref := queryCentralizedStationRef(centralizedStationId, repo)
ref.CjList = append(ref.CjList, handlerRelayGiCj(relayUidStructure, centralizedStationId, relayGi.CiCjList)...) ref.CjList = append(ref.CjList, handlerRelayGiCj(relayUidStructure, centralizedStationId, relayGi.CiCjList)...)
sortQcTable(ref.CjList) sortQcTable(ref.CjList)
@ -1301,19 +1281,19 @@ func fillProtoRepository(repo *proto.Repository, storage *data_proto.RtssGraphic
SameTrend: data.SameTrend, SameTrend: data.SameTrend,
}) })
} }
// 初始化站场图按钮 //// 初始化站场图按钮
for _, data := range storage.EsbButtons { //for _, data := range storage.EsbButtons {
repo.Buttons = append(repo.Buttons, &proto.Button{ // repo.Buttons = append(repo.Buttons, &proto.Button{
Id: uidsMap.ButtonIds[GetMapElementId(data.Common)].Uid, // Id: uidsMap.EsbIds[GetMapElementId(data.Common)].Uid,
Code: data.Code, // Code: data.Code,
ButtonType: proto.Button_Reset_Press, // ButtonType: proto.Button_Reset_Press,
}) // })
} //}
// 车站关联关系 //// 车站关联关系
relateMap := make(map[string]*data_proto.StationRelateDevice) //relateMap := make(map[string]*data_proto.StationRelateDevice)
for _, data := range storage.StationRelateDeviceList { //for _, data := range storage.StationRelateDeviceList {
relateMap[data.Code] = data // relateMap[data.Code] = data
} //}
// 处理车站信息 // 处理车站信息
repoStationMap := make(map[uint32]*proto.Station) repoStationMap := make(map[uint32]*proto.Station)
for _, data := range storage.Stations { for _, data := range storage.Stations {
@ -1322,26 +1302,26 @@ func fillProtoRepository(repo *proto.Repository, storage *data_proto.RtssGraphic
Code: data.StationName, Code: data.StationName,
} }
repoStationMap[GetMapElementId(data.Common)] = station repoStationMap[GetMapElementId(data.Common)] = station
// 关联车站的设备 //// 关联车站的设备
refs, ok := relateMap[station.Code] //refs, ok := relateMap[station.Code]
if ok { //if ok {
for _, c := range refs.Combinationtypes { // for _, c := range refs.Combinationtypes {
group := &proto.ElectronicGroup{Code: c.Code} // group := &proto.ElectronicGroup{Code: c.Code}
for _, d := range c.RefDevices { // for _, d := range c.RefDevices {
var comp *proto.ElectronicComponent // var comp *proto.ElectronicComponent
if uidsMap.ButtonIds[d] != nil { // 目前只处理按钮 // if uidsMap.EsbIds[d] != nil { // 目前只处理按钮
comp = &proto.ElectronicComponent{ // comp = &proto.ElectronicComponent{
Id: uidsMap.ButtonIds[d].Uid, // Id: uidsMap.EsbIds[d].Uid,
DeviceType: proto.DeviceType_DeviceType_Button, // DeviceType: proto.DeviceType_DeviceType_Button,
} // }
} else { // } else {
continue // continue
} // }
group.Components = append(group.Components, comp) // group.Components = append(group.Components, comp)
} // }
station.ElectronicGroup = append(station.ElectronicGroup, group) // station.ElectronicGroup = append(station.ElectronicGroup, group)
} // }
} //}
//// 处理车站关联IBP的设备 //// 处理车站关联IBP的设备
//handlerIBPDeviceToStation(station, repo, data.RefIbpMapCode) //handlerIBPDeviceToStation(station, repo, data.RefIbpMapCode)
repo.Stations = append(repo.Stations, station) repo.Stations = append(repo.Stations, station)
@ -1447,6 +1427,21 @@ func fillProtoRepository(repo *proto.Repository, storage *data_proto.RtssGraphic
} }
repo.Xcjs = append(repo.Xcjs, xcj) repo.Xcjs = append(repo.Xcjs, xcj)
} }
//ESB
for _, data := range storage.EsbButtons {
repo.Esbs = append(repo.Esbs, &proto.Esb{
Id: uidsMap.EsbIds[data.Common.Id].Uid,
PlatformId: uidsMap.StationIds[data.RefStand].Uid,
})
}
//SPKS
for _, data := range storage.SpksSwitchs {
repo.Spkss = append(repo.Spkss, &proto.Spks{
Id: uidsMap.SpksIds[data.Common.Id].Uid,
Code: data.Code,
PlatformId: uidsMap.StationIds[data.RefStand].Uid,
})
}
} }
func fillCkmOrFym(repo *proto.Repository, doors []*data_proto.GarageDoor, uidsMap *StationUidStructure) { func fillCkmOrFym(repo *proto.Repository, doors []*data_proto.GarageDoor, uidsMap *StationUidStructure) {

2
ts/test_simulation_manage.go
View File

@ -161,7 +161,7 @@ func stopThirdParty(s *memory.VerifySimulation) {
for _, c := range s.GetInterlockCodes() { for _, c := range s.GetInterlockCodes() {
switch c.Line { switch c.Line {
case "11": case "11":
beijing11.Stop() beijing11.Stop(c.Code)
default: default:
beijing12.Stop(c) beijing12.Stop(c)
} }