joylink/rts-sim-module
6
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: joylink:master
Branches Tags
joylink:master
joylink:detached
joylink:refactoring
joylink:restruct
..
compare: joylink:restruct
Branches Tags
joylink:master
joylink:detached
joylink:refactoring
joylink:restruct

No commits in common. "master" and "restruct" have entirely different histories.
master ... restruct

186 changed files with 4692 additions and 23817 deletions
Show Stats Expand all files Collapse all files

6
.gitmodules vendored
View File

@ -1,3 +1,3 @@
[submodule "jl-ecs"]
path = jl-ecs
url = https://gitea.joylink.club/joylink/jl-ecs.git
[submodule "jl-ecs-go"]
path = jl-ecs-go
url = https://git.code.tencent.com/jl-framework/jl-ecs-go.git

11
component/axle_counting_section.go
View File

@ -1,11 +0,0 @@
package component
import "joylink.club/ecs"
var (
AxleCountingSectionStateType = ecs.NewComponentType[AxleCountingSectionState]()
)
type AxleCountingSectionState struct {
Occupied bool
}

29
component/balise.go
View File

@ -2,24 +2,15 @@ package component
import "joylink.club/ecs"
type BaliseState struct {
ValidTelegram []byte //当前一条有效报文
}
var (
BaliseFB = ecs.NewTag() // 固定应答器
BaliseWB = ecs.NewTag() // 轮径校正应答器
BaliseDB = ecs.NewTag() // 休眠唤醒应答器
BaliseVB = ecs.NewTag() // 主信号应答器
BaliseIB = ecs.NewTag() // 预告应答器
BaliseFB = ecs.NewTag() // 固定应答器
BaliseWB = ecs.NewTag() // 轮径校正应答器
BaliseDB = ecs.NewTag() // 休眠唤醒应答器
BaliseVB = ecs.NewTag() // 主信号应答器
BaliseIB = ecs.NewTag() // 预告应答器
BaliseStateType = ecs.NewComponentType[BaliseState]()
)
var ForceVariableTelegram = ecs.NewTag() //表示可变报文为强制设置并锁定
var BaliseFixedTelegramType = ecs.NewComponentType[BaliseTelegram]() //应答器固定报文
var BaliseVariableTelegramType = ecs.NewComponentType[BaliseTelegram]() //应答器可变报文
type BaliseTelegram struct {
Telegram []byte //报文
UserTelegram []byte //用户报文
}
var BaliseWorkStateType = ecs.NewComponentType[BaliseWorkState]() // 工作状态
type BaliseWorkState struct {
Work bool //应答器是否正常工作中（目前仅应答器停止发送报文故障会导致为false）
}

151
component/cbtc_atp_ground.go
View File

@ -1,151 +0,0 @@
package component
import (
"time"
"joylink.club/ecs"
)
// 控制模式
type ControlMode uint8
const (
ControlMode_None ControlMode = iota // 交出未被接收
ControlMode_Center // 中控
ControlMode_Local // 站控/自律站控
ControlMode_Emergency // 紧急站控
ControlMode_Interlock // 联锁控/非常站控
)
// 控制模式
type ControlState struct {
Model ControlMode // 当前控制模式
}
var ControlStateType = ecs.NewComponentType[ControlState]() // 控制模式
// 限速组件
type SpeedLimit struct {
Val float32 // 限速值
}
var SpeedLimitType = ecs.NewComponentType[SpeedLimit]() // 限速组件
// 占用类型
type OccupiedType uint8
const (
Occupied_Ct OccupiedType = iota // 通信车占用
Occupied_Nct // 非通信车占用
Occupied_Fault // 故障占用
)
// 占用状态
type OccupiedStatus struct {
Types []OccupiedType // 占用状态
}
var OccupiedStatusType = ecs.NewComponentType[OccupiedStatus]() // 占用状态组件
// 进路锁闭状态
type RouteLock struct {
Route *ecs.Entry
}
var RouteLockType = ecs.NewComponentType[RouteLock]()
// 故障锁闭状态
type FaultLock struct {
Fault any // 故障信息
}
var FaultLockType = ecs.NewComponentType[FaultLock]() // 故障锁闭状态组件
// 封锁状态
type BlockadeStatus struct {
}
var BlockadeStatusType = ecs.NewComponentType[BlockadeStatus]() // 封锁状态组件
// 解锁状态
type UnLockStatus struct {
Delay bool // 延迟状态
DelayTime time.Duration // 延迟解锁时间
}
var UnLockStatusType = ecs.NewComponentType[UnLockStatus]() // 解锁状态组件
// 关闭状态
type ClosedStatus struct {
}
var ClosedStatusType = ecs.NewComponentType[ClosedStatus]() // 关闭状态组件
// 站台跳停状态
type PlatformSkipStatus struct {
AllSkip bool // 全部跳停
Trains []*ecs.Entry // 跳停列车
}
var PlatformSkipStatusType = ecs.NewComponentType[PlatformSkipStatus]() // 站台跳停状态
// 站台停靠发车状态
type PlatformParkStatus struct {
Park bool // 列车停靠状态
ParkTime time.Duration // 停靠时间
Depart bool // 列车发车状态
}
var PlatformParkStatusType = ecs.NewComponentType[PlatformParkStatus]() // 站台停靠发车状态
// 扣车状态
type PlatformHoldStatus struct {
}
var PlatformHoldStatusType = ecs.NewComponentType[PlatformHoldStatus]() // 扣车状态组件
// 信号机状态
type SignalStatus struct {
ApproachLock bool // 接近锁闭
OverlapLock bool // 延续保护锁闭
}
var SignalStatusType = ecs.NewComponentType[SignalStatus]() // 信号机状态组件
// 进路状态
type RouteStatus struct {
AtsControl bool // ats自动控制
Setting bool // 进路是否排列中
Lock bool // 已锁闭
Setable bool // 是否可排列
}
var RouteStatusType = ecs.NewComponentType[RouteStatus]() // 进路状态组件
// 列车运行级别
type TrainRunLevel uint8
const (
TrainRunLevel_CBTC TrainRunLevel = iota // cbtc级别
TrainRunLevel_ITC // 点式通信
TrainRunLevel_IL // 联锁级
)
// 列车运行模式
type DriveMode uint8
const (
DriveMode_AM DriveMode = iota // 列车自动驾驶模式
DriveMode_CM // ATP防护下的人工驾驶模式
DriveMode_RM // 限制人工驾驶模式
DriveMode_NRM // 无限制人工驾驶模式
)
// 位置：目标位置、占用位置
type DevicePosition struct {
Device *ecs.Entry // 设备
Offset int64 // 在设备上的相对a位置偏移
Direction bool // 上下行
}
var DevicePositionType = ecs.NewComponentType[DevicePosition]()

10
component/ci.go
View File

@ -1,10 +0,0 @@
package component
import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/component/component_data"
)
var (
CiSysRAMType = ecs.NewComponentType[component_data.CiSysRAM]()
)

6
component/ci_qc.go
View File

@ -4,7 +4,7 @@ import (
"fmt"
"joylink.club/ecs"
"joylink.club/rtsssimulation/component/component_data"
"joylink.club/rtsssimulation/component/component_proto"
"joylink.club/rtsssimulation/repository/model/proto"
)
@ -55,7 +55,7 @@ func (qc *CiQcTable) QueryQdIndex(uid string) (int, bool) {
}
type CiQcState struct {
component_data.CiQcState
component_proto.CiQcState
}
func NewCiQcState(qlen int, clen int) *CiQcState {
@ -68,7 +68,7 @@ func NewCiQcState(qlen int, clen int) *CiQcState {
cbl++
}
return &CiQcState{
component_data.CiQcState{
component_proto.CiQcState{
Qbs: make([]byte, qbl),
Cbs: make([]byte, cbl),
},

36
component/ckm.go
View File

@ -1,36 +0,0 @@
package component
import (
"joylink.club/ecs"
)
var (
CkmTag = ecs.NewTag()
CkmCircuitType = ecs.NewComponentType[CkmCircuit]()
CkmPslType = ecs.NewComponentType[CkmPsl]()
CkmForceOpenTag = ecs.NewTag()
CkmForceCloseTag = ecs.NewTag()
)
type CkmCircuit struct {
MKJ *ecs.Entry //门开继电器
MGJ *ecs.Entry //门关继电器
MGZJ *ecs.Entry //门故障继电器
MPLJ *ecs.Entry //门旁路继电器
MMSJ *ecs.Entry //门模式继电器（吸合：远程/断开：本地）（初始状态：吸合）
KMJ *ecs.Entry //开门继电器
GMJ *ecs.Entry //关门继电器
}
func (c *CkmCircuit) RelayList() []*ecs.Entry {
return []*ecs.Entry{c.MKJ, c.MGJ, c.MGZJ, c.MPLJ, c.MMSJ, c.KMJ, c.GMJ}
}
type CkmPsl struct {
KMA *ecs.Entry //开门按钮
GMA *ecs.Entry //关门按钮
MPLA *ecs.Entry //门旁路按钮
MMSA *ecs.Entry //门模式按钮
}

34
component/common.go
View File

@ -2,58 +2,47 @@ package component
import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/component/component_data"
"joylink.club/rtsssimulation/component/component_proto"
"joylink.club/rtsssimulation/consts"
"joylink.club/rtsssimulation/repository/model/proto"
)
var (
UidType = ecs.NewComponentType[Uid]()
// 固定位置转换组件类型
FixedPositionTransformType = ecs.NewComponentType[FixedPositionTransform]()
// 电机状态组件类型
MotorStateType = ecs.NewComponentType[component_data.MotorState]()
BitStateType = ecs.NewComponentType[BitState]()
)
/*type Bypass struct {
BypassEnable bool // 摁钮，钥匙 是否旁路
OldVal bool //摁钮旁路旧值
}*/
// 唯一ID组件
type Uid struct {
Id string
}
var UidType = ecs.NewComponentType[Uid]()
// 两个稳态位置转换组件
// type TwoPositionTransform struct {
// Pos int // 当前位置百分比,[0, 10000],两位小数
// Speed int
// }
type FixedPositionTransform struct {
component_data.FixedPositionTransform
type TwoPositionTransform struct {
component_proto.TwoPositionTransform
}
// 当前位置百分比值
func (tp *FixedPositionTransform) Percentage() float32 {
func (tp *TwoPositionTransform) Percentage() float32 {
return float32(tp.Pos) / consts.TwoPosMax
}
var TwoPositionTransformType = ecs.NewComponentType[TwoPositionTransform]()
// 计算两位置动作的平均速度
// 总时间t和tick的单位都应该是ms
// t - 总时间，tick - 执行间隔
func CalculateTwoPositionAvgSpeed(t int, tick int) int32 {
return int32(consts.TwoPosMax / (t / tick))
}
// 仅有两状态的组件
type BitState struct {
//Bypass
Val bool
}
var BitStateType = ecs.NewComponentType[BitState]()
// 倒数/倒计时组件
type CounterDown struct {
Val int // 当前值
@ -69,6 +58,3 @@ type Counter struct {
}
var CounterType = ecs.NewComponentType[Counter]()
var LinkPositionType = ecs.NewComponentType[component_data.LinkPosition]()
var KmType = ecs.NewComponentType[proto.Kilometer]()

1305
component/component_data/ci.pb.go
View File

File diff suppressed because it is too large Load Diff

666
component/component_data/common.pb.go
View File

@ -1,666 +0,0 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.33.0
// protoc v4.23.1
// source: component/common.proto
package component_data
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// 电机
type MotorState struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// 是否通电
PowerUp bool `protobuf:"varint,1,opt,name=powerUp,proto3" json:"powerUp,omitempty"`
// 是否正转
Forward bool `protobuf:"varint,2,opt,name=forward,proto3" json:"forward,omitempty"`
}
func (x *MotorState) Reset() {
*x = MotorState{}
if protoimpl.UnsafeEnabled {
mi := &file_component_common_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *MotorState) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*MotorState) ProtoMessage() {}
func (x *MotorState) ProtoReflect() protoreflect.Message {
mi := &file_component_common_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use MotorState.ProtoReflect.Descriptor instead.
func (*MotorState) Descriptor() ([]byte, []int) {
return file_component_common_proto_rawDescGZIP(), []int{0}
}
func (x *MotorState) GetPowerUp() bool {
if x != nil {
return x.PowerUp
}
return false
}
func (x *MotorState) GetForward() bool {
if x != nil {
return x.Forward
}
return false
}
// 无极继电器和偏极继电器稳态为落下，也就是后接点(8组采集接点中的1,3接点,1为中接点),吸气为前接点（1,2接点）
// 有极继电器是定位反位双稳态（有永久磁钢）,前接点为定位,后接点为反位
// 有极继电器（对于道岔中的2DQJ）,励磁接点1,2接通为反位;3,4接通为定位
// 定义继电器状态时，false表示落下/反位/后接点,true表示吸起/定位/前接点
// 缓动继电器：指从通电或断电起,至接点转接止所需时间在0.3s以上的继电器。可分为缓放继电器(如无极缓放继电器等)和缓吸继电器(如热力继电器和时间继电器等)。
// 偏极继电器：只有通过规定方向的电流时,才吸起
// 继电器状态
type RelayState struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// 是否通电
PowerUp bool `protobuf:"varint,1,opt,name=powerUp,proto3" json:"powerUp,omitempty"`
// 是否励磁到前接点
Qq bool `protobuf:"varint,2,opt,name=qq,proto3" json:"qq,omitempty"`
// 是否在前接点位置
Q bool `protobuf:"varint,3,opt,name=q,proto3" json:"q,omitempty"`
}
func (x *RelayState) Reset() {
*x = RelayState{}
if protoimpl.UnsafeEnabled {
mi := &file_component_common_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RelayState) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RelayState) ProtoMessage() {}
func (x *RelayState) ProtoReflect() protoreflect.Message {
mi := &file_component_common_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RelayState.ProtoReflect.Descriptor instead.
func (*RelayState) Descriptor() ([]byte, []int) {
return file_component_common_proto_rawDescGZIP(), []int{1}
}
func (x *RelayState) GetPowerUp() bool {
if x != nil {
return x.PowerUp
}
return false
}
func (x *RelayState) GetQq() bool {
if x != nil {
return x.Qq
}
return false
}
func (x *RelayState) GetQ() bool {
if x != nil {
return x.Q
}
return false
}
// 开关类设备状态
type SwitchState struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// 是否按下(按钮式开关true表示按下,旋钮开关true非常态位)
Pressed bool `protobuf:"varint,2,opt,name=pressed,proto3" json:"pressed,omitempty"`
}
func (x *SwitchState) Reset() {
*x = SwitchState{}
if protoimpl.UnsafeEnabled {
mi := &file_component_common_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *SwitchState) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*SwitchState) ProtoMessage() {}
func (x *SwitchState) ProtoReflect() protoreflect.Message {
mi := &file_component_common_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use SwitchState.ProtoReflect.Descriptor instead.
func (*SwitchState) Descriptor() ([]byte, []int) {
return file_component_common_proto_rawDescGZIP(), []int{2}
}
func (x *SwitchState) GetPressed() bool {
if x != nil {
return x.Pressed
}
return false
}
// 固定位置转换组件
type FixedPositionTransform struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Pos int32 `protobuf:"varint,1,opt,name=pos,proto3" json:"pos,omitempty"` // 当前位置,[0, 10000]
Speed int32 `protobuf:"varint,2,opt,name=speed,proto3" json:"speed,omitempty"`
}
func (x *FixedPositionTransform) Reset() {
*x = FixedPositionTransform{}
if protoimpl.UnsafeEnabled {
mi := &file_component_common_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *FixedPositionTransform) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*FixedPositionTransform) ProtoMessage() {}
func (x *FixedPositionTransform) ProtoReflect() protoreflect.Message {
mi := &file_component_common_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use FixedPositionTransform.ProtoReflect.Descriptor instead.
func (*FixedPositionTransform) Descriptor() ([]byte, []int) {
return file_component_common_proto_rawDescGZIP(), []int{3}
}
func (x *FixedPositionTransform) GetPos() int32 {
if x != nil {
return x.Pos
}
return 0
}
func (x *FixedPositionTransform) GetSpeed() int32 {
if x != nil {
return x.Speed
}
return 0
}
// 开关状态组件
type BitState struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Val bool `protobuf:"varint,1,opt,name=val,proto3" json:"val,omitempty"`
}
func (x *BitState) Reset() {
*x = BitState{}
if protoimpl.UnsafeEnabled {
mi := &file_component_common_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BitState) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BitState) ProtoMessage() {}
func (x *BitState) ProtoReflect() protoreflect.Message {
mi := &file_component_common_proto_msgTypes[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BitState.ProtoReflect.Descriptor instead.
func (*BitState) Descriptor() ([]byte, []int) {
return file_component_common_proto_rawDescGZIP(), []int{4}
}
func (x *BitState) GetVal() bool {
if x != nil {
return x.Val
}
return false
}
// 计数/计时组件
type Counter struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Val int32 `protobuf:"varint,1,opt,name=val,proto3" json:"val,omitempty"`
Step int32 `protobuf:"varint,2,opt,name=step,proto3" json:"step,omitempty"`
}
func (x *Counter) Reset() {
*x = Counter{}
if protoimpl.UnsafeEnabled {
mi := &file_component_common_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Counter) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Counter) ProtoMessage() {}
func (x *Counter) ProtoReflect() protoreflect.Message {
mi := &file_component_common_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Counter.ProtoReflect.Descriptor instead.
func (*Counter) Descriptor() ([]byte, []int) {
return file_component_common_proto_rawDescGZIP(), []int{5}
}
func (x *Counter) GetVal() int32 {
if x != nil {
return x.Val
}
return 0
}
func (x *Counter) GetStep() int32 {
if x != nil {
return x.Step
}
return 0
}
// Link位置
type LinkPosition struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Link的ID
LinkId string `protobuf:"bytes,1,opt,name=linkId,proto3" json:"linkId,omitempty"`
// Link的偏移量
Offset int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
}
func (x *LinkPosition) Reset() {
*x = LinkPosition{}
if protoimpl.UnsafeEnabled {
mi := &file_component_common_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *LinkPosition) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*LinkPosition) ProtoMessage() {}
func (x *LinkPosition) ProtoReflect() protoreflect.Message {
mi := &file_component_common_proto_msgTypes[6]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use LinkPosition.ProtoReflect.Descriptor instead.
func (*LinkPosition) Descriptor() ([]byte, []int) {
return file_component_common_proto_rawDescGZIP(), []int{6}
}
func (x *LinkPosition) GetLinkId() string {
if x != nil {
return x.LinkId
}
return ""
}
func (x *LinkPosition) GetOffset() int64 {
if x != nil {
return x.Offset
}
return 0
}
// 倒数/倒计时组件
type CounterDown struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Val int32 `protobuf:"varint,1,opt,name=val,proto3" json:"val,omitempty"`
Step int32 `protobuf:"varint,2,opt,name=step,proto3" json:"step,omitempty"`
}
func (x *CounterDown) Reset() {
*x = CounterDown{}
if protoimpl.UnsafeEnabled {
mi := &file_component_common_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *CounterDown) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*CounterDown) ProtoMessage() {}
func (x *CounterDown) ProtoReflect() protoreflect.Message {
mi := &file_component_common_proto_msgTypes[7]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use CounterDown.ProtoReflect.Descriptor instead.
func (*CounterDown) Descriptor() ([]byte, []int) {
return file_component_common_proto_rawDescGZIP(), []int{7}
}
func (x *CounterDown) GetVal() int32 {
if x != nil {
return x.Val
}
return 0
}
func (x *CounterDown) GetStep() int32 {
if x != nil {
return x.Step
}
return 0
}
var File_component_common_proto protoreflect.FileDescriptor
var file_component_common_proto_rawDesc = []byte{
0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f, 0x63, 0x6f, 0x6d, 0x6d,
0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x09, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x22, 0x40, 0x0a, 0x0a, 0x4d, 0x6f, 0x74, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x74,
0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x55, 0x70, 0x18, 0x01, 0x20, 0x01,
0x28, 0x08, 0x52, 0x07, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x55, 0x70, 0x12, 0x18, 0x0a, 0x07, 0x66,
0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x66, 0x6f,
0x72, 0x77, 0x61, 0x72, 0x64, 0x22, 0x44, 0x0a, 0x0a, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x53, 0x74,
0x61, 0x74, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x55, 0x70, 0x18, 0x01,
0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x55, 0x70, 0x12, 0x0e, 0x0a,
0x02, 0x71, 0x71, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x02, 0x71, 0x71, 0x12, 0x0c, 0x0a,
0x01, 0x71, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x01, 0x71, 0x22, 0x27, 0x0a, 0x0b, 0x53,
0x77, 0x69, 0x74, 0x63, 0x68, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x72,
0x65, 0x73, 0x73, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x70, 0x72, 0x65,
0x73, 0x73, 0x65, 0x64, 0x22, 0x40, 0x0a, 0x16, 0x46, 0x69, 0x78, 0x65, 0x64, 0x50, 0x6f, 0x73,
0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x12, 0x10,
0x0a, 0x03, 0x70, 0x6f, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x70, 0x6f, 0x73,
0x12, 0x14, 0x0a, 0x05, 0x73, 0x70, 0x65, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52,
0x05, 0x73, 0x70, 0x65, 0x65, 0x64, 0x22, 0x1c, 0x0a, 0x08, 0x42, 0x69, 0x74, 0x53, 0x74, 0x61,
0x74, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x76, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52,
0x03, 0x76, 0x61, 0x6c, 0x22, 0x2f, 0x0a, 0x07, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x12,
0x10, 0x0a, 0x03, 0x76, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x76, 0x61,
0x6c, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x74, 0x65, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52,
0x04, 0x73, 0x74, 0x65, 0x70, 0x22, 0x3e, 0x0a, 0x0c, 0x4c, 0x69, 0x6e, 0x6b, 0x50, 0x6f, 0x73,
0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x6c, 0x69, 0x6e, 0x6b, 0x49, 0x64, 0x18,
0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6c, 0x69, 0x6e, 0x6b, 0x49, 0x64, 0x12, 0x16, 0x0a,
0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6f,
0x66, 0x66, 0x73, 0x65, 0x74, 0x22, 0x33, 0x0a, 0x0b, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72,
0x44, 0x6f, 0x77, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x76, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28,
0x05, 0x52, 0x03, 0x76, 0x61, 0x6c, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x74, 0x65, 0x70, 0x18, 0x02,
0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x73, 0x74, 0x65, 0x70, 0x42, 0x1c, 0x5a, 0x1a, 0x2e, 0x2f,
0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
file_component_common_proto_rawDescOnce sync.Once
file_component_common_proto_rawDescData = file_component_common_proto_rawDesc
)
func file_component_common_proto_rawDescGZIP() []byte {
file_component_common_proto_rawDescOnce.Do(func() {
file_component_common_proto_rawDescData = protoimpl.X.CompressGZIP(file_component_common_proto_rawDescData)
})
return file_component_common_proto_rawDescData
}
var file_component_common_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
var file_component_common_proto_goTypes = []interface{}{
(*MotorState)(nil), // 0: component.MotorState
(*RelayState)(nil), // 1: component.RelayState
(*SwitchState)(nil), // 2: component.SwitchState
(*FixedPositionTransform)(nil), // 3: component.FixedPositionTransform
(*BitState)(nil), // 4: component.BitState
(*Counter)(nil), // 5: component.Counter
(*LinkPosition)(nil), // 6: component.LinkPosition
(*CounterDown)(nil), // 7: component.CounterDown
}
var file_component_common_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_component_common_proto_init() }
func file_component_common_proto_init() {
if File_component_common_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_component_common_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*MotorState); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_common_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RelayState); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_common_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*SwitchState); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_common_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*FixedPositionTransform); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_common_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BitState); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_common_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Counter); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_common_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*LinkPosition); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_common_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*CounterDown); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_component_common_proto_rawDesc,
NumEnums: 0,
NumMessages: 8,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_component_common_proto_goTypes,
DependencyIndexes: file_component_common_proto_depIdxs,
MessageInfos: file_component_common_proto_msgTypes,
}.Build()
File_component_common_proto = out.File
file_component_common_proto_rawDesc = nil
file_component_common_proto_goTypes = nil
file_component_common_proto_depIdxs = nil
}

144
component/component_data/equipment.pb.go
View File

@ -1,144 +0,0 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.33.0
// protoc v4.23.1
// source: component/equipment.proto
package component_data
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// 继电器强制故障(强制在某个位置)
type RelayFaultForce struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Q bool `protobuf:"varint,1,opt,name=q,proto3" json:"q,omitempty"` // 是否强制到前接点(吸起)位置
}
func (x *RelayFaultForce) Reset() {
*x = RelayFaultForce{}
if protoimpl.UnsafeEnabled {
mi := &file_component_equipment_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *RelayFaultForce) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*RelayFaultForce) ProtoMessage() {}
func (x *RelayFaultForce) ProtoReflect() protoreflect.Message {
mi := &file_component_equipment_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use RelayFaultForce.ProtoReflect.Descriptor instead.
func (*RelayFaultForce) Descriptor() ([]byte, []int) {
return file_component_equipment_proto_rawDescGZIP(), []int{0}
}
func (x *RelayFaultForce) GetQ() bool {
if x != nil {
return x.Q
}
return false
}
var File_component_equipment_proto protoreflect.FileDescriptor
var file_component_equipment_proto_rawDesc = []byte{
0x0a, 0x19, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f, 0x65, 0x71, 0x75, 0x69,
0x70, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x09, 0x63, 0x6f, 0x6d,
0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x22, 0x1f, 0x0a, 0x0f, 0x52, 0x65, 0x6c, 0x61, 0x79, 0x46,
0x61, 0x75, 0x6c, 0x74, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x12, 0x0c, 0x0a, 0x01, 0x71, 0x18, 0x01,
0x20, 0x01, 0x28, 0x08, 0x52, 0x01, 0x71, 0x42, 0x1c, 0x5a, 0x1a, 0x2e, 0x2f, 0x63, 0x6f, 0x6d,
0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x5f, 0x64, 0x61, 0x74, 0x61, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
file_component_equipment_proto_rawDescOnce sync.Once
file_component_equipment_proto_rawDescData = file_component_equipment_proto_rawDesc
)
func file_component_equipment_proto_rawDescGZIP() []byte {
file_component_equipment_proto_rawDescOnce.Do(func() {
file_component_equipment_proto_rawDescData = protoimpl.X.CompressGZIP(file_component_equipment_proto_rawDescData)
})
return file_component_equipment_proto_rawDescData
}
var file_component_equipment_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_component_equipment_proto_goTypes = []interface{}{
(*RelayFaultForce)(nil), // 0: component.RelayFaultForce
}
var file_component_equipment_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_component_equipment_proto_init() }
func file_component_equipment_proto_init() {
if File_component_equipment_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_component_equipment_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*RelayFaultForce); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_component_equipment_proto_rawDesc,
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_component_equipment_proto_goTypes,
DependencyIndexes: file_component_equipment_proto_depIdxs,
MessageInfos: file_component_equipment_proto_msgTypes,
}.Build()
File_component_equipment_proto = out.File
file_component_equipment_proto_rawDesc = nil
file_component_equipment_proto_goTypes = nil
file_component_equipment_proto_depIdxs = nil
}

639
component/component_data/points.pb.go
View File

@ -1,639 +0,0 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.33.0
// protoc v4.23.1
// source: component/points.proto
package component_data
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// 道岔故障
type Points_Fault int32
const (
// 失表
Points_SB Points_Fault = 0
// 定位失表
Points_DWSB Points_Fault = 1
// 反位失表
Points_FWSB Points_Fault = 2
// 挤岔
Points_JC Points_Fault = 3
// 联锁无法驱动故障
Points_CIQD Points_Fault = 4
)
// Enum value maps for Points_Fault.
var (
Points_Fault_name = map[int32]string{
0: "SB",
1: "DWSB",
2: "FWSB",
3: "JC",
4: "CIQD",
}
Points_Fault_value = map[string]int32{
"SB": 0,
"DWSB": 1,
"FWSB": 2,
"JC": 3,
"CIQD": 4,
}
)
func (x Points_Fault) Enum() *Points_Fault {
p := new(Points_Fault)
*p = x
return p
}
func (x Points_Fault) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (Points_Fault) Descriptor() protoreflect.EnumDescriptor {
return file_component_points_proto_enumTypes[0].Descriptor()
}
func (Points_Fault) Type() protoreflect.EnumType {
return &file_component_points_proto_enumTypes[0]
}
func (x Points_Fault) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use Points_Fault.Descriptor instead.
func (Points_Fault) EnumDescriptor() ([]byte, []int) {
return file_component_points_proto_rawDescGZIP(), []int{2, 0}
}
// 道岔转辙机自动开闭器状态
// 自动开闭器接点位置,默认定位接通1/3排，反位接通2/4排
// 由定位转反位（1DQJ和1DQJF励磁吸起,2DQJ在反位——即落下）,三相电路导通,电机开始反转,转辙机将第3排接点接通第4排,到位锁闭后,转辙机的自动开闭器拉簧将第1排接点拉到第2排,接点到2排后,三相电路断路
// 由反位转定位（1DQJ和1DQJF励磁吸起,2DQJ在定位——即吸起）,三相电路导通,电机开始正转,转辙机将第2排接点接通第1排,到位锁闭后,转辙机的自动开闭器拉簧将第4排接点拉到第3排,接点到3排后,三相电路断路
type PointsZzjKbqState struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// 接点在1/2排的位置,false-接点在1排,true-接点在2排
Jd13 bool `protobuf:"varint,1,opt,name=jd13,proto3" json:"jd13,omitempty"`
// 接点在3/4排的位置,false-接点在3排,true-接点在4排
Jd24 bool `protobuf:"varint,2,opt,name=jd24,proto3" json:"jd24,omitempty"`
}
func (x *PointsZzjKbqState) Reset() {
*x = PointsZzjKbqState{}
if protoimpl.UnsafeEnabled {
mi := &file_component_points_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PointsZzjKbqState) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PointsZzjKbqState) ProtoMessage() {}
func (x *PointsZzjKbqState) ProtoReflect() protoreflect.Message {
mi := &file_component_points_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PointsZzjKbqState.ProtoReflect.Descriptor instead.
func (*PointsZzjKbqState) Descriptor() ([]byte, []int) {
return file_component_points_proto_rawDescGZIP(), []int{0}
}
func (x *PointsZzjKbqState) GetJd13() bool {
if x != nil {
return x.Jd13
}
return false
}
func (x *PointsZzjKbqState) GetJd24() bool {
if x != nil {
return x.Jd24
}
return false
}
// 道岔位置状态表示组件
type PointsPosition struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// 是否定位(实际位置)
Dw bool `protobuf:"varint,1,opt,name=dw,proto3" json:"dw,omitempty"`
// 是否反位(实际位置)
Fw bool `protobuf:"varint,2,opt,name=fw,proto3" json:"fw,omitempty"`
// 定表
Db bool `protobuf:"varint,3,opt,name=db,proto3" json:"db,omitempty"`
// 反表
Fb bool `protobuf:"varint,4,opt,name=fb,proto3" json:"fb,omitempty"`
}
func (x *PointsPosition) Reset() {
*x = PointsPosition{}
if protoimpl.UnsafeEnabled {
mi := &file_component_points_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PointsPosition) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PointsPosition) ProtoMessage() {}
func (x *PointsPosition) ProtoReflect() protoreflect.Message {
mi := &file_component_points_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PointsPosition.ProtoReflect.Descriptor instead.
func (*PointsPosition) Descriptor() ([]byte, []int) {
return file_component_points_proto_rawDescGZIP(), []int{1}
}
func (x *PointsPosition) GetDw() bool {
if x != nil {
return x.Dw
}
return false
}
func (x *PointsPosition) GetFw() bool {
if x != nil {
return x.Fw
}
return false
}
func (x *PointsPosition) GetDb() bool {
if x != nil {
return x.Db
}
return false
}
func (x *PointsPosition) GetFb() bool {
if x != nil {
return x.Fb
}
return false
}
// 道岔
type Points struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *Points) Reset() {
*x = Points{}
if protoimpl.UnsafeEnabled {
mi := &file_component_points_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Points) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Points) ProtoMessage() {}
func (x *Points) ProtoReflect() protoreflect.Message {
mi := &file_component_points_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Points.ProtoReflect.Descriptor instead.
func (*Points) Descriptor() ([]byte, []int) {
return file_component_points_proto_rawDescGZIP(), []int{2}
}
// 道岔失表故障
type PointsFaultSB struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *PointsFaultSB) Reset() {
*x = PointsFaultSB{}
if protoimpl.UnsafeEnabled {
mi := &file_component_points_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PointsFaultSB) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PointsFaultSB) ProtoMessage() {}
func (x *PointsFaultSB) ProtoReflect() protoreflect.Message {
mi := &file_component_points_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PointsFaultSB.ProtoReflect.Descriptor instead.
func (*PointsFaultSB) Descriptor() ([]byte, []int) {
return file_component_points_proto_rawDescGZIP(), []int{3}
}
// 道岔定位失表故障
type PointsFaultDwsb struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *PointsFaultDwsb) Reset() {
*x = PointsFaultDwsb{}
if protoimpl.UnsafeEnabled {
mi := &file_component_points_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PointsFaultDwsb) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PointsFaultDwsb) ProtoMessage() {}
func (x *PointsFaultDwsb) ProtoReflect() protoreflect.Message {
mi := &file_component_points_proto_msgTypes[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PointsFaultDwsb.ProtoReflect.Descriptor instead.
func (*PointsFaultDwsb) Descriptor() ([]byte, []int) {
return file_component_points_proto_rawDescGZIP(), []int{4}
}
// 道岔反位失表故障
type PointsFaultFwsb struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *PointsFaultFwsb) Reset() {
*x = PointsFaultFwsb{}
if protoimpl.UnsafeEnabled {
mi := &file_component_points_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PointsFaultFwsb) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PointsFaultFwsb) ProtoMessage() {}
func (x *PointsFaultFwsb) ProtoReflect() protoreflect.Message {
mi := &file_component_points_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PointsFaultFwsb.ProtoReflect.Descriptor instead.
func (*PointsFaultFwsb) Descriptor() ([]byte, []int) {
return file_component_points_proto_rawDescGZIP(), []int{5}
}
// 道岔挤岔故障
type PointsFaultJc struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *PointsFaultJc) Reset() {
*x = PointsFaultJc{}
if protoimpl.UnsafeEnabled {
mi := &file_component_points_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PointsFaultJc) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PointsFaultJc) ProtoMessage() {}
func (x *PointsFaultJc) ProtoReflect() protoreflect.Message {
mi := &file_component_points_proto_msgTypes[6]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PointsFaultJc.ProtoReflect.Descriptor instead.
func (*PointsFaultJc) Descriptor() ([]byte, []int) {
return file_component_points_proto_rawDescGZIP(), []int{6}
}
// 道岔联锁无法驱动故障
type PointsFaultCiqd struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *PointsFaultCiqd) Reset() {
*x = PointsFaultCiqd{}
if protoimpl.UnsafeEnabled {
mi := &file_component_points_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PointsFaultCiqd) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PointsFaultCiqd) ProtoMessage() {}
func (x *PointsFaultCiqd) ProtoReflect() protoreflect.Message {
mi := &file_component_points_proto_msgTypes[7]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PointsFaultCiqd.ProtoReflect.Descriptor instead.
func (*PointsFaultCiqd) Descriptor() ([]byte, []int) {
return file_component_points_proto_rawDescGZIP(), []int{7}
}
var File_component_points_proto protoreflect.FileDescriptor
var file_component_points_proto_rawDesc = []byte{
0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f, 0x70, 0x6f, 0x69, 0x6e,
0x74, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x09, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x22, 0x3b, 0x0a, 0x11, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x5a, 0x7a, 0x6a,
0x4b, 0x62, 0x71, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6a, 0x64, 0x31, 0x33,
0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x6a, 0x64, 0x31, 0x33, 0x12, 0x12, 0x0a, 0x04,
0x6a, 0x64, 0x32, 0x34, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x6a, 0x64, 0x32, 0x34,
0x22, 0x50, 0x0a, 0x0e, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69,
0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x64, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x02,
0x64, 0x77, 0x12, 0x0e, 0x0a, 0x02, 0x66, 0x77, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x02,
0x66, 0x77, 0x12, 0x0e, 0x0a, 0x02, 0x64, 0x62, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x02,
0x64, 0x62, 0x12, 0x0e, 0x0a, 0x02, 0x66, 0x62, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x02,
0x66, 0x62, 0x22, 0x3f, 0x0a, 0x06, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x22, 0x35, 0x0a, 0x05,
0x46, 0x61, 0x75, 0x6c, 0x74, 0x12, 0x06, 0x0a, 0x02, 0x53, 0x42, 0x10, 0x00, 0x12, 0x08, 0x0a,
0x04, 0x44, 0x57, 0x53, 0x42, 0x10, 0x01, 0x12, 0x08, 0x0a, 0x04, 0x46, 0x57, 0x53, 0x42, 0x10,
0x02, 0x12, 0x06, 0x0a, 0x02, 0x4a, 0x43, 0x10, 0x03, 0x12, 0x08, 0x0a, 0x04, 0x43, 0x49, 0x51,
0x44, 0x10, 0x04, 0x22, 0x0f, 0x0a, 0x0d, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x46, 0x61, 0x75,
0x6c, 0x74, 0x53, 0x42, 0x22, 0x11, 0x0a, 0x0f, 0x50, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x46, 0x61,
0x75, 0x6c, 0x74, 0x44, 0x77, 0x73, 0x62, 0x22, 0x11, 0x0a, 0x0f, 0x50, 0x6f, 0x69, 0x6e, 0x74,
0x73, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x46, 0x77, 0x73, 0x62, 0x22, 0x0f, 0x0a, 0x0d, 0x50, 0x6f,
0x69, 0x6e, 0x74, 0x73, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x4a, 0x63, 0x22, 0x11, 0x0a, 0x0f, 0x50,
0x6f, 0x69, 0x6e, 0x74, 0x73, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x69, 0x71, 0x64, 0x42, 0x1c,
0x5a, 0x1a, 0x2e, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f, 0x63, 0x6f,
0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x62, 0x06, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x33,
}
var (
file_component_points_proto_rawDescOnce sync.Once
file_component_points_proto_rawDescData = file_component_points_proto_rawDesc
)
func file_component_points_proto_rawDescGZIP() []byte {
file_component_points_proto_rawDescOnce.Do(func() {
file_component_points_proto_rawDescData = protoimpl.X.CompressGZIP(file_component_points_proto_rawDescData)
})
return file_component_points_proto_rawDescData
}
var file_component_points_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_component_points_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
var file_component_points_proto_goTypes = []interface{}{
(Points_Fault)(0), // 0: component.Points.Fault
(*PointsZzjKbqState)(nil), // 1: component.PointsZzjKbqState
(*PointsPosition)(nil), // 2: component.PointsPosition
(*Points)(nil), // 3: component.Points
(*PointsFaultSB)(nil), // 4: component.PointsFaultSB
(*PointsFaultDwsb)(nil), // 5: component.PointsFaultDwsb
(*PointsFaultFwsb)(nil), // 6: component.PointsFaultFwsb
(*PointsFaultJc)(nil), // 7: component.PointsFaultJc
(*PointsFaultCiqd)(nil), // 8: component.PointsFaultCiqd
}
var file_component_points_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_component_points_proto_init() }
func file_component_points_proto_init() {
if File_component_points_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_component_points_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PointsZzjKbqState); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_points_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PointsPosition); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_points_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Points); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_points_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PointsFaultSB); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_points_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PointsFaultDwsb); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_points_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PointsFaultFwsb); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_points_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PointsFaultJc); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_points_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PointsFaultCiqd); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_component_points_proto_rawDesc,
NumEnums: 1,
NumMessages: 8,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_component_points_proto_goTypes,
DependencyIndexes: file_component_points_proto_depIdxs,
EnumInfos: file_component_points_proto_enumTypes,
MessageInfos: file_component_points_proto_msgTypes,
}.Build()
File_component_points_proto = out.File
file_component_points_proto_rawDesc = nil
file_component_points_proto_goTypes = nil
file_component_points_proto_depIdxs = nil
}

155
component/component_proto/ci.pb.go Normal file
View File

@ -0,0 +1,155 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.31.0
// protoc v4.23.1
// source: component/ci.proto
package component_proto
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// 联锁驱动、采集状态表
type CiQcState struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// 驱动bit表
Qbs []byte `protobuf:"bytes,1,opt,name=qbs,proto3" json:"qbs,omitempty"`
// 采集bit表
Cbs []byte `protobuf:"bytes,2,opt,name=cbs,proto3" json:"cbs,omitempty"`
}
func (x *CiQcState) Reset() {
*x = CiQcState{}
if protoimpl.UnsafeEnabled {
mi := &file_component_ci_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *CiQcState) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*CiQcState) ProtoMessage() {}
func (x *CiQcState) ProtoReflect() protoreflect.Message {
mi := &file_component_ci_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use CiQcState.ProtoReflect.Descriptor instead.
func (*CiQcState) Descriptor() ([]byte, []int) {
return file_component_ci_proto_rawDescGZIP(), []int{0}
}
func (x *CiQcState) GetQbs() []byte {
if x != nil {
return x.Qbs
}
return nil
}
func (x *CiQcState) GetCbs() []byte {
if x != nil {
return x.Cbs
}
return nil
}
var File_component_ci_proto protoreflect.FileDescriptor
var file_component_ci_proto_rawDesc = []byte{
0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f, 0x63, 0x69, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x12, 0x09, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x22,
0x2f, 0x0a, 0x09, 0x43, 0x69, 0x51, 0x63, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x10, 0x0a, 0x03,
0x71, 0x62, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x71, 0x62, 0x73, 0x12, 0x10,
0x0a, 0x03, 0x63, 0x62, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x63, 0x62, 0x73,
0x42, 0x1d, 0x5a, 0x1b, 0x2e, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f,
0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
file_component_ci_proto_rawDescOnce sync.Once
file_component_ci_proto_rawDescData = file_component_ci_proto_rawDesc
)
func file_component_ci_proto_rawDescGZIP() []byte {
file_component_ci_proto_rawDescOnce.Do(func() {
file_component_ci_proto_rawDescData = protoimpl.X.CompressGZIP(file_component_ci_proto_rawDescData)
})
return file_component_ci_proto_rawDescData
}
var file_component_ci_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_component_ci_proto_goTypes = []interface{}{
(*CiQcState)(nil), // 0: component.CiQcState
}
var file_component_ci_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_component_ci_proto_init() }
func file_component_ci_proto_init() {
if File_component_ci_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_component_ci_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*CiQcState); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_component_ci_proto_rawDesc,
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_component_ci_proto_goTypes,
DependencyIndexes: file_component_ci_proto_depIdxs,
MessageInfos: file_component_ci_proto_msgTypes,
}.Build()
File_component_ci_proto = out.File
file_component_ci_proto_rawDesc = nil
file_component_ci_proto_goTypes = nil
file_component_ci_proto_depIdxs = nil
}

361
component/component_proto/common.pb.go Normal file
View File

@ -0,0 +1,361 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.31.0
// protoc v4.23.1
// source: component/common.proto
package component_proto
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// 两个稳态位置转换组件
type TwoPositionTransform struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Pos int32 `protobuf:"varint,1,opt,name=pos,proto3" json:"pos,omitempty"` // 当前位置百分比,[0, 10000],两位小数
Speed int32 `protobuf:"varint,2,opt,name=speed,proto3" json:"speed,omitempty"`
}
func (x *TwoPositionTransform) Reset() {
*x = TwoPositionTransform{}
if protoimpl.UnsafeEnabled {
mi := &file_component_common_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *TwoPositionTransform) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*TwoPositionTransform) ProtoMessage() {}
func (x *TwoPositionTransform) ProtoReflect() protoreflect.Message {
mi := &file_component_common_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use TwoPositionTransform.ProtoReflect.Descriptor instead.
func (*TwoPositionTransform) Descriptor() ([]byte, []int) {
return file_component_common_proto_rawDescGZIP(), []int{0}
}
func (x *TwoPositionTransform) GetPos() int32 {
if x != nil {
return x.Pos
}
return 0
}
func (x *TwoPositionTransform) GetSpeed() int32 {
if x != nil {
return x.Speed
}
return 0
}
// 仅有两状态的组件
type BitState struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Val bool `protobuf:"varint,1,opt,name=val,proto3" json:"val,omitempty"`
}
func (x *BitState) Reset() {
*x = BitState{}
if protoimpl.UnsafeEnabled {
mi := &file_component_common_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *BitState) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*BitState) ProtoMessage() {}
func (x *BitState) ProtoReflect() protoreflect.Message {
mi := &file_component_common_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use BitState.ProtoReflect.Descriptor instead.
func (*BitState) Descriptor() ([]byte, []int) {
return file_component_common_proto_rawDescGZIP(), []int{1}
}
func (x *BitState) GetVal() bool {
if x != nil {
return x.Val
}
return false
}
// 计数/计时组件
type Counter struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Val int32 `protobuf:"varint,1,opt,name=val,proto3" json:"val,omitempty"`
Step int32 `protobuf:"varint,2,opt,name=step,proto3" json:"step,omitempty"`
}
func (x *Counter) Reset() {
*x = Counter{}
if protoimpl.UnsafeEnabled {
mi := &file_component_common_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Counter) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Counter) ProtoMessage() {}
func (x *Counter) ProtoReflect() protoreflect.Message {
mi := &file_component_common_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Counter.ProtoReflect.Descriptor instead.
func (*Counter) Descriptor() ([]byte, []int) {
return file_component_common_proto_rawDescGZIP(), []int{2}
}
func (x *Counter) GetVal() int32 {
if x != nil {
return x.Val
}
return 0
}
func (x *Counter) GetStep() int32 {
if x != nil {
return x.Step
}
return 0
}
// 倒数/倒计时组件
type CounterDown struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Val int32 `protobuf:"varint,1,opt,name=val,proto3" json:"val,omitempty"`
Step int32 `protobuf:"varint,2,opt,name=step,proto3" json:"step,omitempty"`
}
func (x *CounterDown) Reset() {
*x = CounterDown{}
if protoimpl.UnsafeEnabled {
mi := &file_component_common_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *CounterDown) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*CounterDown) ProtoMessage() {}
func (x *CounterDown) ProtoReflect() protoreflect.Message {
mi := &file_component_common_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use CounterDown.ProtoReflect.Descriptor instead.
func (*CounterDown) Descriptor() ([]byte, []int) {
return file_component_common_proto_rawDescGZIP(), []int{3}
}
func (x *CounterDown) GetVal() int32 {
if x != nil {
return x.Val
}
return 0
}
func (x *CounterDown) GetStep() int32 {
if x != nil {
return x.Step
}
return 0
}
var File_component_common_proto protoreflect.FileDescriptor
var file_component_common_proto_rawDesc = []byte{
0x0a, 0x16, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f, 0x63, 0x6f, 0x6d, 0x6d,
0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x09, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e,
0x65, 0x6e, 0x74, 0x22, 0x3e, 0x0a, 0x14, 0x54, 0x77, 0x6f, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69,
0x6f, 0x6e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x12, 0x10, 0x0a, 0x03, 0x70,
0x6f, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x70, 0x6f, 0x73, 0x12, 0x14, 0x0a,
0x05, 0x73, 0x70, 0x65, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x70,
0x65, 0x65, 0x64, 0x22, 0x1c, 0x0a, 0x08, 0x42, 0x69, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12,
0x10, 0x0a, 0x03, 0x76, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x03, 0x76, 0x61,
0x6c, 0x22, 0x2f, 0x0a, 0x07, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x12, 0x10, 0x0a, 0x03,
0x76, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x76, 0x61, 0x6c, 0x12, 0x12,
0x0a, 0x04, 0x73, 0x74, 0x65, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x73, 0x74,
0x65, 0x70, 0x22, 0x33, 0x0a, 0x0b, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x44, 0x6f, 0x77,
0x6e, 0x12, 0x10, 0x0a, 0x03, 0x76, 0x61, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03,
0x76, 0x61, 0x6c, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x74, 0x65, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28,
0x05, 0x52, 0x04, 0x73, 0x74, 0x65, 0x70, 0x42, 0x1d, 0x5a, 0x1b, 0x2e, 0x2f, 0x63, 0x6f, 0x6d,
0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
file_component_common_proto_rawDescOnce sync.Once
file_component_common_proto_rawDescData = file_component_common_proto_rawDesc
)
func file_component_common_proto_rawDescGZIP() []byte {
file_component_common_proto_rawDescOnce.Do(func() {
file_component_common_proto_rawDescData = protoimpl.X.CompressGZIP(file_component_common_proto_rawDescData)
})
return file_component_common_proto_rawDescData
}
var file_component_common_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
var file_component_common_proto_goTypes = []interface{}{
(*TwoPositionTransform)(nil), // 0: component.TwoPositionTransform
(*BitState)(nil), // 1: component.BitState
(*Counter)(nil), // 2: component.Counter
(*CounterDown)(nil), // 3: component.CounterDown
}
var file_component_common_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_component_common_proto_init() }
func file_component_common_proto_init() {
if File_component_common_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_component_common_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*TwoPositionTransform); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_common_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*BitState); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_common_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Counter); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_component_common_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*CounterDown); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_component_common_proto_rawDesc,
NumEnums: 0,
NumMessages: 4,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_component_common_proto_goTypes,
DependencyIndexes: file_component_common_proto_depIdxs,
MessageInfos: file_component_common_proto_msgTypes,
}.Build()
File_component_common_proto = out.File
file_component_common_proto_rawDesc = nil
file_component_common_proto_goTypes = nil
file_component_common_proto_depIdxs = nil
}

69
component/component_proto/psd.pb.go
View File

@ -1,6 +1,6 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.33.0
// protoc-gen-go v1.31.0
// protoc v4.23.1
// source: component/psd.proto
@ -74,9 +74,7 @@ type PsdState struct {
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Close bool `protobuf:"varint,1,opt,name=close,proto3" json:"close,omitempty"`
Obstacle bool `protobuf:"varint,2,opt,name=obstacle,proto3" json:"obstacle,omitempty"` //有障碍物
InterlockRelease bool `protobuf:"varint,3,opt,name=interlockRelease,proto3" json:"interlockRelease,omitempty"` //互锁解除
Close bool `protobuf:"varint,1,opt,name=close,proto3" json:"close,omitempty"`
}
func (x *PsdState) Reset() {
@ -118,20 +116,6 @@ func (x *PsdState) GetClose() bool {
return false
}
func (x *PsdState) GetObstacle() bool {
if x != nil {
return x.Obstacle
}
return false
}
func (x *PsdState) GetInterlockRelease() bool {
if x != nil {
return x.InterlockRelease
}
return false
}
type Psd struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
@ -175,11 +159,9 @@ type AsdState struct {
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Gmdw bool `protobuf:"varint,1,opt,name=gmdw,proto3" json:"gmdw,omitempty"` //关门到位（实际位置）
Kmdw bool `protobuf:"varint,2,opt,name=kmdw,proto3" json:"kmdw,omitempty"` //开门到位（实际位置）
Mgj bool `protobuf:"varint,3,opt,name=mgj,proto3" json:"mgj,omitempty"` //门关继电器
Zaw bool `protobuf:"varint,4,opt,name=zaw,proto3" json:"zaw,omitempty"` //有障碍物
Force bool `protobuf:"varint,5,opt,name=force,proto3" json:"force,omitempty"` //强制开/关门
Gmdw bool `protobuf:"varint,1,opt,name=gmdw,proto3" json:"gmdw,omitempty"` //关门到位（实际位置）
Kmdw bool `protobuf:"varint,2,opt,name=kmdw,proto3" json:"kmdw,omitempty"` //开门到位（实际位置）
Mgj bool `protobuf:"varint,3,opt,name=mgj,proto3" json:"mgj,omitempty"` //门关继电器
}
func (x *AsdState) Reset() {
@ -235,43 +217,22 @@ func (x *AsdState) GetMgj() bool {
return false
}
func (x *AsdState) GetZaw() bool {
if x != nil {
return x.Zaw
}
return false
}
func (x *AsdState) GetForce() bool {
if x != nil {
return x.Force
}
return false
}
var File_component_psd_proto protoreflect.FileDescriptor
var file_component_psd_proto_rawDesc = []byte{
0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f, 0x70, 0x73, 0x64, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x09, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74,
0x22, 0x68, 0x0a, 0x08, 0x50, 0x73, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x14, 0x0a, 0x05,
0x22, 0x20, 0x0a, 0x08, 0x50, 0x73, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x14, 0x0a, 0x05,
0x63, 0x6c, 0x6f, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x63, 0x6c, 0x6f,
0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x6f, 0x62, 0x73, 0x74, 0x61, 0x63, 0x6c, 0x65, 0x18, 0x02,
0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x6f, 0x62, 0x73, 0x74, 0x61, 0x63, 0x6c, 0x65, 0x12, 0x2a,
0x0a, 0x10, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x6c, 0x65, 0x61,
0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6c,
0x6f, 0x63, 0x6b, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x22, 0x44, 0x0a, 0x03, 0x50, 0x73,
0x64, 0x22, 0x3d, 0x0a, 0x05, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x12, 0x0d, 0x0a, 0x09, 0x55, 0x6e,
0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x41, 0x73, 0x64,
0x43, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x10, 0x01, 0x12, 0x11, 0x0a,
0x0d, 0x41, 0x73, 0x64, 0x43, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x4f, 0x70, 0x65, 0x6e, 0x10, 0x02,
0x22, 0x6c, 0x0a, 0x08, 0x41, 0x73, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x12, 0x0a, 0x04,
0x67, 0x6d, 0x64, 0x77, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x67, 0x6d, 0x64, 0x77,
0x12, 0x12, 0x0a, 0x04, 0x6b, 0x6d, 0x64, 0x77, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04,
0x6b, 0x6d, 0x64, 0x77, 0x12, 0x10, 0x0a, 0x03, 0x6d, 0x67, 0x6a, 0x18, 0x03, 0x20, 0x01, 0x28,
0x08, 0x52, 0x03, 0x6d, 0x67, 0x6a, 0x12, 0x10, 0x0a, 0x03, 0x7a, 0x61, 0x77, 0x18, 0x04, 0x20,
0x01, 0x28, 0x08, 0x52, 0x03, 0x7a, 0x61, 0x77, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63,
0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x42, 0x1d,
0x73, 0x65, 0x22, 0x44, 0x0a, 0x03, 0x50, 0x73, 0x64, 0x22, 0x3d, 0x0a, 0x05, 0x46, 0x61, 0x75,
0x6c, 0x74, 0x12, 0x0d, 0x0a, 0x09, 0x55, 0x6e, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x10,
0x00, 0x12, 0x12, 0x0a, 0x0e, 0x41, 0x73, 0x64, 0x43, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x43, 0x6c,
0x6f, 0x73, 0x65, 0x10, 0x01, 0x12, 0x11, 0x0a, 0x0d, 0x41, 0x73, 0x64, 0x43, 0x61, 0x6e, 0x6e,
0x6f, 0x74, 0x4f, 0x70, 0x65, 0x6e, 0x10, 0x02, 0x22, 0x44, 0x0a, 0x08, 0x41, 0x73, 0x64, 0x53,
0x74, 0x61, 0x74, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x67, 0x6d, 0x64, 0x77, 0x18, 0x01, 0x20, 0x01,
0x28, 0x08, 0x52, 0x04, 0x67, 0x6d, 0x64, 0x77, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x6d, 0x64, 0x77,
0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x04, 0x6b, 0x6d, 0x64, 0x77, 0x12, 0x10, 0x0a, 0x03,
0x6d, 0x67, 0x6a, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x03, 0x6d, 0x67, 0x6a, 0x42, 0x1d,
0x5a, 0x1b, 0x2e, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f, 0x63, 0x6f,
0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x06, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x33,

2
component/component_proto/signal.pb.go
View File

@ -1,6 +1,6 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.33.0
// protoc-gen-go v1.31.0
// protoc v4.23.1
// source: component/signal.proto

2
component/component_proto/turnout.pb.go
View File

@ -1,6 +1,6 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.28.1
// protoc-gen-go v1.31.0
// protoc v4.23.1
// source: component/turnout.proto

20
component/equipment.go
View File

@ -1,20 +0,0 @@
package component
import (
"unsafe"
"joylink.club/ecs"
"joylink.club/rtsssimulation/component/component_data"
)
var (
RelayFaultForceType = ecs.NewComponentType[component_data.RelayFaultForce]()
)
func AddOrUpdateRelayFaultForce(entry *ecs.Entry, q bool) {
if entry.HasComponent(RelayFaultForceType) {
entry.SetComponent(RelayFaultForceType, unsafe.Pointer(&component_data.RelayFaultForce{Q: q}))
} else {
entry.AddComponent(RelayFaultForceType, unsafe.Pointer(&component_data.RelayFaultForce{Q: q}))
}
}

1
component/ibp.go
View File

@ -45,7 +45,6 @@ var AlarmDriveType = ecs.NewComponentType[AlarmDrive]()
// 挡位组件
type GearState struct {
//Bypass
Val int32
}

5
component/iscs_bas_air_conditioner.go
View File

@ -5,8 +5,13 @@ import "joylink.club/ecs"
// AirConditioning 空调
type AirConditioning struct {
Running bool //true-运行正常；false-停止
}
var (
AirConditioningType = ecs.NewComponentType[AirConditioning]() //空调
CombinationAirConditionerTag = ecs.NewTag() //组合式空调
AirConditioningGroupTag = ecs.NewTag() //空调群控系统
AirConditionerTag = ecs.NewTag() //空调器
)

4
component/iscs_bas_air_pavilion.go
View File

@ -8,5 +8,7 @@ type AirPavilion struct {
}
var (
AirPavilionType = ecs.NewComponentType[AirPavilion]() //风亭
AirPavilionType = ecs.NewComponentType[AirPavilion]() //风亭
ExhaustPavilionTag = ecs.NewTag() //排风亭
AirSupplyPavilionTag = ecs.NewTag() //送风亭
)

20
component/iscs_bas_fan.go
View File

@ -2,18 +2,38 @@ package component
import "joylink.club/ecs"
// FanDevice 风机设备
// 正转即顺时针转-排风；反转即逆时针转-进风
type FanDevice struct {
Speed uint16 //风机转速，r/min
Forward bool //true-正转；false-反转
}
// FanFcUnit 风机变频器
type FanFcUnit struct {
Fc bool //true-变频器已开启
}
// FanBypassUnit 风机旁路装置
type FanBypassUnit struct {
Bypass bool //true-风机旁路已开启
}
// FanSoftStartUnit 风机软启装置
type FanSoftStartUnit struct {
SoftStart bool //true-风机软启已开启
}
// FanHighLowSpeedMode 风机双速模式控制
type FanHighLowSpeedMode struct {
HighMode bool //true-风机高速模式；false-风机低速模式
}
var (
FanDeviceType = ecs.NewComponentType[FanDevice]() //风机设备
FanFcUnitType = ecs.NewComponentType[FanFcUnit]() //风机变频装置
FanBypassUnitType = ecs.NewComponentType[FanBypassUnit]() //风机旁路装置
FanSoftStartUnitType = ecs.NewComponentType[FanSoftStartUnit]() //风机软启装置
FanHighLowSpeedModeType = ecs.NewComponentType[FanHighLowSpeedMode]() //风机双速模式控制
CommonFanTag = ecs.NewTag() //一般风机

0
component/iscs_bas_environment.go → component/iscs_bas_gas_environment.go
View File

11
component/iscs_bas_gas_mixing_chamber.go Normal file
View File

@ -0,0 +1,11 @@
package component
import "joylink.club/ecs"
// GasMixingChamber 混合室静压箱
type GasMixingChamber struct {
}
var (
GasMixingChamberType = ecs.NewComponentType[GasMixingChamber]()
)

134
component/iscs_bas_pipe.go
View File

@ -1,134 +0,0 @@
package component
import "joylink.club/ecs"
///////////////////////////////////////////
//组合空调柜AHU-A01 二通阀MOV-A01
//回排风机RAF-A01 风阀MDD-A03
//排烟风机SEF-A01 风阀MDD-A04
//排风阀MDA-A02
//回风阀MDA-A03
//小新风阀MDA-A01
//空调柜MDD-A02
//防烟防火SFD-A01
// PipeMatter 管线中传输的物质类型
type PipeMatter uint8
const (
PmtNon PipeMatter = iota //未知或没有
PmtWater
PmtElectricity //电
PmtAir //正常空气
PmtSmoke //含有有害烟的空气(如火灾时的烟气)
PmtOil //油
)
func (m *PipeMatter) IsNon() bool {
return *m == PmtNon
}
func (m *PipeMatter) IsEle() bool {
return *m == PmtElectricity
}
// PipeDirection 管线中物质传输方向定义
type PipeDirection uint8
const (
PdNon PipeDirection = iota //无方向
PdAb //方向A=>B
PdBa //方向B=>A
)
func (d *PipeDirection) IsAb() bool {
return *d == PdAb
}
func (d *PipeDirection) IsBa() bool {
return *d == PdBa
}
func (d *PipeDirection) IsNon() bool {
return *d == PdNon
}
// Pipe 管线一般状态定义
type Pipe struct {
Matter PipeMatter //管线中物质类型
Direction PipeDirection //管线中物质运动方向
}
// PipeElectricity 电线(三相交流，一般单相交流，直流)
// 如果是三相电，则简化认为每相电压电流一样
type PipeElectricity struct {
U uint32 //电压
I uint32 //电流
Sx bool //true-三相交流电，此时Ac无效；false-一般单相电，此时Ua Ia Ac有效
Ac bool //true-交流；false-直流
Sources map[string]*ElectricitySource //key-电源实体id,value-电源投影
}
func NewPipeElectricity() *PipeElectricity {
return &PipeElectricity{Sources: make(map[string]*ElectricitySource)}
}
func (p *PipeElectricity) FromElectricitySource(es *ElectricitySource) {
p.U = es.U
p.Sx = es.Sx
p.Ac = es.Ac
}
func (p *PipeElectricity) TransPower(powerSourceId string, power *ElectricitySource) {
ep, ok := p.Sources[powerSourceId]
if ok {
*ep = *power
ep.Fresh -= 1
} else {
p.Sources[powerSourceId] = &ElectricitySource{}
*p.Sources[powerSourceId] = *power
p.Sources[powerSourceId].Fresh -= 1
}
}
// ElectricitySource 电源(三相交流，一般单相交流，直流)
type ElectricitySource struct {
Fresh int64 //该电力值更新的时间戳
U uint32 //电压
I uint32 //电流
Sx bool //true-三相交流电，此时Ac无效；false-一般单相电，此时Ua Ia Ac有效
Ac bool //true-交流；false-直流
}
func NewElectricitySource() *ElectricitySource {
return &ElectricitySource{}
}
// SetOut0 设置0输出
func (s *ElectricitySource) SetOut0() {
s.U = 0
s.I = 0
}
// PipeFluid 流体(液体气体)管线
type PipeFluid struct {
T float32 //温度
}
func NewPipeFluid() *PipeFluid {
return &PipeFluid{}
}
var (
PipeType = ecs.NewComponentType[Pipe]() //电线
PipeElectricityType = ecs.NewComponentType[PipeElectricity]() //电线电力
PipeFluidType = ecs.NewComponentType[PipeFluid]() //管线流体
ElectricitySourceType = ecs.NewComponentType[ElectricitySource]() //电源
)
/////////////////////////////////////////////////////////////////////////
// FluidDriver 流体驱动器
type FluidDriver struct {
On bool //true-输出流体驱动力；false-未输出流体驱动力
}
var (
FluidDriverType = ecs.NewComponentType[FluidDriver]() //流体驱动器
)

16
component/iscs_bas_plenum_chamber.go
View File

@ -1,16 +0,0 @@
package component
import "joylink.club/ecs"
// GasMixingChamber 混合室静压箱
//
// 送风系统中的配件
// 显然静压箱起到了增加静压的作用。静压箱的设计原则：静压箱的作用是为各分支管路提供均匀的压力，
// 从理论上说静压箱内部静压处处相等（这时静压箱容积要做得非常大，就是说静压箱内部流速处处为零）在实际工程中这是不可能的，
// 一般箱内风速可控制在2m/s以下，或相对于进出风管风速有大大下降即可。
type GasMixingChamber struct {
}
var (
GasMixingChamberType = ecs.NewComponentType[GasMixingChamber]()
)

12
component/iscs_bas_valve.go
View File

@ -11,15 +11,11 @@ type Valve struct {
Moving bool //true-正在动作
OpenRate uint8 //开度，0-100%
}
type ValveController struct {
TargetOpenRate uint8 //目标开度，0-100%
}
var (
ValveType = ecs.NewComponentType[Valve]() //阀门(开关)
ValveControllerType = ecs.NewComponentType[ValveController]()
ElectricControlValveTag = ecs.NewTag() //电动调节阀
ElectricAirValveTag = ecs.NewTag() //电动风阀
CombinationAirValveTag = ecs.NewTag() //组合式风阀
ElectricButterflyValveTag = ecs.NewTag() //电动蝶阀
ElectricControlValveTag = ecs.NewTag() //电动调节阀
ElectricAirValveTag = ecs.NewTag() //电动风阀标签
CombinationAirValveTag = ecs.NewTag() //组合式风阀
ElectricButterflyValveTag = ecs.NewTag() //电动蝶阀
)

34
component/iscs_pscada.go
View File

@ -102,6 +102,32 @@ type EarthingDevice struct {
////////////////////////////////////////////////////////////
// PowerPipe 电力母线
type PowerPipe struct {
Voltage uint32 //母线当前电压
Ac bool //true-交流电；false-直流电
Sources map[string]*ElePower //key-电源PowerSource实体id
}
func (p *PowerPipe) TransPower(powerSourceId string, power *ElePower) {
ep, ok := p.Sources[powerSourceId]
if ok {
*ep = *power
ep.Fresh -= 1
} else {
p.Sources[powerSourceId] = &ElePower{}
*p.Sources[powerSourceId] = *power
p.Sources[powerSourceId].Fresh -= 1
}
}
// ElePower 传输中的电力
type ElePower struct {
Fresh int64 //该电力值更新的时间戳
Voltage uint32 //电压
Ac bool //true-交流电；false-直流电
}
// PscadaVoltageLevel 电力母线当前电压等级定义
type PscadaVoltageLevel uint8
@ -113,6 +139,12 @@ const (
PscadaVoltageDc1500V //1500V直流
)
// PowerSource 电源(国家电网)
type PowerSource struct {
Voltage uint32 //电压
Ac bool //true-交流电；false-直流电
}
//////////////////////////////////////////////////////////////////////////////////
var (
@ -124,6 +156,8 @@ var (
LightningArresterType = ecs.NewComponentType[LightningArrester]() //避雷器
RectifierType = ecs.NewComponentType[Rectifier]() //整流器
VoltageTransformerType = ecs.NewComponentType[VoltageTransformer]() //变压器
PowerPipeType = ecs.NewComponentType[PowerPipe]() //电力母线
PowerSourceType = ecs.NewComponentType[PowerSource]() //电源
EarthingDeviceType = ecs.NewComponentType[EarthingDevice]() //接地装置
)

51
component/motor.go
View File

@ -1,51 +0,0 @@
package component
import "joylink.club/ecs"
// Motor 电机、马达
type Motor struct {
Speed float32 //电机转速，r/min
Forward bool //true-正转；false-反转
Ms MotorSwitch //电机开关
}
func (m *Motor) RunningForward() bool {
return m.Forward && m.Speed > 0
}
func (m *Motor) RunningReverse() bool {
return !m.Forward && m.Speed > 0
}
// MotorFc 电机变频器
// 电机转速与变频器频率关系 计算公式：n=60f/p（其中n是同步转速，f是频率，P是磁极对数）
// 变频器的额定输出频率一般为0-100HZ
type MotorFc struct {
F uint16 //变频器频率(0-100HZ)
}
// MotorSwitch 电机电源开关定义
type MotorSwitch uint8
const (
MsOff MotorSwitch = iota //关闭
MsOnForward //正转
MsOnReverse //反转
)
func (f *MotorSwitch) Off() bool {
return *f == MsOff
}
func (f *MotorSwitch) OnForward() bool {
return *f == MsOnForward
}
func (f *MotorSwitch) OnReverse() bool {
return *f == MsOnReverse
}
func (f *MotorSwitch) On() bool {
return *f == MsOnReverse || *f == MsOnForward
}
var (
MotorType = ecs.NewComponentType[Motor]() //电机马达
MotorFcType = ecs.NewComponentType[MotorFc]() //电机变频器
)

112
component/physical_section.go
View File

@ -1,27 +1,105 @@
package component
import "joylink.club/ecs"
import (
"fmt"
"joylink.club/ecs"
)
//计轴设备，管理联锁集中站内的所有计轴区段
//计轴直接复位：计轴的轮对计数清零，区段转换为空闲状态
//计轴预复位：将计轴的轮对计数清零，但是区段不会立即变成空闲区段，而是处于一种“占用”状态，在压道车通过之后确认区段空闲且计轴正常后，区段转换为空闲状态
//
//当CI系统给计轴设备发送计轴直接复零/预复零命令时，连续发送一定时间（具体发送时间调试后确定）的复零/预复零命令。
//当RAC，RJO，RJT任意一个不为0时，终止发送复零/预复零命令。
// PhysicalSectionState 物理区段
type PhysicalSectionState struct {
//true-占用，false-出清
Occ bool
}
// AxlePhysicalSection 计轴物理区段
type AxlePhysicalSection struct {
//计轴区段内车轴数
Count int
//记录Count变化波形
countPulse uint8
}
type AxleDeviceRuntime struct {
//true-计轴复位反馈,表示计轴设备已收到CI系统发送的直接复零/预复零命令。
Rac bool
//true-运营原因拒绝计轴复位,如区段空闲时下发复位命令；或车轮压住传感器时收到复位命令。
Rjo bool
//true-技术原因拒绝计轴复位,主要指计轴相关设备故障时收到复位命令，如车轮传感器的导线断开、AEB之间的通信故障等
Rjt bool
//true-计轴直接复位
//计轴的轮对计数清零，区段转换为空闲状态
Drst bool
//true-计轴预复位
//将计轴的轮对计数清零，但是区段不会立即变成空闲区段，而是处于一种“占用”状态，在压道车通过之后确认区段空闲且计轴正常后，区段转换为空闲状态
Pdrst bool
//true-计轴系统正在执行直接预复位操作
DoingPdrst bool
}
func NewAxleDeviceRuntime() *AxleDeviceRuntime {
return &AxleDeviceRuntime{}
}
// AxleManageDevice 计轴管理设备
type AxleManageDevice struct {
CentralizedStation string //所属集中站
Adrs map[string]*AxleDeviceRuntime //key-sectionId
}
func (d *AxleManageDevice) FindAdr(sectionId string) *AxleDeviceRuntime {
return d.Adrs[sectionId]
}
func NewAxleManageDevice(centralizedStation string) *AxleManageDevice {
return &AxleManageDevice{CentralizedStation: centralizedStation, Adrs: make(map[string]*AxleDeviceRuntime)}
}
var (
PhysicalSectionTag = ecs.NewTag()
PhysicalSectionCircuitType = ecs.NewComponentType[PhysicalSectionCircuit]()
PhysicalSectionManagerType = ecs.NewComponentType[PhysicalSectionManager]()
PhysicalSectionStateType = ecs.NewComponentType[PhysicalSectionState]()
AxlePhysicalSectionType = ecs.NewComponentType[AxlePhysicalSection]()
AxleSectionFaultTag = ecs.NewTag()
AxleManageDeviceType = ecs.NewComponentType[AxleManageDevice]()
)
var PhysicalSectionForceOccupied = ecs.NewTag() //区段强制占用（故障占用）
// PhysicalSectionManager 计轴管理器。我自己起的名字，计轴逻辑的载体
type PhysicalSectionManager struct {
Count int //轴数（简化版）。目前此轴数计数只与区段上有无列车有关，故障占用等状态不会影响此计数
Occupied bool //占用
/////////////////////////////AxlePhysicalSection/////////////////////////////////
PDRST bool //预复位
//RAC bool //计轴复位反馈。主要指计轴设备发送给CI系统的直接复零/预复零命令反馈，表示计轴设备已收到CI系统发送的直接复零/预复零命令。
//RJO bool //运营原因拒绝直接复位/预复位。如区段空闲时下发复位命令；或车轮压住传感器时收到复位命令。
//RJT bool //技术原因拒绝直接复位/预复位。主要指计轴相关设备故障时收到复位命令，如车轮传感器的导线断开、AEB之间的通信故障等。
func NewAxlePhysicalSection() *AxlePhysicalSection {
return &AxlePhysicalSection{Count: 0, countPulse: 0}
}
func (c *AxlePhysicalSection) UpdateCount(count int) {
cp := to1(c.Count)
np := to1(count)
//
if cp != np {
c.countPulse <<= 1
if np > 0 {
c.countPulse |= np
}
}
c.Count = count
}
func (c *AxlePhysicalSection) ResetCountPulse() {
c.countPulse = 0x00
}
func (c *AxlePhysicalSection) ShowCountWave() string {
return fmt.Sprintf("%08b", c.countPulse)
}
// PhysicalSectionCircuit 计轴区段电路
type PhysicalSectionCircuit struct {
GJ *ecs.Entry
// IsCount010Pulse true-车进入计轴区段后出清计轴区段
func (c *AxlePhysicalSection) IsCount010Pulse() bool {
return c.countPulse&0x01 == 0 && c.countPulse&0x02 > 0 && c.countPulse&0x04 == 0
}
// 归1
func to1(c int) uint8 {
if c > 0 {
return 0x01
} else {
return 0x00
}
}

22
component/points.go
View File

@ -1,22 +0,0 @@
package component
import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/component/component_data"
"joylink.club/rtsssimulation/component/relation"
)
var (
// 道岔标签
PointsTag = ecs.NewTag()
// 道岔模型数据引用组件类型
PointsModelRelaType = relation.PointsModelRelaType
// 道岔转辙机关系组件类型
PointsZzjRelaType = relation.PointsZzjRelaType
// 道岔ZDJ9双机电路元器件组件类型
Zdj9TwoElectronicType = relation.Zdj9TwoElectronicType
// 道岔转辙机自动开闭器状态组件类型
PointsZzjKbqStateType = ecs.NewComponentType[component_data.PointsZzjKbqState]()
// 道岔位置组件类型
PointsPositionType = ecs.NewComponentType[component_data.PointsPosition]()
)

36
component/psd.go
View File

@ -65,12 +65,6 @@ type AsdMotorState struct {
var AsdStateType = ecs.NewComponentType[component_proto.AsdState]()
// AsdForceType ture强制开门 false强制关门
var AsdForceType = ecs.NewComponentType[BitState]()
// AsdHasObstacleTag 滑动门有障碍物
var AsdHasObstacleTag = ecs.NewTag()
var PlatformMkxCircuitType = ecs.NewComponentType[PlatformMkxCircuit]()
// PlatformMkxCircuit 站台门控箱电路
@ -79,25 +73,15 @@ type PlatformMkxCircuit struct {
PCBJ *ecs.Entry
POBJ *ecs.Entry
PABJ *ecs.Entry
WRZFJ *ecs.Entry
QKQRJ *ecs.Entry
}
var MkxType = ecs.NewComponentType[Mkx]()
type Mkx struct {
PCB *ecs.Entry
PCBPL *ecs.Entry
POB *ecs.Entry
POBPL *ecs.Entry
PAB *ecs.Entry
PABPL *ecs.Entry
WRZF *ecs.Entry
WRZFPL *ecs.Entry
QKQR *ecs.Entry
QKQRPL *ecs.Entry
MPL *ecs.Entry
JXTCPL *ecs.Entry
PCB *ecs.Entry
POB *ecs.Entry
PAB *ecs.Entry
MPL *ecs.Entry
}
var PscType = ecs.NewComponentType[Psc]()
@ -107,8 +91,14 @@ type Psc struct {
//InterlockKM8 bool
InterlockKmGroup map[int32]bool //开门编组。k-编组 v-设置开门
InterlockGM bool
InterlockMPL bool
//MkxKM bool 门控箱控制继电器->联锁采集继电器状态->联锁驱动屏蔽门控制继电器
//MkxGM bool
//MkxPL bool
MkxKM bool
MkxGM bool
MkxPL bool
QDTC bool
TZTC bool
ZAW bool
JXTCPL bool
}

166
component/relation/points.go
View File

@ -1,166 +0,0 @@
package relation
import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/modelrepo/model"
)
var (
// 道岔模型数据引用组件类型
PointsModelRelaType = ecs.NewComponentType[PointsModelRela]()
// 道岔转辙机关系组件类型
PointsZzjRelaType = ecs.NewComponentType[PointsZzjRela]()
// ZDJ9双机电路元器件组件类型
Zdj9TwoElectronicType = ecs.NewComponentType[Zdj9TwoElectronic]()
)
// 道岔模型数据引用
type PointsModelRela struct {
M model.Points
}
func NewPointsModelRela(m model.Points) *PointsModelRela {
return &PointsModelRela{
M: m,
}
}
// 道岔转辙机关系组件
type PointsZzjRela struct {
Points *ecs.Entry
Zzjs []*ecs.Entry
}
func NewPointsZzjRela(t *ecs.Entry, zzjs ...*ecs.Entry) *PointsZzjRela {
return &PointsZzjRela{
Points: t,
Zzjs: zzjs,
}
}
// 获取转辙机一,若没有则panic
func (tz *PointsZzjRela) GetZzj1() *ecs.Entry {
len := len(tz.Zzjs)
if len > 0 {
return tz.Zzjs[0]
}
panic("道岔没有转辙机一")
}
// 获取转辙机二,若没有则panic
func (tz *PointsZzjRela) GetZzj2() *ecs.Entry {
len := len(tz.Zzjs)
if len > 1 {
return tz.Zzjs[1]
}
panic("道岔没有转辙机二")
}
// ZDJ9双机电路元器件
type Zdj9TwoElectronic struct {
TDC_DCJ *ecs.Entry // 定操继电器
TDC_FCJ *ecs.Entry // 反操继电器
TDC_YCJ *ecs.Entry // 允许操作继电器
TDC_ZDBJ *ecs.Entry // 总定表继电器
TDC_ZFBJ *ecs.Entry // 总反表继电器
// 一机
TDFJ1_1DQJ *ecs.Entry // 一启动继电器
TDFJ1_BHJ *ecs.Entry // 保护继电器
TDFJ1_2DQJ *ecs.Entry // 二启动继电器
TDFJ1_1DQJF *ecs.Entry // 一启动复示继电器
TDFJ1_DBQ *ecs.Entry // 断相保护器
TDFJ1_DBJ *ecs.Entry // 定位表示继电器
TDFJ1_FBJ *ecs.Entry // 反位表示继电器
TDFJ1_QDJ *ecs.Entry // 切断继电器
TDFJ1_ZBHJ *ecs.Entry // 总保护继电器
TDFJ1_QDJ_Remain int // 切断继电器保持电路保持剩余时间
// 二机
TDFJ2_1DQJ *ecs.Entry // 一启动继电器
TDFJ2_BHJ *ecs.Entry // 保护继电器
TDFJ2_2DQJ *ecs.Entry // 二启动继电器
TDFJ2_1DQJF *ecs.Entry // 一启动复示继电器
TDFJ2_DBQ *ecs.Entry // 断相保护器
TDFJ2_DBJ *ecs.Entry // 定位表示继电器
TDFJ2_FBJ *ecs.Entry // 反位表示继电器
}
// 检查空引用，返回空引用字段名称
func (te *Zdj9TwoElectronic) CheckNilReference() []string {
var nils []string = make([]string, 0)
if te.TDC_DCJ == nil {
nils = append(nils, "TDC_DCJ")
}
if te.TDC_FCJ == nil {
nils = append(nils, "TDC_FCJ")
}
if te.TDC_YCJ == nil {
nils = append(nils, "TDC_YCJ")
}
if te.TDC_ZDBJ == nil {
nils = append(nils, "TDC_ZDBJ")
}
if te.TDC_ZFBJ == nil {
nils = append(nils, "TDC_ZFBJ")
}
// 一机
if te.TDFJ1_1DQJ == nil {
nils = append(nils, "TDFJ1_1DQJ")
}
if te.TDFJ1_BHJ == nil {
nils = append(nils, "TDFJ1_BHJ")
}
if te.TDFJ1_2DQJ == nil {
nils = append(nils, "TDFJ1_2DQJ")
}
if te.TDFJ1_1DQJF == nil {
nils = append(nils, "TDFJ1_1DQJF")
}
if te.TDFJ1_DBQ == nil {
nils = append(nils, "TDFJ1_DBQ")
}
if te.TDFJ1_DBJ == nil {
nils = append(nils, "TDFJ1_DBJ")
}
if te.TDFJ1_FBJ == nil {
nils = append(nils, "TDFJ1_FBJ")
}
if te.TDFJ1_QDJ == nil {
nils = append(nils, "TDFJ1_QDJ")
}
if te.TDFJ1_ZBHJ == nil {
nils = append(nils, "TDFJ1_ZBHJ")
}
// 二机
if te.TDFJ2_1DQJ == nil {
nils = append(nils, "TDFJ2_1DQJ")
}
if te.TDFJ2_BHJ == nil {
nils = append(nils, "TDFJ2_BHJ")
}
if te.TDFJ2_2DQJ == nil {
nils = append(nils, "TDFJ2_2DQJ")
}
if te.TDFJ2_1DQJF == nil {
nils = append(nils, "TDFJ2_1DQJF")
}
if te.TDFJ2_DBQ == nil {
nils = append(nils, "TDFJ2_DBQ")
}
if te.TDFJ2_DBJ == nil {
nils = append(nils, "TDFJ2_DBJ")
}
if te.TDFJ2_FBJ == nil {
nils = append(nils, "TDFJ2_FBJ")
}
return nils
}
// 是否有空引用
func (te *Zdj9TwoElectronic) HasNilReference() bool {
nils := te.CheckNilReference()
return len(nils) > 0
}

35
component/singleton/entity_uid_index.go
View File

@ -1,35 +0,0 @@
package singleton
import (
"sync"
"joylink.club/ecs"
)
var EntityUidIndexType = ecs.NewComponentType[EntityUidIndex]()
// 对象实体Uid索引
// 只索引具有uid且不会销毁的实体
type EntityUidIndex struct {
mu sync.RWMutex
entityMap map[string]ecs.Entity
}
func (idx *EntityUidIndex) Add(uid string, entity ecs.Entity) {
idx.mu.Lock()
defer idx.mu.Unlock()
idx.entityMap[uid] = entity
}
func (idx *EntityUidIndex) Get(uid string) ecs.Entity {
idx.mu.RLock()
defer idx.mu.RUnlock()
return idx.entityMap[uid]
}
func loadUidEntityIndex(w ecs.World) {
entry := w.Entry(w.Create(EntityUidIndexType))
EntityUidIndexType.Set(entry, &EntityUidIndex{
entityMap: make(map[string]ecs.Entity, 512),
})
}

45
component/singleton/load.go
View File

@ -1,45 +0,0 @@
package singleton
import (
"joylink.club/ecs"
"joylink.club/ecs/filter"
"joylink.club/rtsssimulation/modelrepo"
)
// 加载并初始化单例组件
func LoadSingletons(w ecs.World, r modelrepo.Repo) {
loadWorldRepo(w, r)
LoadWorldTime(w)
loadUidEntityIndex(w)
}
type Singleton struct {
}
var worldRepoQuery = ecs.NewQuery(filter.Contains(WorldRepoType))
var worldTimeQuery = ecs.NewQuery(filter.Contains(WorldTimeType))
var uidEntityIndexQuery = ecs.NewQuery(filter.Contains(EntityUidIndexType))
func GetWorldTime(w ecs.World) *WorldTime {
entry, _ := worldTimeQuery.First(w)
if entry == nil {
panic("不存在世界时间组件")
}
return WorldTimeType.Get(entry)
}
func GetWorldRepo(w ecs.World) *WorldRepo {
entry, _ := worldRepoQuery.First(w)
if entry == nil {
panic("不存在世界数据组件")
}
return WorldRepoType.Get(entry)
}
func GetEntityUidIndex(w ecs.World) *EntityUidIndex {
entry, _ := uidEntityIndexQuery.First(w)
if entry == nil {
panic("不存在UidEntityIndex组件")
}
return EntityUidIndexType.Get(entry)
}

19
component/singleton/repo.go
View File

@ -1,19 +0,0 @@
package singleton
import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/modelrepo"
)
var WorldRepoType = ecs.NewComponentType[WorldRepo]()
type WorldRepo struct {
r modelrepo.Repo
}
func loadWorldRepo(w ecs.World, r modelrepo.Repo) {
entry := w.Entry(w.Create(WorldRepoType))
WorldRepoType.Set(entry, &WorldRepo{
r: r,
})
}

37
component/singleton/world_time.go
View File

@ -1,37 +0,0 @@
package singleton
import (
"time"
"joylink.club/ecs"
)
var WorldTimeType = ecs.NewComponentType[WorldTime]()
type WorldTime struct {
time int64
}
func (w *WorldTime) SetTime(t time.Time) {
w.time = t.UnixMilli()
}
// 增加时间
func (w *WorldTime) Run(ms int) {
w.time += int64(ms)
}
// 获取时间
func (w *WorldTime) GetTime() time.Time {
return time.UnixMilli(w.time)
}
// 获取时间戳ms
func (w *WorldTime) GetMilli() int64 {
return w.time
}
func LoadWorldTime(w ecs.World) {
entry := w.Entry(w.Create(WorldTimeType))
WorldTimeType.Set(entry, &WorldTime{time: time.Now().UnixMilli()})
}

11
component/track_circuit.go
View File

@ -1,11 +0,0 @@
package component
import "joylink.club/ecs"
var (
TrackCircuitType = ecs.NewComponentType[TrackCircuit]()
)
type TrackCircuit struct {
GJ *ecs.Entry
}

10
component/train.go
View File

@ -12,7 +12,6 @@ type TrainPositionInfo struct {
Up bool
//列车长度 mm
Len int64
//列车所在轨道link
HeadLink string
//列车所在link偏移量（mm）
@ -21,15 +20,6 @@ type TrainPositionInfo struct {
TailLink string
//列车所在link偏移量（mm）
TailLinkOffset int64
//车头所在物理区段
HeadSectionId string
//车头所在物理区段偏移量
HeadSectionOffset uint32
//车尾所在物理区段
TailSectionId string
//车尾所在物理区段偏移量
TailSectionOffset uint32
}
func (t *TrainPositionInfo) ToString() string {

12
component/turnout.go
View File

@ -208,12 +208,12 @@ func (te *Zdj9TwoElectronic) HasNilReference() bool {
// }
var (
// ZDJ9双机电路元器件组件类型
// Zdj9TwoElectronicType = ecs.NewComponentType[Zdj9TwoElectronic]()
// // ZDJ9双机驱动状态组件类型
// Zdj9TwoDriveType = ecs.NewComponentType[Zdj9TwoDrive]()
// // ZDJ9双机采集状态组件类型
// Zdj9TwoCollectType = ecs.NewComponentType[Zdj9TwoCollect]()
// ZDJ9双机电路元器件组件类型
Zdj9TwoElectronicType = ecs.NewComponentType[Zdj9TwoElectronic]()
// // ZDJ9双机驱动状态组件类型
// Zdj9TwoDriveType = ecs.NewComponentType[Zdj9TwoDrive]()
// // ZDJ9双机采集状态组件类型
// Zdj9TwoCollectType = ecs.NewComponentType[Zdj9TwoCollect]()
)
// 转辙机状态

23
component/xcj.go
View File

@ -1,23 +0,0 @@
package component
import (
"joylink.club/ecs"
)
var (
XcjTag = ecs.NewTag()
XcjFaultTag = ecs.NewTag()
XcjCircuitType = ecs.NewComponentType[XcjCircuit]()
)
type XcjCircuit struct {
//联锁驱动的继电器
XQJ *ecs.Entry //洗车请求
TWJList []*ecs.Entry //停稳继电器
TGQJ *ecs.Entry //通过请求
XCJXJ *ecs.Entry //洗车就绪
XCYXJ *ecs.Entry //洗车允许
CFJList []*ecs.Entry //移动允许继电器
JTJ *ecs.Entry //紧急停车
TGYXJ *ecs.Entry //通过允许
}

6
consts/bit.go
View File

@ -12,7 +12,7 @@ func GetBitOfBytes(bs []byte, bitIndex int) bool {
panic(fmt.Errorf("从字节数组获取位值错误,位索引超出字节数组范围: 数组len=%d,位索引=%d", len(bs), bitIndex))
}
by := bs[bi]
v := byte(1 << i)
v := byte(1 << (7 - i))
return (by & v) == v
}
@ -28,9 +28,9 @@ func SetBitOfBytes(bs []byte, bitIndex int, v bool) []byte {
}
by := bs[bi]
if v {
by |= (1 << i)
by |= (1 << (7 - i))
} else {
by &= ((1 << i) ^ byte(0xff))
by &= ((1 << (7 - i)) ^ byte(0xff))
}
bs[bi] = by
return bs

20
entity/axle_counting_section.go
View File

@ -1,20 +0,0 @@
package entity
import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
)
var AxleCountingSectionBaseComponentTypes = []ecs.IComponentType{component.UidType, component.AxleCountingSectionStateType}
// LoadPhysicalSections 加载计轴区段
func LoadAxleCountingSections(w ecs.World) error {
wd := GetWorldData(w)
sections := wd.Repo.AxleCountingSectionList()
for _, section := range sections {
entry := w.Entry(w.Create(AxleCountingSectionBaseComponentTypes...))
component.UidType.SetValue(entry, component.Uid{Id: section.Id()})
wd.EntityMap[section.Id()] = entry
}
return nil
}

22
entity/balise.go
View File

@ -3,14 +3,10 @@ package entity
import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/component/component_data"
"joylink.club/rtsssimulation/repository"
"joylink.club/rtsssimulation/repository/model/proto"
)
var BaliseBaseComponentTypeArr = []ecs.IComponentType{component.UidType, component.BaliseFixedTelegramType,
component.LinkPositionType, component.KmType, component.BaliseWorkStateType}
// LoadBalises 加载应答器实体
func LoadBalises(w ecs.World) error {
data := GetWorldData(w)
@ -32,27 +28,13 @@ func LoadBalises(w ecs.World) error {
}
return nil
}
func newBaliseEntity(w ecs.World, td *repository.Transponder, worldData *component.WorldData) *ecs.Entry {
uid := td.Id()
entry, ok := worldData.EntityMap[uid]
if !ok {
entry = w.Entry(w.Create(BaliseBaseComponentTypeArr...))
entry = w.Entry(w.Create(component.UidType, component.BaliseStateType))
component.UidType.SetValue(entry, component.Uid{Id: uid})
component.BaliseWorkStateType.SetValue(entry, component.BaliseWorkState{Work: true})
component.BaliseFixedTelegramType.Set(entry, &component.BaliseTelegram{
Telegram: td.FixedTelegram(),
UserTelegram: td.FixedUserTelegram(),
})
if proto.Transponder_IB == td.BaliseType() || proto.Transponder_VB == td.BaliseType() {
entry.AddComponent(component.BaliseVariableTelegramType)
}
linkPosition := td.LinkPosition()
component.LinkPositionType.SetValue(entry, component_data.LinkPosition{
LinkId: linkPosition.Link().Id(),
Offset: linkPosition.Offset(),
})
component.KmType.Set(entry, td.Km())
component.BaliseStateType.Set(entry, &component.BaliseState{})
worldData.EntityMap[uid] = entry
}
return entry

24
entity/ci_ls.go
View File

@ -108,27 +108,3 @@ func NewDYPEntity(w ecs.World, station *repository.Station) error {
}
return nil
}
// NewLsEntity 创建零散继电器实体
func NewLsEntity(w ecs.World, station *repository.Station) error {
data := GetWorldData(w)
repo := data.Repo
for _, ecc := range station.DeviceEcc() {
if ecc.DeviceType != proto.DeviceType_DeviceType_LS {
continue
}
for _, eg := range ecc.Egs {
if eg.Code != "LS" {
continue
}
for _, componentId := range eg.ComponentIds {
relay := repo.FindById(componentId)
if relay == nil {
return fmt.Errorf("零散继电器实体构建错误: 找不到id=%s的继电器", componentId)
}
NewRelayEntity(w, relay.(*repository.Relay), data.EntityMap)
}
}
}
return nil
}

74
entity/ckm.go
View File

@ -1,74 +0,0 @@
package entity
import (
"github.com/yohamta/donburi"
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/repository"
"unsafe"
)
var CkmBaseComponentTypes = []ecs.IComponentType{component.UidType, component.CkmTag, component.FixedPositionTransformType}
func LoadCkm(w ecs.World) error {
data := GetWorldData(w)
for _, ckm := range data.Repo.CkmList() {
ckmEntry := newCkmEntry(w, ckm, data)
addCkmCircuit(w, ckm, ckmEntry, data)
}
for _, psl := range data.Repo.CkmPslList() {
ckmEntry := data.EntityMap[psl.Ckm().Id()]
addCkmPsl(w, psl, ckmEntry, data)
}
return nil
}
// 构建基础镜像
func newCkmEntry(w ecs.World, ckm *repository.Ckm, data *component.WorldData) *donburi.Entry {
//创建基础entry
entry := w.Entry(w.Create(CkmBaseComponentTypes...))
component.UidType.SetValue(entry, component.Uid{Id: ckm.Id()})
data.EntityMap[ckm.Id()] = entry
return entry
}
// 添加车库门电路
func addCkmCircuit(w ecs.World, ckm *repository.Ckm, ckmEntry *donburi.Entry, data *component.WorldData) {
//加载电路
if len(ckm.ComponentGroups()) != 0 {
circuit := &component.CkmCircuit{}
ckmEntry.AddComponent(component.CkmCircuitType, unsafe.Pointer(circuit))
for _, group := range ckm.ComponentGroups() {
for _, ec := range group.Components() {
relay := ec.(*repository.Relay)
switch ec.Code() {
case "MKJ":
circuit.MKJ = NewRelayEntity(w, relay, data.EntityMap)
case "MGJ":
circuit.MGJ = NewRelayEntity(w, relay, data.EntityMap)
case "MGZJ":
circuit.MGZJ = NewRelayEntity(w, relay, data.EntityMap)
case "MPLJ":
circuit.MPLJ = NewRelayEntity(w, relay, data.EntityMap)
case "MMSJ":
circuit.MMSJ = NewRelayEntity(w, relay, data.EntityMap)
case "KMJ":
circuit.KMJ = NewRelayEntity(w, relay, data.EntityMap)
case "GMJ":
circuit.GMJ = NewRelayEntity(w, relay, data.EntityMap)
}
}
}
}
}
// 添加车库门PSL
func addCkmPsl(w ecs.World, psl *repository.CkmPsl, ckmEntry *ecs.Entry, data *component.WorldData) {
ckmPsl := component.CkmPsl{
KMA: NewButtonEntity(w, psl.Kma(), data.EntityMap),
GMA: NewButtonEntity(w, psl.Gma(), data.EntityMap),
MPLA: NewButtonEntity(w, psl.Mpla(), data.EntityMap),
MMSA: NewButtonEntity(w, psl.Mmsa(), data.EntityMap),
}
ckmEntry.AddComponent(component.CkmPslType, unsafe.Pointer(&ckmPsl))
}

64
entity/fadc_axle.go Normal file
View File

@ -0,0 +1,64 @@
package entity
import (
"fmt"
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/repository"
"strings"
)
func newAxleManageDevice(w ecs.World, data *component.WorldData, centralizedStation string) *ecs.Entry {
entry := w.Entry(w.Create(component.AxleManageDeviceType))
component.AxleManageDeviceType.Set(entry, component.NewAxleManageDevice(centralizedStation))
data.AxleManageDeviceEntities = append(data.AxleManageDeviceEntities, entry)
return entry
}
// LoadAxlePhysicalSections 加载计轴区段
func LoadAxlePhysicalSections(w ecs.World) error {
data := GetWorldData(w)
sections := data.Repo.PhysicalSectionList()
for _, section := range sections {
if is, se := section.IsAxleSection(); se == nil && is {
if len(strings.TrimSpace(section.CentralizedStation())) == 0 {
return fmt.Errorf("区段[%s]未设置所属集中站", section.Id())
}
amdEntry := FindAxleManageDevice(data, section.CentralizedStation())
if amdEntry == nil {
amdEntry = newAxleManageDevice(w, data, section.CentralizedStation())
}
amd := component.AxleManageDeviceType.Get(amdEntry)
//
createAxleSectionEntity(w, section, data)
//
amd.Adrs[section.Id()] = component.NewAxleDeviceRuntime()
}
}
return nil
}
func FindAxleManageDevice(data *component.WorldData, centralizedStation string) *ecs.Entry {
for _, entry := range data.AxleManageDeviceEntities {
amd := component.AxleManageDeviceType.Get(entry)
if amd != nil && amd.CentralizedStation == centralizedStation {
return entry
}
}
return nil
}
// 计轴区段实体
func createAxleSectionEntity(w ecs.World, axleSection *repository.PhysicalSection, worldData *component.WorldData) *ecs.Entry {
uid := axleSection.Id()
entry, ok := worldData.EntityMap[uid]
if !ok {
entry = w.Entry(w.Create(component.UidType, component.PhysicalSectionStateType, component.AxlePhysicalSectionType))
//
component.UidType.SetValue(entry, component.Uid{Id: uid})
component.PhysicalSectionStateType.Set(entry, &component.PhysicalSectionState{Occ: false})
component.AxlePhysicalSectionType.Set(entry, component.NewAxlePhysicalSection())
//
worldData.EntityMap[uid] = entry
}
return entry
}

9
entity/ibp.go
View File

@ -195,16 +195,13 @@ func LoadEMPEntity(w ecs.World, entry *ecs.Entry, datas []*repository.Electronic
}
}
if emp.Alarm == nil || emp.QBA == nil || emp.SDA == nil {
slog.Warn("EMP组合缺少元素，将不添加EMP电路组件")
return nil
return fmt.Errorf("EMP组合初始化出错,请检查IBP地图组合数据")
}
for code, e := range emp.EMPJMap {
if e.EMPFA_BTN == nil || e.EMPD == nil || len(e.EMP_BTNS) == 0 {
slog.Warn(fmt.Sprintf("组合[%s]还原按钮未关联,请检查IBP地图组合数据", code))
return nil
return fmt.Errorf("组合[%s]还原按钮未关联,请检查IBP地图组合数据", code)
} else if e.EMPJ == nil {
slog.Warn(fmt.Sprintf("组合[%s]继电器未关联,请检查继电器地图组合数据", code))
return nil
return fmt.Errorf("组合[%s]继电器未关联,请检查继电器地图组合数据", code)
}
}
entry.AddComponent(component.EmpElectronicType, unsafe.Pointer(emp))

30
entity/init.go
View File

@ -2,14 +2,12 @@ package entity
import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/component/singleton"
"joylink.club/rtsssimulation/repository"
)
// 仿真实体加载
func Load(w ecs.World, repo *repository.Repository) error {
// 初始化世界数据单例组件
singleton.LoadWorldTime(w)
LoadWorldData(w, repo)
// 加载联锁驱采卡相关实体
err := LoadCiQC(w)
@ -36,13 +34,8 @@ func Load(w ecs.World, repo *repository.Repository) error {
if err != nil {
return err
}
// 加载物理区段相关实体
err = LoadPhysicalSections(w)
if err != nil {
return err
}
// 加载计轴区段相关实体
err = LoadAxleCountingSections(w)
err = LoadAxlePhysicalSections(w)
if err != nil {
return err
}
@ -51,25 +44,6 @@ func Load(w ecs.World, repo *repository.Repository) error {
if err != nil {
return err
}
// 加载车库门
err = LoadCkm(w)
if err != nil {
return err
}
//加载洗车机
err = LoadXcj(w)
if err != nil {
return err
}
//加载轨道电路
err = LoadTrackCircuit(w)
if err != nil {
return err
}
//加载站台（继电器）
err = LoadPlatform(w)
if err != nil {
return err
}
//
return err
}

54
entity/iscs_bas.go
View File

@ -3,8 +3,6 @@ package entity
import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/component/component_data"
"joylink.club/rtsssimulation/consts"
"joylink.club/rtsssimulation/repository/model/proto"
)
@ -13,7 +11,7 @@ func NewWireCabinetEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.WireCabinetType, component.DeviceExceptionType))
e := w.Entry(w.Create(component.UidType, component.WireCabinetType, component.DeviceExceptionType))
component.UidType.SetValue(e, component.Uid{Id: id})
wd.EntityMap[id] = e
}
@ -25,7 +23,7 @@ func NewNetworkSwitchEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.NetworkSwitchType, component.DeviceExceptionType))
e := w.Entry(w.Create(component.UidType, component.NetworkSwitchType, component.DeviceExceptionType))
component.UidType.SetValue(e, component.Uid{Id: id})
component.NetworkSwitchType.Set(e, &component.NetworkSwitch{Normal: true})
wd.EntityMap[id] = e
@ -34,11 +32,18 @@ func NewNetworkSwitchEntity(w ecs.World, id string) *ecs.Entry {
}
// NewAirPavilionEntity 创建风亭实体
func NewAirPavilionEntity(w ecs.World, id string) *ecs.Entry {
func NewAirPavilionEntity(w ecs.World, id string, apType proto.AirPavilion_Type) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.AirPavilionType))
e := w.Entry(w.Create(component.UidType, component.AirPavilionType))
//
switch apType {
case proto.AirPavilion_ExhaustPavilion:
e.AddComponent(component.ExhaustPavilionTag)
case proto.AirPavilion_AirSupplyPavilion:
e.AddComponent(component.AirSupplyPavilionTag)
}
//
component.UidType.SetValue(e, component.Uid{Id: id})
component.AirPavilionType.Set(e, &component.AirPavilion{Normal: true})
@ -52,11 +57,9 @@ func NewValveEntity(w ecs.World, id string, valveType proto.Valve_Type) *ecs.Ent
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.ValveType, component.ValveControllerType, component.FixedPositionTransformType, component.DeviceExceptionType))
e := w.Entry(w.Create(component.UidType, component.ValveType, component.DeviceExceptionType))
component.UidType.SetValue(e, component.Uid{Id: id})
//默认全关位置
component.FixedPositionTransformType.Set(e, &component.FixedPositionTransform{FixedPositionTransform: component_data.FixedPositionTransform{Pos: consts.TwoPosMin}})
component.ValveControllerType.Set(e, &component.ValveController{TargetOpenRate: 0})
component.ValveType.Set(e, &component.Valve{OpenRate: 100, Closed: false, Opened: true, Moving: false})
//
switch valveType {
case proto.Valve_ElectricControlValve:
@ -79,31 +82,22 @@ func NewGasMixingChamberEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.GasMixingChamberType))
e := w.Entry(w.Create(component.UidType, component.GasMixingChamberType))
component.UidType.SetValue(e, component.Uid{Id: id})
wd.EntityMap[id] = e
}
return e
}
// NewCombinationAirConditionerEntity 创建组合式空调(变频)实体
// NewCombinationAirConditionerEntity 创建组合式空调实体
func NewCombinationAirConditionerEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.MotorType, component.MotorFcType, component.FluidDriverType, component.AirConditioningType, component.DeviceExceptionType))
component.UidType.SetValue(e, component.Uid{Id: id})
wd.EntityMap[id] = e
}
return e
return newAirConditioningEntity(w, id, component.CombinationAirConditionerTag)
}
// NewAirConditionerEntity 创建空调实体
func NewAirConditionerEntity(w ecs.World, id string) *ecs.Entry {
func newAirConditioningEntity(w ecs.World, id string, tag *ecs.ComponentType[struct{}]) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.MotorType, component.AirConditioningType, component.DeviceExceptionType))
e := w.Entry(w.Create(component.UidType, component.AirConditioningType, component.DeviceExceptionType, tag))
component.UidType.SetValue(e, component.Uid{Id: id})
wd.EntityMap[id] = e
}
@ -115,7 +109,7 @@ func NewPurificationDeviceEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.PurificationDeviceType, component.DeviceExceptionType))
e := w.Entry(w.Create(component.UidType, component.PurificationDeviceType, component.DeviceExceptionType))
component.UidType.SetValue(e, component.Uid{Id: id})
wd.EntityMap[id] = e
}
@ -127,7 +121,7 @@ func NewAirCurtainEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.AirCurtainType, component.DeviceExceptionType))
e := w.Entry(w.Create(component.UidType, component.AirCurtainType, component.DeviceExceptionType))
component.UidType.SetValue(e, component.Uid{Id: id})
wd.EntityMap[id] = e
}
@ -139,7 +133,7 @@ func NewGasEnvironmentEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.GasEnvironmentType))
e := w.Entry(w.Create(component.UidType, component.GasEnvironmentType))
component.UidType.SetValue(e, component.Uid{Id: id})
wd.EntityMap[id] = e
}
@ -151,9 +145,8 @@ func NewFanEntity(w ecs.World, id string, fanType proto.Fan_Type) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.MotorType, component.FluidDriverType, component.DeviceExceptionType))
e := w.Entry(w.Create(component.UidType, component.FanDeviceType, component.DeviceExceptionType))
component.UidType.SetValue(e, component.Uid{Id: id})
component.MotorType.Set(e, &component.Motor{Speed: 0, Forward: true, Ms: component.MsOff})
//
switch fanType {
case proto.Fan_CommonFan:
@ -162,12 +155,13 @@ func NewFanEntity(w ecs.World, id string, fanType proto.Fan_Type) *ecs.Entry {
}
case proto.Fan_FcBypassFan:
{
e.AddComponent(component.MotorFcType)
e.AddComponent(component.FanFcUnitType)
e.AddComponent(component.FanBypassUnitType)
e.AddComponent(component.FcBypassFanTag)
}
case proto.Fan_SoftStartFan:
{
e.AddComponent(component.FanSoftStartUnitType)
e.AddComponent(component.SoftStartFanTag)
}
case proto.Fan_HighLowSpeedFan:

35
entity/iscs_fas.go
View File

@ -103,6 +103,27 @@ func NewEvacuationTypeFireRollerShutterEntity(w ecs.World, id string) *ecs.Entry
return entry
}
// NewFirePumpEntity 创建消防泵实体
func NewFirePumpEntity(w ecs.World, id string) *ecs.Entry {
entry := NewWaterPumpEntity(w, id)
entry.AddComponent(component.FirePumpTag)
return entry
}
// NewSprayPumpEntity 创建喷淋泵实体
func NewSprayPumpEntity(w ecs.World, id string) *ecs.Entry {
entry := NewWaterPumpEntity(w, id)
entry.AddComponent(component.SprayPumpTag)
return entry
}
// NewStabilizedPressurePumpEntity 创建稳压泵实体
func NewStabilizedPressurePumpEntity(w ecs.World, id string) *ecs.Entry {
entry := NewWaterPumpEntity(w, id)
entry.AddComponent(component.StabilizedPressurePumpTag)
return entry
}
// NewFasAcsEntity 创建火警ACS联动实体
func NewFasAcsEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
@ -139,6 +160,20 @@ func NewWaterFlowIndicatorEntity(w ecs.World, id string) *ecs.Entry {
return e
}
// NewSignalButterflyValveEntity 创建信号蝶阀实体
func NewSignalButterflyValveEntity(w ecs.World, id string) *ecs.Entry {
entry := NewElectricControlValveEntity(w, id)
entry.AddComponent(component.SignalButterflyValveTag)
return entry
}
// NewPressureSwitchEntity 压力开关是与电器开关相结合的装置，当到达预先设定的流体压力时，开关接点动作
func NewPressureSwitchEntity(w ecs.World, id string) *ecs.Entry {
entry := NewElectricControlValveEntity(w, id)
entry.AddComponent(component.PressureSwitchTag)
return entry
}
// NewNonFirePowerSourceEntity 创建非消防电源实体
func NewNonFirePowerSourceEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)

12
entity/iscs_load.go
View File

@ -2,6 +2,7 @@ package entity
import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/repository/model/proto"
)
// LoadIscs 加载ISCS相关设备实体
@ -9,7 +10,10 @@ func LoadIscs(w ecs.World) error {
data := GetWorldData(w)
//电力母线实体
for _, pipe := range data.Repo.PipeMap {
NewPipeEntity(w, pipe.Id())
switch pipe.PipeType {
case proto.Pipe_ElectricPower:
NewPowerPipeEntity(w, pipe.Id())
}
}
//断路器
for _, circuitBreaker := range data.Repo.CircuitBreakerMap {
@ -37,7 +41,7 @@ func LoadIscs(w ecs.World) error {
}
//电源
for _, ps := range data.Repo.PowerSourceMap {
NewPowerSourceEntity(w, ps.Id())
NewPowerSourceEntity(w, ps.Id(), ps.Ac, ps.Voltage)
}
//避雷器
for _, la := range data.Repo.LightningArresterMap {
@ -57,7 +61,7 @@ func LoadIscs(w ecs.World) error {
}
//风亭(排风亭、送风亭)
for _, ap := range data.Repo.AirPavilionMap {
NewAirPavilionEntity(w, ap.Id())
NewAirPavilionEntity(w, ap.Id(), ap.PavilionType)
}
//阀门
for _, valve := range data.Repo.ValveMap {
@ -80,7 +84,7 @@ func LoadIscs(w ecs.World) error {
NewAirCurtainEntity(w, ac.Id())
}
//气体环境
for _, gasEnv := range data.Repo.EnvironmentMap {
for _, gasEnv := range data.Repo.GasEnvironmentMap {
NewGasEnvironmentEntity(w, gasEnv.Id())
}
//风机

28
entity/iscs_pscada.go
View File

@ -12,7 +12,7 @@ func NewCircuitBreakerEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.CircuitBreakerType, component.DeviceExceptionType))
e := w.Entry(w.Create(component.UidType, component.CircuitBreakerType, component.DeviceExceptionType))
component.UidType.SetValue(e, component.Uid{Id: id})
wd.EntityMap[id] = e
}
@ -24,7 +24,7 @@ func NewThreePositionSwitchEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.ThreePositionSwitchType, component.DeviceExceptionType))
e := w.Entry(w.Create(component.UidType, component.ThreePositionSwitchType, component.DeviceExceptionType))
component.UidType.SetValue(e, component.Uid{Id: id})
component.ThreePositionSwitchType.Set(e, &component.ThreePositionSwitch{Position: component.StpOpened})
wd.EntityMap[id] = e
@ -37,7 +37,7 @@ func NewHandcartSwitchEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.HandcartSwitchType, component.DeviceExceptionType))
e := w.Entry(w.Create(component.UidType, component.HandcartSwitchType, component.DeviceExceptionType))
component.UidType.SetValue(e, component.Uid{Id: id})
component.HandcartSwitchType.Set(e, &component.HandcartSwitch{Position: component.HpOpened})
wd.EntityMap[id] = e
@ -50,7 +50,7 @@ func NewRectifierEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.RectifierType, component.DeviceExceptionType))
e := w.Entry(w.Create(component.UidType, component.RectifierType, component.DeviceExceptionType))
component.UidType.SetValue(e, component.Uid{Id: id})
wd.EntityMap[id] = e
}
@ -62,7 +62,7 @@ func NewDisconnectorEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.DisconnectorType, component.DeviceExceptionType))
e := w.Entry(w.Create(component.UidType, component.DisconnectorType, component.DeviceExceptionType))
component.UidType.SetValue(e, component.Uid{Id: id})
wd.EntityMap[id] = e
}
@ -74,7 +74,7 @@ func NewLightningArresterEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.LightningArresterType))
e := w.Entry(w.Create(component.UidType, component.LightningArresterType))
component.UidType.SetValue(e, component.Uid{Id: id})
component.LightningArresterType.Set(e, &component.LightningArrester{Normal: true})
wd.EntityMap[id] = e
@ -87,7 +87,7 @@ func NewEarthingDeviceEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.EarthingDeviceType))
e := w.Entry(w.Create(component.UidType, component.EarthingDeviceType))
component.UidType.SetValue(e, component.Uid{Id: id})
component.EarthingDeviceType.Set(e, &component.EarthingDevice{Voltage: 0})
wd.EntityMap[id] = e
@ -100,30 +100,34 @@ func NewVoltageTransformerEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.VoltageTransformerType, component.DeviceExceptionType))
e := w.Entry(w.Create(component.UidType, component.VoltageTransformerType, component.DeviceExceptionType))
component.UidType.SetValue(e, component.Uid{Id: id})
wd.EntityMap[id] = e
}
return e
}
func NewPipeEntity(w ecs.World, id string) *ecs.Entry {
// NewPowerPipeEntity 创建PSCADA电力母线实体
func NewPowerPipeEntity(w ecs.World, id string) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.PipeType))
e := w.Entry(w.Create(component.UidType, component.PowerPipeType))
component.UidType.SetValue(e, component.Uid{Id: id})
component.PowerPipeType.Set(e, &component.PowerPipe{Sources: make(map[string]*component.ElePower)})
wd.EntityMap[id] = e
}
return e
}
// NewPowerSourceEntity 创建PSCADA电源实体
func NewPowerSourceEntity(w ecs.World, id string) *ecs.Entry {
func NewPowerSourceEntity(w ecs.World, id string, ac bool, voltage uint32) *ecs.Entry {
wd := GetWorldData(w)
e, ok := wd.EntityMap[id]
if !ok {
e = w.Entry(w.Create(component.UidType, component.ElectricitySourceType))
e := w.Entry(w.Create(component.UidType, component.PowerSourceType))
component.UidType.SetValue(e, component.Uid{Id: id})
component.PowerSourceType.Set(e, &component.PowerSource{Ac: ac, Voltage: voltage})
wd.EntityMap[id] = e
}
return e

27
entity/loader.go
View File

@ -1,27 +0,0 @@
package entity
import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/component/singleton"
"joylink.club/rtsssimulation/modelrepo"
"joylink.club/rtsssimulation/modelrepo/model"
)
// 加载城轨仿真实体
func Loading(w ecs.World, repo modelrepo.Repo) error {
singleton.LoadSingletons(w, repo)
for _, s := range repo.GetEcses() {
// 加载道岔实体
loadTurnouts(w, s.GetTurnouts())
}
return nil
}
func loadTurnouts(w ecs.World, points []model.Points) {
for _, p := range points {
switch p.GetTractionType() {
case model.PTT_ZDJ9_2:
}
}
}

34
entity/physical_section.go
View File

@ -1,34 +0,0 @@
package entity
import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/repository"
"unsafe"
)
var PhysicalSectionBaseComponentTypes = []ecs.IComponentType{component.UidType, component.PhysicalSectionTag, component.PhysicalSectionManagerType}
// LoadPhysicalSections 加载计轴区段
func LoadPhysicalSections(w ecs.World) error {
wd := GetWorldData(w)
sections := wd.Repo.PhysicalSectionList()
for _, section := range sections {
if is, err := section.IsAxleSection(); err == nil && is {
entry := w.Entry(w.Create(PhysicalSectionBaseComponentTypes...))
component.UidType.SetValue(entry, component.Uid{Id: section.Id()})
for _, group := range section.ComponentGroups() {
for _, ec := range group.Components() {
if ec.Code() == "GJ" {
relay := ec.(*repository.Relay)
gjEntry := NewRelayEntity(w, relay, wd.EntityMap)
circuit := &component.PhysicalSectionCircuit{GJ: gjEntry}
entry.AddComponent(component.PhysicalSectionCircuitType, unsafe.Pointer(circuit))
}
}
}
wd.EntityMap[section.Id()] = entry
}
}
return nil
}

22
entity/platform.go
View File

@ -1,22 +0,0 @@
package entity
import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/repository"
)
func LoadPlatform(w ecs.World) error {
wd := GetWorldData(w)
for _, platform := range wd.Repo.PlatformList() {
for _, group := range platform.ComponentGroups() {
for _, component := range group.Components() {
relay, ok := component.(*repository.Relay)
if !ok {
continue
}
NewRelayEntity(w, relay, wd.EntityMap)
}
}
}
return nil
}

36
entity/points.go
View File

@ -1,36 +0,0 @@
package entity
import (
"fmt"
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/component/relation"
"joylink.club/rtsssimulation/modelrepo/model"
)
func NewPoints(w ecs.World, p model.Points) *ecs.Entry {
id := p.Uid().Id()
// 创建道岔实体
e := w.Entry(w.Create(component.UidType, component.TurnoutTag, component.PointsModelRelaType, component.PointsZzjRelaType,
component.PointsPositionType))
c := p.GetZzjCount()
if c <= 0 {
panic(fmt.Errorf("道岔转辙机数量必须大于0。id=%s, zzjCount=%d", id, c))
}
// 创建转辙机实体
entities := w.CreateMany(c, component.PointsZzjRelaType, component.PointsZzjKbqStateType, component.FixedPositionTransformType)
pzr := &relation.PointsZzjRela{
Points: e,
}
// 关系状态初始化
component.UidType.Set(e, &component.Uid{Id: id})
component.PointsModelRelaType.Set(e, &relation.PointsModelRela{M: p})
component.PointsZzjRelaType.Set(e, pzr)
for _, ez := range entities {
zzj := w.Entry(ez)
pzr.Zzjs = append(pzr.Zzjs, zzj)
component.PointsZzjRelaType.Set(zzj, pzr)
}
return e
}

60
entity/psd.go
View File

@ -4,14 +4,13 @@ import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/repository"
"regexp"
"strconv"
)
var PsdBaseComponentTypeArr = []ecs.IComponentType{component.PsdTag, component.UidType,
component.PsdStateType, component.AsdListType, component.PscType}
var AsdBaseComponentTypeArr = []ecs.IComponentType{component.AsdTag, component.UidType,
component.AsdMotorStateType, component.FixedPositionTransformType, component.AsdStateType}
component.AsdMotorStateType, component.TwoPositionTransformType, component.AsdStateType}
func LoadPsd(w ecs.World) error {
data := GetWorldData(w)
@ -29,7 +28,7 @@ func LoadPsd(w ecs.World) error {
}
func loadPlatformMkxCircuit(world ecs.World, entryMap map[string]*ecs.Entry, pmcMap map[string]*ecs.Entry,
mkx *repository.PsdPsl, mkxEntry *ecs.Entry, psdEntry *ecs.Entry) {
mkx *repository.Mkx, mkxEntry *ecs.Entry, psdEntry *ecs.Entry) {
platformMkx, ok := pmcMap[mkx.Psd().Id()]
if !ok {
platformMkx = NewPlatformMkxEntry(world, entryMap, mkx)
@ -46,26 +45,18 @@ func loadPsdCircuit(world ecs.World, entry *ecs.Entry, psd *repository.Psd, entr
return
}
circuit := &component.PsdCircuit{KMJMap: make(map[int32]*ecs.Entry)}
pattern := regexp.MustCompile("(\\d*).*KMJ") //用来匹配开门继电器的正则表达式
for _, group := range psd.ComponentGroups() {
for _, ec := range group.Components() {
relay := ec.(*repository.Relay)
matches := pattern.FindStringSubmatch(relay.Code())
if len(matches) != 0 { //匹配上了
if matches[1] == "" { //SKMJ/XKMJ
circuit.KMJMap[0] = NewRelayEntity(world, relay, entryMap)
} else {
num, err := strconv.Atoi(matches[1])
if err != nil {
panic(err)
}
circuit.KMJMap[int32(num)] = NewRelayEntity(world, relay, entryMap)
}
continue
}
switch ec.Code() {
case "XGMJ", "SGMJ":
circuit.GMJ = NewRelayEntity(world, relay, entryMap)
case "XKMJ", "SKMJ":
circuit.KMJMap[0] = NewRelayEntity(world, relay, entryMap)
case "4XKMJ", "4SKMJ":
circuit.KMJMap[4] = NewRelayEntity(world, relay, entryMap)
case "8XKMJ", "8SKMJ":
circuit.KMJMap[8] = NewRelayEntity(world, relay, entryMap)
case "XMGJ", "SMGJ":
circuit.MGJ = NewRelayEntity(world, relay, entryMap)
case "XMPLJ", "SMPLJ":
@ -111,7 +102,7 @@ func NewAsdEntry(world ecs.World, worldData *component.WorldData, psdId string,
return entry
}
func NewMkxEntry(world ecs.World, worldData *component.WorldData, mkx *repository.PsdPsl) *ecs.Entry {
func NewMkxEntry(world ecs.World, worldData *component.WorldData, mkx *repository.Mkx) *ecs.Entry {
entry := world.Entry(world.Create(component.UidType, component.MkxType))
worldData.EntityMap[mkx.Id()] = entry
component.UidType.SetValue(entry, component.Uid{Id: mkx.Id()})
@ -120,44 +111,19 @@ func NewMkxEntry(world ecs.World, worldData *component.WorldData, mkx *repositor
if pcb := mkx.Pcb(); pcb != nil {
mkxComponent.PCB = NewButtonEntity(world, pcb, worldData.EntityMap)
}
if pcbpl := mkx.Pcbpl(); pcbpl != nil {
mkxComponent.PCBPL = NewButtonEntity(world, pcbpl, worldData.EntityMap)
}
if pob := mkx.Pob(); pob != nil {
mkxComponent.POB = NewButtonEntity(world, pob, worldData.EntityMap)
}
if pobpl := mkx.Pobpl(); pobpl != nil {
mkxComponent.POBPL = NewButtonEntity(world, pobpl, worldData.EntityMap)
}
if pab := mkx.Pab(); pab != nil {
mkxComponent.PAB = NewButtonEntity(world, pab, worldData.EntityMap)
}
if pabpl := mkx.Pabpl(); pabpl != nil {
mkxComponent.PABPL = NewButtonEntity(world, pabpl, worldData.EntityMap)
}
if wrzf := mkx.Wrzf(); wrzf != nil {
mkxComponent.WRZF = NewButtonEntity(world, wrzf, worldData.EntityMap)
}
if wrzfpl := mkx.Wrzfpl(); wrzfpl != nil {
mkxComponent.WRZFPL = NewButtonEntity(world, wrzfpl, worldData.EntityMap)
}
if qkqr := mkx.Qkqr(); qkqr != nil {
mkxComponent.QKQR = NewButtonEntity(world, qkqr, worldData.EntityMap)
}
if qkqrpl := mkx.Qkqrpl(); qkqrpl != nil {
mkxComponent.QKQRPL = NewButtonEntity(world, qkqrpl, worldData.EntityMap)
}
if mpl := mkx.Mpl(); mpl != nil {
mkxComponent.MPL = NewButtonEntity(world, mpl, worldData.EntityMap)
}
if jxtcpl := mkx.Jxtcpl(); jxtcpl != nil {
mkxComponent.JXTCPL = NewButtonEntity(world, jxtcpl, worldData.EntityMap)
}
return entry
}
func NewPlatformMkxEntry(world ecs.World, entryMap map[string]*ecs.Entry, mkx *repository.PsdPsl) *ecs.Entry {
func NewPlatformMkxEntry(world ecs.World, entryMap map[string]*ecs.Entry, mkx *repository.Mkx) *ecs.Entry {
entry := world.Entry(world.Create(component.PlatformMkxCircuitType))
circuit := &component.PlatformMkxCircuit{}
if pcbj := mkx.Pcbj(); pcbj != nil {
@ -169,12 +135,6 @@ func NewPlatformMkxEntry(world ecs.World, entryMap map[string]*ecs.Entry, mkx *r
if pabj := mkx.Pabj(); pabj != nil {
circuit.PABJ = NewRelayEntity(world, pabj, entryMap)
}
if wrzfj := mkx.Wrzfj(); wrzfj != nil {
circuit.WRZFJ = NewRelayEntity(world, wrzfj, entryMap)
}
if qkqrj := mkx.Qkqrj(); qkqrj != nil {
circuit.QKQRJ = NewRelayEntity(world, qkqrj, entryMap)
}
component.PlatformMkxCircuitType.Set(entry, circuit)
return entry
}

7
entity/relay.go
View File

@ -26,13 +26,6 @@ func NewRelayEntity(w ecs.World, relay *repository.Relay, entityMap map[string]*
entry.AddComponent(component.HfRelayTag)
}
entityMap[uid] = entry
//设置继电器初始状态
switch relay.DefaultPos() {
case proto.Relay_Pos_Q:
component.RelayDriveType.Get(entry).Td = true
case proto.Relay_Pos_H:
component.RelayDriveType.Get(entry).Td = false
}
}
return entry
}

5
entity/station.go
View File

@ -10,6 +10,7 @@ import (
func LoadStations(w ecs.World) error {
data := GetWorldData(w)
stations := data.Repo.StationList()
// 加载零散组合继电器
for _, station := range stations {
err := NewSFAEntity(w, station)
if err != nil {
@ -23,10 +24,6 @@ func LoadStations(w ecs.World) error {
if err != nil {
return err
}
err = NewLsEntity(w, station)
if err != nil {
return err
}
entry := NewStationEntity(w, station.Id(), data)
err = LoadSPKEntity(w, entry, station.SpksComponents(), data) // 人员防护
if err != nil {

51
entity/track_circuit.go
View File

@ -1,51 +0,0 @@
package entity
import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/repository"
"unsafe"
)
var TrackCircuitBaseComponentTypeArr = []ecs.IComponentType{component.UidType, component.TrackCircuitType}
func LoadTrackCircuit(w ecs.World) error {
data := GetWorldData(w)
for _, trackCircuit := range data.Repo.PhysicalSectionList() {
isAxleSection, err := trackCircuit.IsAxleSection()
if isAxleSection || err != nil {
continue
}
trackCircuitEntry := newTrackCircuitEntry(w, trackCircuit, data)
addTrackCircuit(w, trackCircuit, trackCircuitEntry, data)
}
return nil
}
func newTrackCircuitEntry(w ecs.World, section *repository.PhysicalSection, data *component.WorldData) *ecs.Entry {
uid := section.Id()
entry, ok := data.EntityMap[uid]
if !ok {
entry = w.Entry(w.Create(TrackCircuitBaseComponentTypeArr...))
component.UidType.SetValue(entry, component.Uid{Id: uid})
data.EntityMap[uid] = entry
}
return entry
}
func addTrackCircuit(w ecs.World, circuit *repository.PhysicalSection, entry *ecs.Entry, data *component.WorldData) {
if len(circuit.ComponentGroups()) == 0 {
return
}
trackCircuit := component.TrackCircuit{}
entry.AddComponent(component.TrackCircuitType, unsafe.Pointer(&trackCircuit))
for _, group := range circuit.ComponentGroups() {
for _, ec := range group.Components() {
relay := ec.(*repository.Relay)
switch ec.Code() {
case "GJ":
trackCircuit.GJ = NewRelayEntity(w, relay, data.EntityMap)
}
}
}
}

2
entity/turnout.go
View File

@ -52,7 +52,7 @@ func LoadTurnoutZdj9One(w ecs.World, turnout *repository.Turnout, entry *ecs.Ent
// 加载道岔ZDJ9双机转辙机
func LoadTurnoutZdj9Two(w ecs.World, turnout *repository.Turnout, entry *ecs.Entry, entityMap map[string]*ecs.Entry) error {
// 加载转辙机
entrys := ecs.Entries(w, w.CreateMany(2, component.ZzjStateType, component.FixedPositionTransformType))
entrys := ecs.Entries(w, w.CreateMany(2, component.ZzjStateType, component.TwoPositionTransformType))
// 给道岔添加转辙机引用组件
entry.AddComponent(component.TurnoutZzjType, unsafe.Pointer(&component.TurnoutZzj{
ZzjList: entrys,

66
entity/xcj.go
View File

@ -1,66 +0,0 @@
package entity
import (
"errors"
"fmt"
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/repository"
"strconv"
"strings"
"unsafe"
)
var XcjBaseComponentTypes = []ecs.IComponentType{component.UidType, component.XcjTag}
func LoadXcj(w ecs.World) error {
wd := GetWorldData(w)
for _, xcj := range wd.Repo.XcjList() {
//创建基础entry
entry := w.Entry(w.Create(XcjBaseComponentTypes...))
component.UidType.SetValue(entry, component.Uid{Id: xcj.Id()})
wd.EntityMap[xcj.Id()] = entry
//加载电路
if len(xcj.ComponentGroups()) != 0 {
circuit := &component.XcjCircuit{
TWJList: make([]*ecs.Entry, xcj.NumSegments),
CFJList: make([]*ecs.Entry, xcj.NumSegments),
}
entry.AddComponent(component.XcjCircuitType, unsafe.Pointer(circuit))
for _, group := range xcj.ComponentGroups() {
for _, ec := range group.Components() {
relay := ec.(*repository.Relay)
switch ec.Code() {
case "XQJ":
circuit.XQJ = NewRelayEntity(w, relay, wd.EntityMap)
case "TGQJ":
circuit.TGQJ = NewRelayEntity(w, relay, wd.EntityMap)
case "XCJXJ":
circuit.XCJXJ = NewRelayEntity(w, relay, wd.EntityMap)
case "XCYXJ":
circuit.XCYXJ = NewRelayEntity(w, relay, wd.EntityMap)
case "JTJ":
circuit.JTJ = NewRelayEntity(w, relay, wd.EntityMap)
case "TGYXJ":
circuit.TGYXJ = NewRelayEntity(w, relay, wd.EntityMap)
default:
if strings.Contains(ec.Code(), "TWJ") {
index, err := strconv.Atoi(ec.Code()[3:])
if err != nil {
return errors.New(fmt.Sprintf("洗车机继电器[%s]编号异常", ec.Code()))
}
circuit.TWJList[index-1] = NewRelayEntity(w, relay, wd.EntityMap)
} else if strings.Contains(ec.Code(), "CFJ") {
index, err := strconv.Atoi(ec.Code()[3:])
if err != nil {
return errors.New(fmt.Sprintf("洗车机继电器[%s]编号异常", ec.Code()))
}
circuit.CFJList[index-1] = NewRelayEntity(w, relay, wd.EntityMap)
}
}
}
}
}
}
return nil
}

42
examples/main.go
View File

@ -1,11 +1,6 @@
package main
import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/entity"
"joylink.club/rtsssimulation/fi"
"joylink.club/rtsssimulation/repository/model/proto"
"joylink.club/rtsssimulation/sys"
"time"
rtss_simulation "joylink.club/rtsssimulation"
@ -13,43 +8,6 @@ import (
)
func main() {
protoRepo := &proto.Repository{}
protoRepo.Id = "1"
protoRepo.Version = "V1"
protoRepo.Fans = append(protoRepo.Fans, &proto.Fan{Id: "fan1", FanType: proto.Fan_CommonFan})
protoRepo.Fans = append(protoRepo.Fans, &proto.Fan{Id: "fan2", FanType: proto.Fan_FcBypassFan})
protoRepo.Fans = append(protoRepo.Fans, &proto.Fan{Id: "fan3", FanType: proto.Fan_SoftStartFan})
protoRepo.Fans = append(protoRepo.Fans, &proto.Fan{Id: "fan4", FanType: proto.Fan_HighLowSpeedFan})
//
protoRepo.Valves = append(protoRepo.Valves, &proto.Valve{Id: "valve1", ValveType: proto.Valve_ElectricControlValve})
protoRepo.Valves = append(protoRepo.Valves, &proto.Valve{Id: "valve2", ValveType: proto.Valve_ElectricAirValve})
protoRepo.Valves = append(protoRepo.Valves, &proto.Valve{Id: "valve3", ValveType: proto.Valve_CombinationAirValve})
protoRepo.Valves = append(protoRepo.Valves, &proto.Valve{Id: "valve4", ValveType: proto.Valve_ElectricButterflyValve})
//
repo, _ := repository.BuildRepository(protoRepo)
sim, _ := newIscsSimulation(repo)
sim.StartUp()
time.Sleep(2 * time.Second)
fi.ValveOperate(sim, "valve1", 100)
time.Sleep(5 * time.Second)
fi.ValveOperate(sim, "valve1", 1)
time.Sleep(4 * time.Second)
sim.Close()
time.Sleep(2 * time.Second)
}
func newIscsSimulation(repo *repository.Repository) (ecs.World, error) {
w := ecs.NewWorld(100)
sys.BindSystem(w)
//
// 初始化世界数据单例组件
entity.LoadWorldData(w, repo)
err := entity.LoadIscs(w)
return w, err
}
///////////////////////////////////////////////////////
func main1() {
sim, _ := rtss_simulation.NewSimulation(&repository.Repository{})
sim.StartUp()
sim.SetSpeed(2)

77
examples/signal_2xh1/main.go Normal file
View File

@ -0,0 +1,77 @@
package main
import (
"log/slog"
"os"
"time"
"joylink.club/ecs"
rtss_simulation "joylink.club/rtsssimulation"
"joylink.club/rtsssimulation/consts"
"joylink.club/rtsssimulation/entity"
"joylink.club/rtsssimulation/examples/signal_2xh1/sigSys"
"joylink.club/rtsssimulation/fi"
"joylink.club/rtsssimulation/repository"
"joylink.club/rtsssimulation/repository/model/proto"
)
const (
IdSignal2XH1 = "signal_2xh1-1"
)
// 信号机测试
func main() {
//
logConfig := &slog.HandlerOptions{AddSource: false, Level: slog.LevelDebug}
slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, logConfig)))
//
proto := &proto.Repository{}
proto.Id = "test-for-signal"
proto.Version = "v1.0"
addProtoSignal2XH1(proto)
repo := repository.BuildRepositoryForSignalTest(proto)
sim, _ := rtss_simulation.NewSimulation(repo)
loadEntities(sim, repo)
sim.SetSpeed(0.1)
sim.AddSystem(sigSys.NewSignalDebugSystem())
sim.StartUp()
//
time.Sleep(1 * time.Second)
slog.Debug("灭灯 .....")
fi.DriveSignal2XH1Dd(sim, IdSignal2XH1, false) //灭灯
time.Sleep(2 * time.Second)
slog.Debug("亮灯 .....")
fi.DriveSignal2XH1Dd(sim, IdSignal2XH1, true) //亮灯
time.Sleep(2 * time.Second)
slog.Debug("开通列车信号 .....")
fi.DriveSignal2XH1Lx(sim, IdSignal2XH1) //开通列车信号
time.Sleep(3 * time.Second)
slog.Debug("开通禁止信号 .....")
fi.DriveSignal2XH1Non(sim, IdSignal2XH1) //开通禁止信号
//
time.Sleep(3 * time.Second)
sim.Close()
}
func addProtoSignal2XH1(r *proto.Repository) {
//相关继电器
r.Relays = append(r.Relays, &proto.Relay{Id: "2xh1-ddj", Code: consts.SIGNAL_DDJ, Model: proto.Relay_JWXC_1700})
r.Relays = append(r.Relays, &proto.Relay{Id: "2xh1-dj", Code: consts.SIGNAL_DJ, Model: proto.Relay_JZXC_H18})
r.Relays = append(r.Relays, &proto.Relay{Id: "2xh1-lxj", Code: consts.SIGNAL_LXJ, Model: proto.Relay_JWXC_1700})
//
signal := &proto.Signal{}
signal.Id = IdSignal2XH1
signal.Km = &proto.Kilometer{}
//
group := &proto.ElectronicComponentGroup{Code: consts.SIGNAL_2XH1, ComponentIds: []string{"2xh1-ddj", "2xh1-dj", "2xh1-lxj"}}
//
signal.ElectronicComponentGroups = append(signal.ElectronicComponentGroups, group)
r.Signals = append(r.Signals, signal)
}
func loadEntities(w ecs.World, repo *repository.Repository) {
// 初始化世界数据单例组件
entity.LoadWorldData(w, repo)
//
if le := entity.LoadSignals(w); le != nil {
slog.Error(le.Error())
}
}

69
examples/signal_3xh1/main.go
View File

@ -2,9 +2,16 @@ package main
import (
"fmt"
"log/slog"
"os"
"time"
"joylink.club/ecs"
rtss_simulation "joylink.club/rtsssimulation"
"joylink.club/rtsssimulation/consts"
"joylink.club/rtsssimulation/entity"
"joylink.club/rtsssimulation/examples/signal_3xh1/sigSys"
"joylink.club/rtsssimulation/fi"
"joylink.club/rtsssimulation/repository"
"joylink.club/rtsssimulation/repository/model/proto"
)
@ -15,37 +22,37 @@ const (
// 信号机测试
func main() {
/* logConfig := &slog.HandlerOptions{AddSource: false, Level: slog.LevelDebug}
slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, logConfig)))
//
proto := &proto.Repository{}
proto.Id = "test-for-signal"
proto.Version = "v1.0"
addProtoSignal3XH1(proto)
repo := repository.BuildRepositoryForSignalTest(proto)
sim, _ := rtss_simulation.NewSimulation(repo)
loadEntities(sim, repo)
sim.SetSpeed(1)
sim.AddSystem(sigSys.NewSignalDebugSystem())
sim.StartUp()
//
time.Sleep(1 * time.Second)
slog.Debug("灭灯 .....")
fi.DriveSignal3XH1Dd(sim, IdSignal3XH1, false)
//
time.Sleep(1 * time.Second)
slog.Debug("亮灯 .....")
fi.DriveSignal3XH1Dd(sim, IdSignal3XH1, true)
//
time.Sleep(2 * time.Second)
slog.Debug("开通引导信号 .....")
fi.DriveSignal3XH1Yx(sim, IdSignal3XH1)
time.Sleep(2 * time.Second)
slog.Debug("开通列车信号 .....")
fi.DriveSignal3XH1Lx(sim, IdSignal3XH1, false)
//
time.Sleep(5 * time.Second)
sim.Close()*/
logConfig := &slog.HandlerOptions{AddSource: false, Level: slog.LevelDebug}
slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, logConfig)))
//
proto := &proto.Repository{}
proto.Id = "test-for-signal"
proto.Version = "v1.0"
addProtoSignal3XH1(proto)
repo := repository.BuildRepositoryForSignalTest(proto)
sim, _ := rtss_simulation.NewSimulation(repo)
loadEntities(sim, repo)
sim.SetSpeed(1)
sim.AddSystem(sigSys.NewSignalDebugSystem())
sim.StartUp()
//
time.Sleep(1 * time.Second)
slog.Debug("灭灯 .....")
fi.DriveSignal3XH1Dd(sim, IdSignal3XH1, false)
//
time.Sleep(1 * time.Second)
slog.Debug("亮灯 .....")
fi.DriveSignal3XH1Dd(sim, IdSignal3XH1, true)
//
time.Sleep(2 * time.Second)
slog.Debug("开通引导信号 .....")
fi.DriveSignal3XH1Yx(sim, IdSignal3XH1)
time.Sleep(2 * time.Second)
slog.Debug("开通列车信号 .....")
fi.DriveSignal3XH1Lx(sim, IdSignal3XH1, false)
//
time.Sleep(5 * time.Second)
sim.Close()
}
func addProtoSignal3XH1(r *proto.Repository) {
//相关继电器

66
fi/balise.go
View File

@ -1,66 +0,0 @@
package fi
import (
"fmt"
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/entity"
)
// BaliseUpdateFixedTelegram 更新固定报文
func BaliseUpdateFixedTelegram(w ecs.World, id string, telegram []byte, userTelegram []byte) error {
result := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
entry, ok := wd.EntityMap[id]
if ok {
baliseFixedTelegram := component.BaliseFixedTelegramType.Get(entry)
baliseFixedTelegram.Telegram = telegram
baliseFixedTelegram.UserTelegram = userTelegram
} else {
return ecs.NewErrResult(fmt.Errorf("未找到id=%s的应答器", id))
}
return ecs.NewOkEmptyResult()
})
return result.Err
}
// BaliseUpdateVariableTelegram 更新可变报文
func BaliseUpdateVariableTelegram(w ecs.World, id string, telegram []byte, userTelegram []byte, force bool) error {
result := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
entry, ok := wd.EntityMap[id]
if ok {
if entry.HasComponent(component.BaliseVariableTelegramType) {
if force {
entry.AddComponent(component.ForceVariableTelegram)
} else if entry.HasComponent(component.ForceVariableTelegram) {
return ecs.NewOkEmptyResult()
}
baliseVariableTelegram := component.BaliseVariableTelegramType.Get(entry)
baliseVariableTelegram.Telegram = telegram
baliseVariableTelegram.UserTelegram = userTelegram
} else {
ecs.NewErrResult(fmt.Errorf("应答器[%s]无可变报文组件", id))
}
} else {
return ecs.NewErrResult(fmt.Errorf("未找到应答器[%s]", id))
}
return ecs.NewOkEmptyResult()
})
return result.Err
}
// BaliseCancelForceVariableTelegram 取消强制可变报文
func BaliseCancelForceVariableTelegram(w ecs.World, id string) error {
request := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
entry, ok := wd.EntityMap[id]
if ok {
if entry.HasComponent(component.ForceVariableTelegram) {
entry.RemoveComponent(component.ForceVariableTelegram)
}
}
return ecs.NewOkEmptyResult()
})
return request.Err
}

42
fi/circuit.go Normal file
View File

@ -0,0 +1,42 @@
package fi
import (
"fmt"
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/entity"
)
// 采集继电器吸起电路状态
func CollectXQCircuitState(w ecs.World, id string) bool {
wd := entity.GetWorldData(w)
entry, ok := wd.EntityMap[id]
if ok {
state := component.BitStateType.Get(entry)
return state.Val
} else {
fmt.Printf("未找到id=%s的继电器\n", id)
}
return false
}
// 采集继电器落下电路状态
func CollectLXCircuitState(w ecs.World, id string) bool {
wd := entity.GetWorldData(w)
entry, ok := wd.EntityMap[id]
if ok {
state := component.BitStateType.Get(entry)
return !state.Val
} else {
fmt.Printf("未找到id=%s的继电器\n", id)
}
return false
}
// 驱动电路状态修改
// x,y:二维数组的索引
// state : 32位的bool数组
func DriveCircuitStateChange(w ecs.World, x, y int, state bool) {
}

4
fi/button.go → fi/ibp.go
View File

@ -2,7 +2,6 @@ package fi
import (
"fmt"
//"joylink.club/bj-rtsts-server/dto/request_proto"
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
@ -17,7 +16,6 @@ func PressDownButton(w ecs.World, id string) error {
if ok {
state := component.BitStateType.Get(entry)
state.Val = true
} else {
return ecs.NewErrResult(fmt.Errorf("未找到id=%s的按钮", id))
}
@ -34,7 +32,6 @@ func PressUpButton(w ecs.World, id string) error {
if ok {
state := component.BitStateType.Get(entry)
state.Val = false
} else {
return ecs.NewErrResult(fmt.Errorf("未找到id=%s的按钮", id))
}
@ -51,7 +48,6 @@ func SwitchKeyGear(w ecs.World, id string, gear int32) error {
if ok {
state := component.GearStateType.Get(entry)
state.Val = gear
} else {
return ecs.NewErrResult(fmt.Errorf("未找到id=%s的钥匙开关", id))
}

151
fi/iscs_bas.go
View File

@ -2,21 +2,16 @@ package fi
import (
"fmt"
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/consts"
"joylink.club/rtsssimulation/entity"
)
// ValveOperate 阀门操作
// CommonFanOperate 一般风机控制,如排烟风机、正压送风机、射流风机、普通风机、硬线风机
//
// deviceId 阀门id;
// openRate 阀门打开百分比值，0-全关，100-全开;
func ValveOperate(w ecs.World, deviceId string, openRate uint8) error {
if openRate < 0 || openRate > 100 {
return fmt.Errorf("阀门打开百分比值[%d]不在范围[0,100]内", openRate)
}
// power : 风机电源，大于0接通正转相序电源，小于0接通反转相序电源，等于0关闭电源
func CommonFanOperate(w ecs.World, deviceId string, power int) error {
r := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
deviceEntry, ok := wd.EntityMap[deviceId]
@ -24,10 +19,120 @@ func ValveOperate(w ecs.World, deviceId string, openRate uint8) error {
return ecs.NewErrResult(fmt.Errorf("设备[%s]实体不存在", deviceId))
}
//
if !(deviceEntry.HasComponent(component.ValveType) && deviceEntry.HasComponent(component.ValveControllerType) && deviceEntry.HasComponent(component.FixedPositionTransformType)) {
return ecs.NewErrResult(fmt.Errorf("设备[%s]不是阀门", deviceId))
if !deviceEntry.HasComponent(component.FanType) {
return ecs.NewErrResult(fmt.Errorf("设备[%s]不是风机", deviceId))
}
//
fan := component.FanType.Get(deviceEntry)
fan.Power = power
//
return ecs.NewOkEmptyResult()
})
return r.Err
}
// SoftBypassFanOperate 如软启风机、隧道风机
func SoftBypassFanOperate(w ecs.World, deviceId string, power int, softStart bool, bypass bool) error {
r := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
deviceEntry, ok := wd.EntityMap[deviceId]
if !ok {
return ecs.NewErrResult(fmt.Errorf("设备[%s]实体不存在", deviceId))
}
//
if !deviceEntry.HasComponent(component.FanType) {
return ecs.NewErrResult(fmt.Errorf("设备[%s]不是风机", deviceId))
}
//
fan := component.FanType.Get(deviceEntry)
fan.Bypass = bypass
fan.SoftStart = softStart
fan.Power = power
//
return ecs.NewOkEmptyResult()
})
return r.Err
}
// FcBypassFanOperate (变频、旁路)回排风机
func FcBypassFanOperate(w ecs.World, deviceId string, power int, fc bool, bypass bool) error {
r := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
deviceEntry, ok := wd.EntityMap[deviceId]
if !ok {
return ecs.NewErrResult(fmt.Errorf("设备[%s]实体不存在", deviceId))
}
//
if !deviceEntry.HasComponent(component.FanType) {
return ecs.NewErrResult(fmt.Errorf("设备[%s]不是风机", deviceId))
}
//
fan := component.FanType.Get(deviceEntry)
fan.Bypass = bypass
fan.Fc = fc
fan.Power = power
//
return ecs.NewOkEmptyResult()
})
return r.Err
}
// TwoSpeedFanOperate 双速风机，转速模式设置
//
// highSpeedMode-true高速模式，false-低速模式
func TwoSpeedFanOperate(w ecs.World, deviceId string, power int, highSpeedMode bool) error {
r := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
deviceEntry, ok := wd.EntityMap[deviceId]
if !ok {
return ecs.NewErrResult(fmt.Errorf("设备[%s]实体不存在", deviceId))
}
//
if !(deviceEntry.HasComponent(component.FanType) && deviceEntry.HasComponent(component.TwoSpeedFanTag)) {
return ecs.NewErrResult(fmt.Errorf("设备[%s]不是双速风机", deviceId))
}
//
fan := component.FanType.Get(deviceEntry)
fan.Power = power
//
deviceEntry.RemoveComponent(component.HighSpeedModeFanTag)
deviceEntry.RemoveComponent(component.LowSpeedModeFanTag)
if highSpeedMode {
deviceEntry.AddComponent(component.HighSpeedModeFanTag)
} else {
deviceEntry.AddComponent(component.LowSpeedModeFanTag)
}
//
return ecs.NewOkEmptyResult()
})
return r.Err
}
// FanExceptionOperate 风机异常设置(故障、异常、通信中断)
func FanExceptionOperate(w ecs.World, deviceId string, opt DeviceExceptionOptEnum) error {
return DeviceExceptionOperate(w, deviceId, opt)
}
// ElectricControlValveOperate 电动调节阀操作
//
// optOpen : true-触发开阀；false-触发关阀
func ElectricControlValveOperate(w ecs.World, deviceId string, optOpen bool) error {
r := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
deviceEntry, ok := wd.EntityMap[deviceId]
if !ok {
return ecs.NewErrResult(fmt.Errorf("设备[%s]实体不存在", deviceId))
}
//
if !(deviceEntry.HasComponent(component.ElectricControlValveType) && deviceEntry.HasComponent(component.TwoPositionTransformType)) {
return ecs.NewErrResult(fmt.Errorf("设备[%s]不是电动调节阀", deviceId))
}
tps := component.TwoPositionTransformType.Get(deviceEntry) //最小表示全关，最大表示全开
if optOpen {
tps.Speed = component.CalculateTwoPositionAvgSpeed(component.ElectricControlValveOperationTime, w.Tick())
} else {
tps.Speed = -component.CalculateTwoPositionAvgSpeed(component.ElectricControlValveOperationTime, w.Tick())
}
component.ValveControllerType.Get(deviceEntry).TargetOpenRate = openRate
//
return ecs.NewOkEmptyResult()
})
@ -197,6 +302,30 @@ func WaterClosedContainerOperate(w ecs.World, deviceId string, optRun bool) erro
return r.Err
}
// BypassValveSwitchOperate 旁通阀开关操作
//
// openRate 旁通阀开关打开百分比[0,100]
func BypassValveSwitchOperate(w ecs.World, deviceId string, openRate uint8) error {
if openRate < 0 || openRate > 100 {
return fmt.Errorf("旁通阀开关打开百分比值须在[0,100]范围内")
}
r := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
deviceEntry, ok := wd.EntityMap[deviceId]
if !ok {
return ecs.NewErrResult(fmt.Errorf("设备[%s]实体不存在", deviceId))
}
//
if !(deviceEntry.HasComponent(component.ControlValveType) && deviceEntry.HasComponent(component.BypassValveSwitchTag)) {
return ecs.NewErrResult(fmt.Errorf("设备[%s]不是旁通阀开关", deviceId))
}
component.ControlValveType.Get(deviceEntry).OpenRate = openRate
//
return ecs.NewOkEmptyResult()
})
return r.Err
}
// CivilDefenseDoorOperate 封闭式水容器(如冷却塔、水处理器)
//
// optOpen : true-开门；false-关门

62
fi/motor.go
View File

@ -1,62 +0,0 @@
package fi
import (
"fmt"
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/entity"
)
// FiMotorSwitch 电机电源开关定义
type FiMotorSwitch uint8
const (
FiMsOff FiMotorSwitch = iota //关闭电源
FiMsOnForward //正转电源
FiMsOnReverse //反转电源
)
// MotorOperate 电机操作
//
// deviceId 电机id；
// fiMs 电机电源；
// fc 电机如果有变频器，设置频率；
func MotorOperate(w ecs.World, deviceId string, fiMs FiMotorSwitch, fc uint16) error {
if fc < 0 || fc > 100 {
return fmt.Errorf("设置变频器频率[%d]不在[0,100]范围内", fc)
}
ms, e := func(fiMs FiMotorSwitch) (component.MotorSwitch, error) {
switch fiMs {
case FiMsOff:
return component.MsOff, nil
case FiMsOnForward:
return component.MsOnForward, nil
case FiMsOnReverse:
return component.MsOnReverse, nil
default:
return 0, fmt.Errorf("参数fiMs[%d]无法映射到component.MotorSwitch", fiMs)
}
}(fiMs)
if e != nil {
return e
}
r := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
deviceEntry, ok := wd.EntityMap[deviceId]
if !ok {
return ecs.NewErrResult(fmt.Errorf("设备[%s]实体不存在", deviceId))
}
//
if !deviceEntry.HasComponent(component.MotorType) {
return ecs.NewErrResult(fmt.Errorf("设备[%s]不是电机", deviceId))
}
motor := component.MotorType.Get(deviceEntry)
motor.Ms = ms
if deviceEntry.HasComponent(component.MotorFcType) { //变频电机
component.MotorFcType.Get(deviceEntry).F = fc
}
//
return ecs.NewOkEmptyResult()
})
return r.Err
}

120
fi/physical_section.go
View File

@ -1,120 +0,0 @@
package fi
import (
"fmt"
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/entity"
"strings"
)
// PhysicalSectionFaultOccDrive 区段故障占用设置
func PhysicalSectionFaultOccDrive(w ecs.World, sectionId string, set bool) error {
r := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
sectionModel := wd.Repo.FindPhysicalSection(sectionId)
if sectionModel == nil {
return ecs.NewErrResult(fmt.Errorf("区段模型[%s]不存实体", sectionId))
}
//
sectionEntry := wd.EntityMap[sectionId]
if sectionEntry == nil {
return ecs.NewErrResult(fmt.Errorf("区段[%s]实体不存在", sectionId))
}
if set { //计轴故障设置
if !sectionEntry.HasComponent(component.PhysicalSectionForceOccupied) {
sectionEntry.AddComponent(component.PhysicalSectionForceOccupied)
}
} else { //计轴故障取消
if sectionEntry.HasComponent(component.PhysicalSectionForceOccupied) {
sectionEntry.RemoveComponent(component.PhysicalSectionForceOccupied)
}
}
return ecs.NewOkEmptyResult()
})
return r.Err
}
// PhysicalSectionDrstDrive 直接复位
func PhysicalSectionDrstDrive(w ecs.World, sectionId string) (*PhysicalSectionState, error) {
r := <-ecs.Request[*PhysicalSectionState](w, func() ecs.Result[*PhysicalSectionState] {
wd := entity.GetWorldData(w)
entry := wd.EntityMap[sectionId]
if entry == nil {
return ecs.NewResult[*PhysicalSectionState](nil, fmt.Errorf("区段[%s]实体不存在", sectionId))
}
axleManager := component.PhysicalSectionManagerType.Get(entry)
state := &PhysicalSectionState{}
if axleManager.Count != 0 {
state.Rjo = true
} else {
entry.RemoveComponent(component.PhysicalSectionForceOccupied)
state.Rac = true
}
return ecs.NewOkResult(state)
})
return r.Val, r.Err
}
// PhysicalSectionPdrstDrive 预复位
func PhysicalSectionPdrstDrive(w ecs.World, sectionId string) (*PhysicalSectionState, error) {
r := <-ecs.Request[*PhysicalSectionState](w, func() ecs.Result[*PhysicalSectionState] {
wd := entity.GetWorldData(w)
entry := wd.EntityMap[sectionId]
if entry == nil {
return ecs.NewResult[*PhysicalSectionState](nil, fmt.Errorf("区段[%s]实体不存在", sectionId))
}
axleManager := component.PhysicalSectionManagerType.Get(entry)
state := &PhysicalSectionState{}
if axleManager.Count != 0 {
state.Rjo = true
} else {
state.Rac = true
}
return ecs.NewOkResult(state)
})
return r.Val, r.Err
}
// FindPhysicalSectionsStatus 获取物理区段的相关状态
func FindPhysicalSectionsStatus(w ecs.World, sectionIds []string) ([]*PhysicalSectionState, error) {
r := <-ecs.Request[[]*PhysicalSectionState](w, func() ecs.Result[[]*PhysicalSectionState] {
wd := entity.GetWorldData(w)
var msg []*PhysicalSectionState
var esb = strings.Builder{} //收集未找到的区段的id
for _, sectionId := range sectionIds {
entry := wd.EntityMap[sectionId]
if entry == nil {
esb.WriteString(fmt.Sprintf("%s,", sectionId))
continue
}
axleManager := component.PhysicalSectionManagerType.Get(entry)
msg = append(msg, &PhysicalSectionState{
Id: sectionId,
Clr: !axleManager.Occupied,
Occ: axleManager.Occupied,
})
}
if esb.Len() > 0 {
return ecs.NewResult(msg, fmt.Errorf("区段非物理区段或物理区段状态不存在：[%s]", esb.String()))
} else {
return ecs.NewResult(msg, nil)
}
})
return r.Val, r.Err
}
type PhysicalSectionState struct {
//uid
Id string
//0-bit7 区段出清
Clr bool
//0-bit6 区段占用
Occ bool
//1-bit6 区段复位反馈
Rac bool
//1-bit5 运营原因拒绝计轴复位
Rjo bool
//1-bit4 技术原因拒绝计轴复位
Rjt bool
}

353
fi/psd.go Normal file
View File

@ -0,0 +1,353 @@
package fi
import (
"errors"
"fmt"
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/component/component_proto"
"joylink.club/rtsssimulation/entity"
)
func SetInterlockKm(world ecs.World, psdId string, group int32) error {
result := <-ecs.Request[ecs.EmptyType](world, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(world)
entry, ok := wd.EntityMap[psdId]
if ok {
err := setInterlockKm(wd, entry, group)
if err != nil {
return ecs.NewErrResult(err)
}
} else {
return ecs.NewErrResult(fmt.Errorf("未找到id=%s的屏蔽门", psdId))
}
return ecs.NewOkEmptyResult()
})
return result.Err
}
func CancelInterlockKm(world ecs.World, id string, group int32) error {
result := <-ecs.Request[ecs.EmptyType](world, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(world)
entry, ok := wd.EntityMap[id]
if ok {
err := cancelInterlockKm(wd, entry, group)
if err != nil {
return ecs.NewErrResult(err)
}
} else {
return ecs.NewErrResult(fmt.Errorf("未找到id=%s的屏蔽门", id))
}
return ecs.NewOkEmptyResult()
})
return result.Err
}
func SetInterlockGm(world ecs.World, id string) error {
result := <-ecs.Request[ecs.EmptyType](world, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(world)
entry, ok := wd.EntityMap[id]
if ok {
err := setInterlockGm(wd, entry)
if err != nil {
return ecs.NewErrResult(err)
}
} else {
return ecs.NewErrResult(fmt.Errorf("未找到id=%s的屏蔽门", id))
}
return ecs.NewOkEmptyResult()
})
return result.Err
}
func CancelInterlockGm(world ecs.World, id string) error {
result := <-ecs.Request[ecs.EmptyType](world, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(world)
entry, ok := wd.EntityMap[id]
if ok {
err := cancelInterlockGm(wd, entry)
if err != nil {
return ecs.NewErrResult(err)
}
} else {
return ecs.NewErrResult(fmt.Errorf("未找到id=%s的屏蔽门", id))
}
return ecs.NewOkEmptyResult()
})
return result.Err
}
func SetPsdFault(world ecs.World, id string, fault component_proto.Psd_Fault, asdCodes []int32) error {
result := <-ecs.Request[ecs.EmptyType](world, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(world)
psdEntry, ok := wd.EntityMap[id]
if !ok {
return ecs.NewErrResult(fmt.Errorf("未找到id=%s的屏蔽门", id))
}
tag, err := component.GetAsdFaultTag(fault)
if err != nil {
return ecs.NewErrResult(err)
}
asdList := component.AsdListType.Get(psdEntry).List
for _, code := range asdCodes {
asdEntry := asdList[int(code-1)]
asdEntry.AddComponent(tag)
}
return ecs.NewOkEmptyResult()
})
return result.Err
}
func CancelPsdFault(world ecs.World, id string, fault component_proto.Psd_Fault, asdCodes []int32) error {
result := <-ecs.Request[ecs.EmptyType](world, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(world)
psdEntry, ok := wd.EntityMap[id]
if !ok {
return ecs.NewErrResult(fmt.Errorf("未找到id=%s的屏蔽门", id))
}
tag, err := component.GetAsdFaultTag(fault)
if err != nil {
return ecs.NewErrResult(err)
}
asdList := component.AsdListType.Get(psdEntry).List
for _, code := range asdCodes {
asdEntry := asdList[int(code-1)]
asdEntry.RemoveComponent(tag)
}
return ecs.NewOkEmptyResult()
})
return result.Err
}
func SetQDTC(world ecs.World, id string) error {
result := <-ecs.Request[ecs.EmptyType](world, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(world)
entry, ok := wd.EntityMap[id]
if ok {
err := setQDTC(wd, entry)
if err != nil {
return ecs.NewErrResult(err)
}
} else {
return ecs.NewErrResult(fmt.Errorf("未找到id=%s的屏蔽门", id))
}
return ecs.NewOkEmptyResult()
})
return result.Err
}
func CancelQDTC(world ecs.World, id string) error {
result := <-ecs.Request[ecs.EmptyType](world, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(world)
entry, ok := wd.EntityMap[id]
if ok {
err := cancelQDTC(wd, entry)
if err != nil {
return ecs.NewErrResult(err)
}
} else {
return ecs.NewErrResult(fmt.Errorf("未找到id=%s的屏蔽门", id))
}
return ecs.NewOkEmptyResult()
})
return result.Err
}
func SetTZTC(world ecs.World, id string) error {
result := <-ecs.Request[ecs.EmptyType](world, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(world)
entry, ok := wd.EntityMap[id]
if ok {
err := setTZTC(wd, entry)
if err != nil {
return ecs.NewErrResult(err)
}
} else {
return ecs.NewErrResult(fmt.Errorf("未找到id=%s的屏蔽门", id))
}
return ecs.NewOkEmptyResult()
})
return result.Err
}
func CancelTZTC(world ecs.World, id string) error {
result := <-ecs.Request[ecs.EmptyType](world, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(world)
entry, ok := wd.EntityMap[id]
if ok {
err := cancelTZTC(wd, entry)
if err != nil {
return ecs.NewErrResult(err)
}
} else {
return ecs.NewErrResult(fmt.Errorf("未找到id=%s的屏蔽门", id))
}
return ecs.NewOkEmptyResult()
})
return result.Err
}
func cancelTZTC(wd *component.WorldData, psdEntry *ecs.Entry) error {
if psdEntry.HasComponent(component.PsdCircuitType) {
circuit := component.PsdCircuitType.Get(psdEntry)
return wd.SetQdBit(component.UidType.Get(circuit.TZTCJ).Id, false)
} else {
psc := component.PscType.Get(psdEntry)
psc.TZTC = false
}
return nil
}
func setTZTC(wd *component.WorldData, psdEntry *ecs.Entry) error {
if psdEntry.HasComponent(component.PsdCircuitType) {
circuit := component.PsdCircuitType.Get(psdEntry)
return wd.SetQdBits([]*component.QdBitParam{
component.NewQdBitParam(component.UidType.Get(circuit.QDTCJ).Id, false),
component.NewQdBitParam(component.UidType.Get(circuit.TZTCJ).Id, true),
})
} else {
psc := component.PscType.Get(psdEntry)
psc.QDTC = false
psc.TZTC = true
}
return nil
}
func cancelQDTC(wd *component.WorldData, psdEntry *ecs.Entry) error {
if psdEntry.HasComponent(component.PsdCircuitType) {
circuit := component.PsdCircuitType.Get(psdEntry)
return wd.SetQdBit(component.UidType.Get(circuit.QDTCJ).Id, false)
} else {
psc := component.PscType.Get(psdEntry)
psc.QDTC = false
}
return nil
}
func setQDTC(wd *component.WorldData, psdEntry *ecs.Entry) error {
if psdEntry.HasComponent(component.PsdCircuitType) {
circuit := component.PsdCircuitType.Get(psdEntry)
return wd.SetQdBits([]*component.QdBitParam{
component.NewQdBitParam(component.UidType.Get(circuit.QDTCJ).Id, true),
component.NewQdBitParam(component.UidType.Get(circuit.TZTCJ).Id, false),
})
} else {
psc := component.PscType.Get(psdEntry)
psc.QDTC = true
psc.TZTC = false
}
return nil
}
// 设置联锁开门
func setInterlockKm(wd *component.WorldData, psdEntry *ecs.Entry, group int32) error {
if psdEntry.HasComponent(component.PsdCircuitType) { //有联锁区段电路
circuit := component.PsdCircuitType.Get(psdEntry)
if circuit.KMJMap[0] != nil { //0编组意味着屏蔽门仅有一个开门继电器
return setRelayDriveKm(wd, circuit, 0)
} else {
kmj := circuit.KMJMap[group]
if kmj == nil {
id := component.UidType.Get(psdEntry).Id
return errors.New(fmt.Sprintf("屏蔽门[id:%s]不支持[%d]编组操作", id, group))
}
return setRelayDriveKm(wd, circuit, group)
}
} else {
psc := component.PscType.Get(psdEntry)
psc.InterlockKmGroup[group] = true
}
return nil
}
// 取消联锁开门
func cancelInterlockKm(wd *component.WorldData, psdEntry *ecs.Entry, group int32) error {
if psdEntry.HasComponent(component.PsdCircuitType) { //有联锁区段电路
circuit := component.PsdCircuitType.Get(psdEntry)
if circuit.KMJMap[0] != nil { //0编组意味着屏蔽门仅有一个开门继电器
return cancelRelayDriveKm(wd, circuit, 0)
} else {
kmj := circuit.KMJMap[group]
if kmj == nil {
id := component.UidType.Get(psdEntry).Id
return errors.New(fmt.Sprintf("屏蔽门[id:%s]不支持[%d]编组操作", id, group))
}
return cancelRelayDriveKm(wd, circuit, group)
}
} else {
psc := component.PscType.Get(psdEntry)
psc.InterlockKmGroup[group] = false
}
return nil
}
// 设置联锁关门
func setInterlockGm(wd *component.WorldData, psdEntry *ecs.Entry) error {
if psdEntry.HasComponent(component.PsdCircuitType) { //有联锁区段电路
circuit := component.PsdCircuitType.Get(psdEntry)
return setRelayDriveGm(wd, circuit)
} else {
psc := component.PscType.Get(psdEntry)
for i, _ := range psc.InterlockKmGroup {
psc.InterlockKmGroup[i] = false
}
psc.InterlockGM = true
}
return nil
}
// 取消联锁关门
func cancelInterlockGm(wd *component.WorldData, psdEntry *ecs.Entry) error {
if psdEntry.HasComponent(component.PsdCircuitType) { //有联锁区段电路
circuit := component.PsdCircuitType.Get(psdEntry)
return cancelRelayDriveGm(wd, circuit)
} else {
psc := component.PscType.Get(psdEntry)
psc.InterlockGM = false
}
return nil
}
// 设置继电器驱动开门
func setRelayDriveKm(wd *component.WorldData, circuit *component.PsdCircuit, group int32) error {
var params []*component.QdBitParam
params = append(params, component.NewQdBitParam(component.UidType.Get(circuit.GMJ).Id, false))
for g, entry := range circuit.KMJMap {
if g == group {
params = append(params, component.NewQdBitParam(component.UidType.Get(entry).Id, true))
} else {
params = append(params, component.NewQdBitParam(component.UidType.Get(entry).Id, false))
}
}
return wd.SetQdBits(params)
}
// 取消继电器驱动开门
func cancelRelayDriveKm(wd *component.WorldData, circuit *component.PsdCircuit, group int32) error {
var params []*component.QdBitParam
for _, entry := range circuit.KMJMap {
params = append(params, component.NewQdBitParam(component.UidType.Get(entry).Id, false))
}
return wd.SetQdBits(params)
}
// 设置继电器驱动关门
func setRelayDriveGm(wd *component.WorldData, circuit *component.PsdCircuit) error {
var params []*component.QdBitParam
params = append(params, component.NewQdBitParam(component.UidType.Get(circuit.GMJ).Id, true))
for _, entry := range circuit.KMJMap {
params = append(params, component.NewQdBitParam(component.UidType.Get(entry).Id, false))
}
return wd.SetQdBits(params)
}
// 取消继电器驱动关门
func cancelRelayDriveGm(wd *component.WorldData, circuit *component.PsdCircuit) error {
var params []*component.QdBitParam
params = append(params, component.NewQdBitParam(component.UidType.Get(circuit.GMJ).Id, false))
return wd.SetQdBits(params)
}

28
fi/relay.go
View File

@ -66,31 +66,3 @@ func DriveRelayDown(w ecs.World, id string) error {
})
return result.Err
}
// 设置继电器强制故障
func SetRelayFaultForce(w ecs.World, id string, q bool) error {
return updateRelayFault(w, id, func(entry *ecs.Entry) {
component.AddOrUpdateRelayFaultForce(entry, q)
})
}
// 取消继电器强制故障
func CancelRelayFaultForce(w ecs.World, id string) error {
return updateRelayFault(w, id, func(entry *ecs.Entry) {
entry.RemoveComponent(component.RelayFaultForceType)
})
}
func updateRelayFault(w ecs.World, id string, faultHandle func(entry *ecs.Entry)) error {
result := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
entry, ok := wd.EntityMap[id]
if ok {
faultHandle(entry)
} else {
return ecs.NewErrResult(fmt.Errorf("未找到id=%s的继电器", id))
}
return ecs.NewOkEmptyResult()
})
return result.Err
}

238
fi/section.go Normal file
View File

@ -0,0 +1,238 @@
package fi
import (
"fmt"
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/entity"
"strings"
)
// AxleSectionDrstDrive 计轴直接复位操作
//
// set : true-设置，false-取消
func AxleSectionDrstDrive(w ecs.World, sectionId string, set bool) error {
r := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
//
sectionModel := wd.Repo.FindPhysicalSection(sectionId)
if sectionModel == nil {
return ecs.NewErrResult(fmt.Errorf("区段模型[%s]不存实体", sectionId))
}
if set {
axleSectionEntry := wd.EntityMap[sectionId]
if !axleSectionEntry.HasComponent(component.AxleSectionFaultTag) {
return ecs.NewErrResult(fmt.Errorf("区段[%s]非故障占用，无法进行复位操作", sectionId))
}
}
//
faDcAxleDeviceEntry := entity.FindAxleManageDevice(wd, sectionModel.CentralizedStation())
if faDcAxleDeviceEntry == nil {
return ecs.NewErrResult(fmt.Errorf("计轴管理设备[%s]实体不存在", sectionModel.CentralizedStation()))
}
faDcAxleDevice := component.AxleManageDeviceType.Get(faDcAxleDeviceEntry)
axleRuntime := faDcAxleDevice.FindAdr(sectionId)
if axleRuntime == nil {
return ecs.NewErrResult(fmt.Errorf("计轴管理设备[%s]中不存在区段[%s]的计轴设备", sectionModel.CentralizedStation(), sectionId))
}
axleRuntime.Drst = set
//
return ecs.NewOkEmptyResult()
})
return r.Err
}
// AxleSectionPdrstDrive 计轴预复位操作
//
// set : true-设置，false-取消
func AxleSectionPdrstDrive(w ecs.World, sectionId string, set bool) error {
r := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
sectionModel := wd.Repo.FindPhysicalSection(sectionId)
if sectionModel == nil {
return ecs.NewErrResult(fmt.Errorf("区段模型[%s]不存实体", sectionId))
}
if set {
axleSectionEntry := wd.EntityMap[sectionId]
if !axleSectionEntry.HasComponent(component.AxleSectionFaultTag) {
return ecs.NewErrResult(fmt.Errorf("区段[%s]非故障占用，无法进行复位操作", sectionId))
}
}
//
faDcAxleDeviceEntry := entity.FindAxleManageDevice(wd, sectionModel.CentralizedStation())
if faDcAxleDeviceEntry == nil {
return ecs.NewErrResult(fmt.Errorf("计轴管理设备[%s]实体不存在", sectionModel.CentralizedStation()))
}
faDcAxleDevice := component.AxleManageDeviceType.Get(faDcAxleDeviceEntry)
axleRuntime, ok := faDcAxleDevice.Adrs[sectionId]
if !ok {
return ecs.NewErrResult(fmt.Errorf("计轴管理设备[%s]中不存在区段[%s]的计轴设备", sectionModel.CentralizedStation(), sectionId))
}
axleRuntime.Pdrst = set
//
return ecs.NewOkEmptyResult()
})
return r.Err
}
// AxleSectionFaultOccDrive 区段故障占用设置
//
// set : true - 设置故障占用；false - 取消故障占用
func AxleSectionFaultOccDrive(w ecs.World, sectionId string, set bool) error {
r := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
sectionModel := wd.Repo.FindPhysicalSection(sectionId)
if sectionModel == nil {
return ecs.NewErrResult(fmt.Errorf("区段模型[%s]不存实体", sectionId))
}
//
sectionEntry := wd.EntityMap[sectionId]
if sectionEntry == nil {
return ecs.NewErrResult(fmt.Errorf("区段[%s]实体不存在", sectionId))
}
if set { //计轴故障设置
if !sectionEntry.HasComponent(component.AxleSectionFaultTag) {
sectionEntry.AddComponent(component.AxleSectionFaultTag)
}
} else { //计轴故障取消
if sectionEntry.HasComponent(component.AxleSectionFaultTag) {
sectionEntry.RemoveComponent(component.AxleSectionFaultTag)
}
}
//
return ecs.NewOkEmptyResult()
})
return r.Err
}
// AxleSectionTrainDrive 计轴区段内车进入出清设置
//
// trainIn : true - 计轴区段内有车；false-计轴区段出清
func AxleSectionTrainDrive(w ecs.World, sectionId string, trainIn bool) error {
r := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
sectionModel := wd.Repo.FindPhysicalSection(sectionId)
if sectionModel == nil {
return ecs.NewErrResult(fmt.Errorf("区段模型[%s]不存实体", sectionId))
}
//
sectionEntry := wd.EntityMap[sectionId]
if sectionEntry == nil {
return ecs.NewErrResult(fmt.Errorf("区段[%s]实体不存在", sectionId))
}
axleDevice := component.AxlePhysicalSectionType.Get(sectionEntry)
if trainIn {
axleDevice.UpdateCount(1)
} else {
axleDevice.UpdateCount(0)
}
//
return ecs.NewOkEmptyResult()
})
return r.Err
}
// FindAxleSectionsStatus 获取计轴区段的相关状态
func FindAxleSectionsStatus(w ecs.World, sectionIds []string) ([]*AxleSectionState, error) {
r := <-ecs.Request[[]*AxleSectionState](w, func() ecs.Result[[]*AxleSectionState] {
wd := entity.GetWorldData(w)
var msg []*AxleSectionState
var esb = strings.Builder{} //收集未找到的区段的id
for _, sectionId := range sectionIds {
find := false
sectionModel := wd.Repo.FindPhysicalSection(sectionId)
if sectionModel != nil {
faDcAxleDeviceEntry := entity.FindAxleManageDevice(wd, sectionModel.CentralizedStation())
if faDcAxleDeviceEntry != nil {
faDcAxleDevice := component.AxleManageDeviceType.Get(faDcAxleDeviceEntry)
axleDevice := faDcAxleDevice.FindAdr(sectionId)
if axleDevice != nil {
sectionEntry, _ := entity.GetEntityByUid(w, sectionId)
if sectionEntry != nil {
if sectionEntry.HasComponent(component.AxlePhysicalSectionType) { //计轴物理区段实体
as := &AxleSectionState{}
state := component.PhysicalSectionStateType.Get(sectionEntry)
as.Id = component.UidType.Get(sectionEntry).Id
as.Clr = !state.Occ
as.Occ = state.Occ
as.Rac = axleDevice.Rac
as.Rjt = axleDevice.Rjt
as.Rjo = axleDevice.Rjo
//
msg = append(msg, as)
find = true
}
}
}
}
}
//
if !find {
esb.WriteString(fmt.Sprintf("%s,", sectionId))
}
} //for
if esb.Len() > 0 {
return ecs.NewResult(msg, fmt.Errorf("区段非计轴区段或计轴区段状态不存在：[%s]", esb.String()))
} else {
return ecs.NewResult(msg, nil)
}
})
return r.Val, r.Err
}
type AxleSectionState struct {
//uid
Id string
//0-bit7 计轴出清
Clr bool
//0-bit6 计轴占用
Occ bool
//1-bit6 计轴复位反馈
Rac bool
//1-bit5 运营原因拒绝计轴复位
Rjo bool
//1-bit4 技术原因拒绝计轴复位
Rjt bool
}
// AxleSectionRstDrive 复位(直接复位、预复位)
func AxleSectionRstDrive(w ecs.World, cmds []*AxleSectionCmd) error {
r := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
var esb = strings.Builder{} //收集未找到的区段的id
find := false
for _, cmd := range cmds {
sectionId := cmd.SectionId
sectionModel := wd.Repo.FindPhysicalSection(sectionId)
if sectionModel != nil {
faDcAxleDeviceEntry := entity.FindAxleManageDevice(wd, sectionModel.CentralizedStation())
if faDcAxleDeviceEntry != nil {
faDcAxleDevice := component.AxleManageDeviceType.Get(faDcAxleDeviceEntry)
axleRuntime := faDcAxleDevice.FindAdr(sectionId)
if axleRuntime != nil {
axleRuntime.Pdrst = cmd.Pdrst
axleRuntime.Drst = cmd.Drst
find = true
}
}
}
if !find {
esb.WriteString(fmt.Sprintf("%s,", sectionId))
}
} //for
if esb.Len() > 0 {
return ecs.NewErrResult(fmt.Errorf("计轴区段复位操作，失败列表[%s]", esb.String()))
} else {
return ecs.NewOkEmptyResult()
}
})
return r.Err
}
type AxleSectionCmd struct {
SectionId string
Drst bool
Pdrst bool
}

26
fi/signal.go
View File

@ -2,7 +2,6 @@ package fi
import (
"fmt"
"joylink.club/ecs"
"joylink.club/rtsssimulation/component"
"joylink.club/rtsssimulation/component/component_proto"
@ -45,31 +44,6 @@ func UpdateSignalLightFault(w ecs.World, signalId string, light component_proto.
return r.Err
}
// 更新信号机灯丝断丝故障
func UpdateSignalFaultDS(w ecs.World, uid string, light []component_proto.Light_Color) error {
r := <-ecs.Request[ecs.EmptyType](w, func() ecs.Result[ecs.EmptyType] {
wd := entity.GetWorldData(w)
signalEntry, ok := wd.EntityMap[uid]
if ok {
lights := component.SignalLightsType.Get(signalEntry)
// 先清除所有故障
for _, e := range lights.Lights {
e.RemoveComponent(component.LightFaultDsType)
}
// 设置故障
for _, light := range light {
lightEntry := component.SignalLightsType.Get(signalEntry).GetLightByColor(light)
if lightEntry == nil {
return ecs.NewErrResult(fmt.Errorf("信号机[%s]没有色灯[%d]", uid, light))
}
lightEntry.AddComponent(component.LightFaultDsType)
}
}
return ecs.NewOkEmptyResult()
})
return r.Err
}
// SignalLightDrive 当没有电路时，直接驱动信号机灯位上的灯
// ldLights : 需要亮的灯;当为空时则信号机所有色灯灭灯
func SignalLightDrive(w ecs.World, signalId string, ldLights ...component_proto.Light_Color) error {

12
fi/train.go
View File

@ -99,18 +99,6 @@ type TrainHeadPositionInfo struct {
Speed float32
//加速度(m/s^2)
Acceleration float32
//列车上一次所在轨道link
OldLink string
//列车上一次车头位置信息
OldLinkOffset int64
TailUp bool
TailLink string
//列车上一次车头位置信息
TailLinkOffset int64
OldTailLink string
//列车上一次车头位置信息
OldTailLinkOffset int64
IsLine12 bool
}
func (t *TrainHeadPositionInfo) String() string {

15
go.mod
View File

@ -3,19 +3,18 @@ module joylink.club/rtsssimulation
go 1.21
require (
github.com/stretchr/testify v1.8.4
google.golang.org/protobuf v1.32.0
github.com/stretchr/testify v1.8.3
google.golang.org/protobuf v1.31.0
joylink.club/ecs v0.0.1
)
replace joylink.club/ecs => ./jl-ecs
replace joylink.club/ecs => ./jl-ecs-go
require (
github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
github.com/google/go-cmp v0.6.0 // indirect
github.com/kr/pretty v0.3.1 // indirect
github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/google/go-cmp v0.5.9 // indirect
github.com/kr/text v0.2.0 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/yohamta/donburi v1.3.9 // indirect
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
)

26
go.sum
View File

@ -1,16 +1,26 @@
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/yohamta/donburi v1.3.9 h1:sYAPaelSnxmoTGjgH9ZlYt4pUKrnwvAv4YGXxLZCK6E=
github.com/yohamta/donburi v1.3.9/go.mod h1:5QkyraUjkzbMVTD2b8jaPFy1Uwjm/zdFN1c1lZGaezg=
google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

2
go.work
View File

@ -2,5 +2,5 @@ go 1.21
use (
.
./jl-ecs
./jl-ecs-go
)

27
go.work.sum
View File

@ -1,47 +1,28 @@
github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
github.com/creack/pty v1.1.9 h1:uDmaGzcdjhF4i/plgjmEsriH11Y0o7RKapEf/LDaM3w=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/ebitengine/purego v0.0.0-20220905075623-aeed57cda744/go.mod h1:Eh8I3yvknDYZeCuXH9kRNaPuHEwvXDCk378o9xszmHg=
github.com/ebitengine/purego v0.1.0 h1:vAEo1FvmbjA050QKsbDbcHj03hhMMvh0fmr9LSehpnU=
github.com/ebitengine/purego v0.1.0/go.mod h1:Eh8I3yvknDYZeCuXH9kRNaPuHEwvXDCk378o9xszmHg=
github.com/go-gl/glfw/v3.3/glfw v0.0.0-20220806181222-55e207c401ad h1:kX51IjbsJPCvzV9jUoVQG9GEUqIq5hjfYzXTqQ52Rh8=
github.com/go-gl/glfw/v3.3/glfw v0.0.0-20220806181222-55e207c401ad/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
github.com/golang/protobuf v1.5.0 h1:LUVKkCeviFUMKqHa4tXIIij/lbhnMbP7Fn5wKdKkRh4=
github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/hajimehoshi/bitmapfont/v2 v2.2.2/go.mod h1:Ua/x9Dkz7M9CU4zr1VHWOqGwjKdXbOTRsH7lWfb1Co0=
github.com/hajimehoshi/ebiten/v2 v2.4.13 h1:ZZ5y+bFkAbUeD2WGquHF+xSbg83SIbcsxCwEVeZgHWM=
github.com/hajimehoshi/ebiten/v2 v2.4.13/go.mod h1:BZcqCU4XHmScUi+lsKexocWcf4offMFwfp8dVGIB/G4=
github.com/hajimehoshi/file2byteslice v0.0.0-20210813153925-5340248a8f41/go.mod h1:CqqAHp7Dk/AqQiwuhV1yT2334qbA/tFWQW0MD2dGqUE=
github.com/hajimehoshi/file2byteslice v1.0.0 h1:ljd5KTennqyJ4vG9i/5jS8MD1prof97vlH5JOdtw3WU=
github.com/hajimehoshi/file2byteslice v1.0.0/go.mod h1:CqqAHp7Dk/AqQiwuhV1yT2334qbA/tFWQW0MD2dGqUE=
github.com/hajimehoshi/go-mp3 v0.3.3/go.mod h1:qMJj/CSDxx6CGHiZeCgbiq2DSUkbK0UbtXShQcnfyMM=
github.com/hajimehoshi/oto v0.6.1/go.mod h1:0QXGEkbuJRohbJaxr7ZQSxnju7hEhseiPx2hrh6raOI=
github.com/hajimehoshi/oto/v2 v2.3.1/go.mod h1:seWLbgHH7AyUMYKfKYT9pg7PhUu9/SisyJvNTT+ASQo=
github.com/jakecoffman/cp v1.2.1/go.mod h1:JjY/Fp6d8E1CHnu74gWNnU0+b9VzEdUVPoJxg2PsTQg=
github.com/jezek/xgb v1.0.1 h1:YUGhxps0aR7J2Xplbs23OHnV1mWaxFVcOl9b+1RQkt8=
github.com/jezek/xgb v1.0.1/go.mod h1:nrhwO0FX/enq75I7Y7G8iN1ubpSGZEiA3v9e9GyRFlk=
github.com/jfreymuth/oggvorbis v1.0.4/go.mod h1:1U4pqWmghcoVsCJJ4fRBKv9peUJMBHixthRlBeD6uII=
github.com/jfreymuth/vorbis v1.0.2/go.mod h1:DoftRo4AznKnShRl1GxiTFCseHr4zR9BN3TWXyuzrqQ=
github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
github.com/kr/pty v1.1.1 h1:VkoXIwSboBpnk99O/KFauAEILuNHv5DVFKZMBN/gUgw=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8/go.mod h1:HKlIX3XHQyzLZPlr7++PzdhaXEj94dEiJgZDTsxEqUI=
github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e h1:aoZm08cpOy4WuID//EZDgcC4zIxODThtZNPirFr42+A=
github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/yuin/goldmark v1.4.0/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
go.uber.org/goleak v1.2.0/go.mod h1:XJYK+MuIchqpmGmUSAzotztawfKvYLUIgg7guXrwVUo=
@ -50,16 +31,13 @@ golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8U
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20190731235908-ec7cb31e5a56 h1:estk1glOnSVeJ9tdEZZc5mAMDZk5lNJNyJ6DvrBkTEU=
golang.org/x/exp v0.0.0-20190731235908-ec7cb31e5a56/go.mod h1:JhuoJpWY28nO4Vef9tZUw9qufEGTyX1+7lmHxV5q5G4=
golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
golang.org/x/image v0.1.0 h1:r8Oj8ZA2Xy12/b5KZYj3tuv7NG/fBz3TwQVvpJ9l8Rk=
golang.org/x/image v0.1.0/go.mod h1:iyPr49SD/G/TBxYVB/9RRtGUT5eNbo2u4NamWeQcD5c=
golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
golang.org/x/mobile v0.0.0-20190415191353-3e0bab5405d6/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
golang.org/x/mobile v0.0.0-20220722155234-aaac322e2105/go.mod h1:pe2sM7Uk+2Su1y7u/6Z8KJ24D7lepUjFZbhFOrmDfuQ=
golang.org/x/mobile v0.0.0-20221012134814-c746ac228303 h1:K4fp1rDuJBz0FCPAWzIJwnzwNEM7S6yobdZzMrZ/Zws=
golang.org/x/mobile v0.0.0-20221012134814-c746ac228303/go.mod h1:M32cGdzp91A8Ex9qQtyZinr19EYxzkFqDjW2oyHzTDQ=
golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
@ -87,7 +65,6 @@ golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBc
golang.org/x/sys v0.0.0-20220712014510-0a85c31ab51e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220818161305-2296e01440c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20221013171732-95e765b1cc43 h1:OK7RB6t2WQX54srQQYSXMW8dF5C6/8+oA/s5QBmmto4=
golang.org/x/sys v0.0.0-20221013171732-95e765b1cc43/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
@ -103,9 +80,5 @@ golang.org/x/tools v0.1.8-0.20211022200916-316ba0b74098/go.mod h1:LGqMHiF4EqQNHR
golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

16
init.go
View File

@ -3,14 +3,13 @@ package rtss_simulation
import (
"joylink.club/ecs"
"joylink.club/rtsssimulation/entity"
"joylink.club/rtsssimulation/modelrepo"
"joylink.club/rtsssimulation/repository"
"joylink.club/rtsssimulation/sys"
)
const (
// 仿真循环间隔，单位ms
RtssSimulationTick = 10
RtssSimulationTick = 20
)
// 初始化仿真
@ -20,16 +19,3 @@ func NewSimulation(repo *repository.Repository) (ecs.World, error) {
err := entity.Load(w, repo)
return w, err
}
// 加载城轨仿真
func LoadCgSimulation(repo modelrepo.Repo) (ecs.World, error) {
w := ecs.NewWorld(RtssSimulationTick)
// 加载组件实体
err := entity.Loading(w, repo)
if err != nil {
return nil, err
}
// 加载系统
sys.BindSystem(w)
return w, err
}

1
jl-ecs

@ -1 +0,0 @@
Subproject commit f0a56ea6722b620c8b900efa9f0d626f00af00ad

1
jl-ecs-go Submodule

@ -0,0 +1 @@
Subproject commit bd947baa4edadb6b7bd059f6e324fb20f8171f8f

23
modelrepo/check_test.go
View File

@ -1,23 +0,0 @@
package modelrepo
import "testing"
func TestIsFieldEmpty(t *testing.T) {
tests := []struct {
give any
want bool
}{
{give: nil, want: true},
{give: "", want: true},
{give: 0, want: true},
{give: []string{}, want: true},
{give: map[string]string{}, want: true},
{give: []int{}, want: true},
}
for _, tt := range tests {
if got := isFieldEmpty(tt.give); got != tt.want {
t.Errorf("IsFieldEmpty(%v) = %v, want = %v", tt.give, got, tt.want)
}
}
}

4060
modelrepo/dto/cg_repo.pb.go
View File

File diff suppressed because it is too large Load Diff

25
modelrepo/error_record.go
View File

@ -1,25 +0,0 @@
package modelrepo
// 构建错误记录
type ErrorRecord struct {
// 告警信息
Warns []string
// 错误信息
Errs []string
}
func NewErrorRecord() *ErrorRecord {
return &ErrorRecord{}
}
func (r *ErrorRecord) AddError(err string) {
r.Errs = append(r.Errs, err)
}
func (r *ErrorRecord) HasError() bool {
return len(r.Errs) > 0
}
func (r *ErrorRecord) AddWarn(warn string) {
r.Warns = append(r.Warns, warn)
}

468
modelrepo/idmapping_build.go
View File

@ -1,468 +0,0 @@
package modelrepo
import (
"fmt"
"reflect"
"strconv"
"strings"
"joylink.club/rtsssimulation/modelrepo/dto"
)
// 城轨uid
type CgUid struct {
// 城市
city string
// 线路
line string
// 设备编号
codes []string
// codestr
codestr string
// uid
idstr string
}
func NewCgUid(city string, line string, codes ...string) *CgUid {
if city == "" || line == "" {
panic(fmt.Errorf("创建城轨uid错误: 城市、线路、车站不能为空 city=%s, line=%s", city, line))
}
l := len(codes)
if l == 0 {
panic(fmt.Errorf("创建城轨uid错误: codes不能为空"))
}
codestr := strings.Join(codes, "_")
elems := []string{city, line, codestr}
uid := strings.Join(elems, "_")
return &CgUid{
city: city,
line: line,
codes: codes,
codestr: codestr,
idstr: uid,
}
}
func (u *CgUid) Id() string {
return u.idstr
}
func (u *CgUid) Code() string {
return u.codestr
}
type idMap struct {
// 数据id
Did string
// 元素id
Eid uint32
// 唯一id
Uid *CgUid
}
func NewIdMap(did string, eid uint32, uid *CgUid) *idMap {
return &idMap{
Did: did,
Eid: eid,
Uid: uid,
}
}
func (m *idMap) DeId() string {
return DeID(m.Did, m.Eid)
}
func (m *idMap) Debug() string {
return fmt.Sprintf("{数据id=%s, 元素id=%v, uid=%s}", m.Did, m.Eid, m.Uid.Id())
}
// 数据元素id key生成
// did - 数据id
// eid - 元素id
func DeID(did string, eid uint32) string {
return fmt.Sprintf("%s_%v", did, eid)
}
// id映射表
type IdMapping struct {
// 数据元素id映射
deidMap map[string]*idMap
// uid映射(只存储最初的idMap,实际中一个uid可能对应多个数据元素id)
uidMap map[string]*idMap
}
func (m *IdMapping) queryByDeId(deid string) *idMap {
return m.deidMap[deid]
}
func (m *IdMapping) queryByDidAndEid(did string, eid uint32) *idMap {
id := DeID(did, eid)
return m.deidMap[id]
}
func (m *IdMapping) add(idmap *idMap) {
if idmap == nil {
panic(fmt.Errorf("添加id映射表错误: idmap不能为空"))
}
m.deidMap[idmap.DeId()] = idmap
}
func (m *IdMapping) checkUidAndAdd(idmap *idMap) (existed *idMap, uidExisted bool) {
if idmap == nil {
panic(fmt.Errorf("添加id映射表错误: idmap不能为空"))
}
m.deidMap[idmap.DeId()] = idmap
existed, ok := m.uidMap[idmap.Uid.Id()]
if ok {
uidExisted = true
} else {
m.uidMap[idmap.Uid.Id()] = idmap
}
return
}
// 构建城轨id映射
func BuildIdMapping(msgs *dto.CgRepo, errRecord *ErrorRecord) *IdMapping {
if msgs == nil {
errRecord.AddError("构建城轨id映射表错误: 未关联任何数据")
return nil
}
idMapping := &IdMapping{
deidMap: make(map[string]*idMap),
uidMap: make(map[string]*idMap),
}
lineSet := make(map[string]struct{})
for _, l := range msgs.Lines {
if _, ok := lineSet[l.City+l.LineId]; ok {
errRecord.AddError(fmt.Sprintf("构建城轨id映射表错误: 线路重复:%s_%s", l.City, l.LineId))
return nil
}
lineSet[l.City+l.LineId] = struct{}{}
}
for _, line := range msgs.Lines {
buildXhbz(idMapping, line, errRecord)
if errRecord.HasError() {
return nil
}
}
return idMapping
}
// 构建信号布置数据id映射
func buildXhbz(idMapping *IdMapping, line *dto.Line, errRecord *ErrorRecord) {
xhbz := line.Xhbz
if xhbz == nil {
errRecord.AddError("构建城轨id映射表错误: 信号布置数据为空")
return
}
city := line.City // 城市
lineId := line.LineId // 线路id
did := xhbz.Id // 数据id
errPrefix := "信号布置数据错误"
// 车站uid
for _, station := range xhbz.Stations {
eid := station.Id
if checkFieldEmpty(did, eid, station.Name, errPrefix, "车站名称", errRecord) {
continue
}
idmap := NewIdMap(did, eid, NewCgUid(city, lineId, station.Name))
if checkRepeatOrAddIdMap(idmap, idMapping, errPrefix, errRecord) {
continue
}
}
// 车站站台uid
for _, p := range xhbz.Platforms {
eid := p.Id
if checkFieldEmpty(did, eid, p.Code, errPrefix, "站台编号", errRecord) {
continue
}
if checkFieldEmpty(did, eid, p.StationId, errPrefix, "站台关联车站", errRecord) {
continue
}
stationIdm := idMapping.queryByDidAndEid(did, p.StationId)
if checkRelationNil(did, eid, p.StationId, stationIdm, errPrefix, "站台关联车站", errRecord) {
continue
}
// 站台code: 车站名称_站台编号
idmap := NewIdMap(did, eid, NewCgUid(city, lineId, stationIdm.Uid.Code(), p.Code))
if checkRepeatOrAddIdMap(idmap, idMapping, errPrefix, errRecord) {
continue
}
}
// 屏蔽门uid
for _, p := range xhbz.Psds {
eid := p.Id
if checkFieldEmpty(did, eid, p.Code, errPrefix, "屏蔽门编号", errRecord) {
continue
}
if checkFieldEmpty(did, eid, p.PlatformId, errPrefix, "屏蔽门关联站台", errRecord) {
continue
}
relIdMap := idMapping.queryByDidAndEid(did, p.PlatformId)
if checkRelationNil(did, eid, p.PlatformId, relIdMap, errPrefix, "屏蔽门关联站台", errRecord) {
continue
}
// 屏蔽门code: 站台编号_屏蔽门编号
idmap := NewIdMap(did, eid, NewCgUid(city, lineId, relIdMap.Uid.Code(), p.Code))
if checkRepeatOrAddIdMap(idmap, idMapping, errPrefix, errRecord) {
continue
}
}
// 物理区段
for _, ps := range xhbz.Sections {
eid := ps.Id
if checkFieldEmpty(did, eid, ps.Code, errPrefix, "物理区段编号", errRecord) {
continue
}
if checkFieldEmpty(did, eid, ps.EcsId, errPrefix, "物理区段关联集中站", errRecord) {
continue
}
relIdMap := idMapping.queryByDidAndEid(did, ps.EcsId)
if checkRelationNil(did, eid, ps.EcsId, relIdMap, errPrefix, "物理区段关联集中站", errRecord) {
continue
}
// 物理区段code: 集中站名称_物理区段编号
idmap := NewIdMap(did, eid, NewCgUid(city, lineId, relIdMap.Uid.Code(), ps.Code))
if checkRepeatOrAddIdMap(idmap, idMapping, errPrefix, errRecord) {
continue
}
}
// 道岔uid
for _, t := range xhbz.Turnouts {
eid := t.Id
if checkFieldEmpty(did, eid, t.Code, errPrefix, "道岔编号", errRecord) {
continue
}
if checkFieldEmpty(did, eid, t.EcsId, errPrefix, "道岔关联集中站", errRecord) {
continue
}
relIdMap := idMapping.queryByDidAndEid(did, t.EcsId)
if checkRelationNil(did, eid, t.EcsId, relIdMap, errPrefix, "道岔关联集中站", errRecord) {
continue
}
// 道岔code: 集中站名称_道岔编号
idmap := NewIdMap(did, eid, NewCgUid(city, lineId, relIdMap.Uid.Code(), t.Code))
if checkRepeatOrAddIdMap(idmap, idMapping, errPrefix, errRecord) {
continue
}
}
// 区段分界点uid
for _, c := range xhbz.DevidingPoints {
eid := c.Id
if checkFieldEmpty(did, eid, c.Code, errPrefix, "区段分界点编号", errRecord) {
continue
}
if checkFieldEmpty(did, eid, c.EcsIds, errPrefix, "区段分界点关联集中站", errRecord) {
continue
}
ecsErr := false
for _, v := range c.EcsIds {
relIdMap := idMapping.queryByDidAndEid(did, v)
if checkRelationNil(did, eid, v, relIdMap, errPrefix, "区段分界点关联集中站", errRecord) {
ecsErr = true
continue
}
}
if ecsErr {
continue
}
idmap := NewIdMap(did, eid, NewCgUid(city, lineId, c.Code))
if checkRepeatOrAddIdMap(idmap, idMapping, errPrefix, errRecord) {
continue
}
}
// 信号机uid
for _, s := range xhbz.Signals {
eid := s.Id
if checkFieldEmpty(did, eid, s.Code, errPrefix, "信号机编号", errRecord) {
continue
}
if checkFieldEmpty(did, eid, s.EcsId, errPrefix, "信号机关联集中站", errRecord) {
continue
}
relIdMap := idMapping.queryByDidAndEid(did, s.EcsId)
if checkRelationNil(did, eid, s.EcsId, relIdMap, errPrefix, "信号机关联集中站", errRecord) {
continue
}
idmap := NewIdMap(did, eid, NewCgUid(city, lineId, relIdMap.Uid.Code(), s.Code))
if checkRepeatOrAddIdMap(idmap, idMapping, errPrefix, errRecord) {
continue
}
}
// 应答器uid
for _, b := range xhbz.Balises {
eid := b.Id
if checkFieldEmpty(did, eid, b.Code, errPrefix, "应答器编号", errRecord) {
continue
}
if checkFieldEmpty(did, eid, b.EcsId, errPrefix, "应答器关联集中站", errRecord) {
continue
}
relIdMap := idMapping.queryByDidAndEid(did, b.EcsId)
if checkRelationNil(did, eid, b.EcsId, relIdMap, errPrefix, "应答器关联集中站", errRecord) {
continue
}
idmap := NewIdMap(did, eid, NewCgUid(city, lineId, relIdMap.Uid.Code(), b.Code))
if checkRepeatOrAddIdMap(idmap, idMapping, errPrefix, errRecord) {
continue
}
}
// 停车点
for _, ps := range xhbz.ParkingSpots {
idmap := NewIdMap(did, ps.Id, NewCgUid(city, lineId, did, strconv.Itoa(int(ps.Id))))
if checkRepeatOrAddIdMap(idmap, idMapping, errPrefix, errRecord) {
continue
}
}
// 坡度
for _, v := range xhbz.Pds {
idmap := NewIdMap(did, v.Id, NewCgUid(city, lineId, did, strconv.Itoa(int(v.Id))))
if checkRepeatOrAddIdMap(idmap, idMapping, errPrefix, errRecord) {
continue
}
}
// 曲度
for _, v := range xhbz.Qds {
idmap := NewIdMap(did, v.Id, NewCgUid(city, lineId, did, strconv.Itoa(int(v.Id))))
if checkRepeatOrAddIdMap(idmap, idMapping, errPrefix, errRecord) {
continue
}
}
// 紧急停车按钮
for _, v := range xhbz.Emps {
eid := v.Id
if checkFieldEmpty(did, eid, v.Code, errPrefix, "紧急停车按钮编号", errRecord) {
continue
}
if checkFieldEmpty(did, eid, v.PlatformId, errPrefix, "紧急停车按钮关联站台", errRecord) {
continue
}
relIdMap := idMapping.queryByDidAndEid(did, v.PlatformId)
if checkRelationNil(did, eid, v.PlatformId, relIdMap, errPrefix, "紧急停车按钮关联站台", errRecord) {
continue
}
idmap := NewIdMap(did, eid, NewCgUid(city, lineId, relIdMap.Uid.Code(), v.Code))
if checkRepeatOrAddIdMap(idmap, idMapping, errPrefix, errRecord) {
continue
}
}
// 停车倒计时器
for _, v := range xhbz.Tdts {
eid := v.Id
if checkFieldEmpty(did, eid, v.Code, errPrefix, "停车倒计时器编号", errRecord) {
continue
}
if checkFieldEmpty(did, eid, v.PlatformId, errPrefix, "停车倒计时器关联站台", errRecord) {
continue
}
relIdMap := idMapping.queryByDidAndEid(did, v.PlatformId)
if checkRelationNil(did, eid, v.PlatformId, relIdMap, errPrefix, "停车倒计时器关联站台", errRecord) {
continue
}
idmap := NewIdMap(did, eid, NewCgUid(city, lineId, relIdMap.Uid.Code(), v.Code))
if checkRepeatOrAddIdMap(idmap, idMapping, errPrefix, errRecord) {
continue
}
}
// 门控箱
for _, v := range xhbz.Mkxs {
eid := v.Id
if checkFieldEmpty(did, eid, v.Code, errPrefix, "门控箱编号", errRecord) {
continue
}
if checkFieldEmpty(did, eid, v.PsdId, errPrefix, "门控箱关联屏蔽门", errRecord) {
continue
}
relIdMap := idMapping.queryByDidAndEid(did, v.PsdId)
if checkRelationNil(did, eid, v.PsdId, relIdMap, errPrefix, "门控箱关联屏蔽门", errRecord) {
continue
}
idmap := NewIdMap(did, eid, NewCgUid(city, lineId, relIdMap.Uid.Code(), v.Code))
if checkRepeatOrAddIdMap(idmap, idMapping, errPrefix, errRecord) {
continue
}
}
// PSL
for _, v := range xhbz.Psls {
eid := v.Id
if checkFieldEmpty(did, eid, v.Code, errPrefix, "PSL编号", errRecord) {
continue
}
if checkFieldEmpty(did, eid, v.PsdId, errPrefix, "PSL关联屏蔽门", errRecord) {
continue
}
relIdMap := idMapping.queryByDidAndEid(did, v.PsdId)
if checkRelationNil(did, eid, v.PsdId, relIdMap, errPrefix, "PSL关联屏蔽门", errRecord) {
continue
}
idmap := NewIdMap(did, eid, NewCgUid(city, lineId, relIdMap.Uid.Code(), v.Code))
if checkRepeatOrAddIdMap(idmap, idMapping, errPrefix, errRecord) {
continue
}
}
// SPKS
for _, v := range xhbz.Spks {
eid := v.Id
if checkFieldEmpty(did, eid, v.Code, errPrefix, "SPKS编号", errRecord) {
continue
}
if checkFieldEmpty(did, eid, v.PlatformId, errPrefix, "SPKS关联站台", errRecord) {
continue
}
relIdMap := idMapping.queryByDidAndEid(did, v.PlatformId)
if checkRelationNil(did, eid, v.PlatformId, relIdMap, errPrefix, "SPKS关联站台", errRecord) {
continue
}
idmap := NewIdMap(did, eid, NewCgUid(city, lineId, relIdMap.Uid.Code(), v.Code))
if checkRepeatOrAddIdMap(idmap, idMapping, errPrefix, errRecord) {
continue
}
}
}
func checkRelationNil(did string, eid uint32, relId uint32, relIdMap *idMap, prefix string, relTip string, errRecord *ErrorRecord) bool {
if relIdMap == nil {
errRecord.AddError(fmt.Sprintf("%s: %s不存在, 数据id=%s 数据元素id=%v 关联id=%v", prefix, relTip, did, eid, relId))
return true
}
return false
}
// 检查字段是否为空
func checkFieldEmpty(did string, eid uint32, field any, prefix string, tip string, errRecord *ErrorRecord) bool {
if isFieldEmpty(field) {
errRecord.AddError(fmt.Sprintf("%s: %s不能为空, 数据id=%s 数据元素id=%v ", prefix, tip, did, eid))
return true
}
return false
}
func isFieldEmpty(field any) bool {
if field == nil {
return true
}
vf := reflect.ValueOf(field)
switch vf.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
reflect.Float32, reflect.Float64:
return field == 0
case reflect.String:
return field == ""
case reflect.Slice, reflect.Map:
return vf.Len() == 0
}
return false
}
// 数据uid/deid重复检查
func checkRepeatOrAddIdMap(idm *idMap, idMapping *IdMapping, prefix string, errRecord *ErrorRecord) (repeated bool) {
if old := idMapping.queryByDeId(idm.DeId()); old != nil {
errRecord.AddError(fmt.Sprintf("%s,数据元素重复: 数据1=%s 数据2=%s,", prefix, old.Debug(), idm.Debug()))
repeated = true
} else if old, _ := idMapping.checkUidAndAdd(idm); old != nil {
errRecord.AddError(fmt.Sprintf("%s,数据重复: 数据1=%s 数据2=%s,", prefix, old.Debug(), idm.Debug()))
repeated = true
}
return
}

57
modelrepo/manage.go
View File

@ -1,57 +0,0 @@
package modelrepo
import "sync"
// Repo管理
type repoManager struct {
repoMap map[string]Repo
lock sync.Mutex
}
var defaultManager = &repoManager{
repoMap: make(map[string]Repo),
}
// 获取Repo
func GetRepo(id string) Repo {
manager := defaultManager
manager.lock.Lock()
defer manager.lock.Unlock()
r, ok := manager.repoMap[id]
if !ok {
return nil
}
return r
}
// 保存Repo
func SaveRepo(r Repo) {
manager := defaultManager
manager.lock.Lock()
defer manager.lock.Unlock()
manager.repoMap[r.Id()] = r
}
// 移除Repo
func RemoveRepo(id string) {
manager := defaultManager
manager.lock.Lock()
defer manager.lock.Unlock()
delete(manager.repoMap, id)
}
// 获取或构建Repo,若存在则返回已存在的,若不存在则构建保存并返回
func GetOrBuildRepo(id string, builder func() (Repo, error)) (Repo, error) {
r := GetRepo(id)
if r == nil {
// 构建模型Repo
r, err := builder()
// 构建出错直接返回
if err != nil {
return nil, err
}
// 保存
SaveRepo(r)
}
return r, nil
}

34
modelrepo/model/common.go
View File

@ -1,34 +0,0 @@
package model
type ModelType string
const (
// 车站
ModelType_Station ModelType = "Station"
// 站台
ModelType_Stand ModelType = "Stand"
// 屏蔽门
ModelType_PSD ModelType = "PSD"
// Link
ModelType_Link ModelType = "Link"
// 区段
ModelType_Section ModelType = "Section"
// 道岔
ModelType_Turnout ModelType = "Turnout"
// 信号机
ModelType_Signal ModelType = "Signal"
// 应答器
ModelType_Balise ModelType = "Balise"
)
type Uid interface {
Id() string
}
// 模型接口
type Model interface {
// Unique id,唯一id
Uid() Uid
// 模型类型
Type() ModelType
}

22
modelrepo/model/elec_comp.go
View File

@ -1,22 +0,0 @@
package model
// 开关
type PowerSwitch interface {
Model
// 编号
Code()
}
// 信号状态表示灯
type Lamp interface {
Model
// 编号
Code()
}
// 蜂鸣器/报警电铃
type Buzzer interface {
Model
// 编号
Code()
}

12
modelrepo/model/ibp.go
View File

@ -1,12 +0,0 @@
package model
// IBP盘(综合后备盘)
type Ibp interface {
Model
// 获取所有开关
GetPowerSwitches() []PowerSwitch
// 获取所有信号状态表示灯
GetLamps() []Lamp
// 获取所有蜂鸣器
GetBuzzer() []Buzzer
}

141
modelrepo/model/link.go
View File

@ -1,141 +0,0 @@
package model
import "log/slog"
// link端口
type Link_Port int
const (
LinkPort_A Link_Port = -1
LinkPort_B Link_Port = 1
)
// Link
type Link interface {
Model
// Link总长度
GetLength() int64
// 获取端口A关联的道岔
GetPaTurnout() Points
// 获取端口B关联的道岔
GetPbTurnout() Points
// 下一个link及端口
// port - 当前link端口
// tpos - 当前道岔位置
Next(port Link_Port, tpos PointsPosition) *LinkPort
}
type LinkPort struct {
link Link
port Link_Port
}
func NewLinkPort(link Link, port Link_Port) *LinkPort {
return &LinkPort{
link: link,
port: port,
}
}
// link偏移位置
// 默认linkA端口偏移为0，从A到B为增大，从B到A为减小
type LinkOffset struct {
link Link
offset int64 // 偏移坐标,link相当于一个一维坐标系,以端口A为原点
}
// 创建link偏移位置,若offset超出link长度则返回nil
func NewLinkOffset(link Link, offset int64) *LinkOffset {
if offset < 0 || offset > link.GetLength() {
return nil
}
return &LinkOffset{
link: link,
offset: offset,
}
}
func (l *LinkOffset) Link() Link {
return l.link
}
func (l *LinkOffset) Offset() int64 {
return l.offset
}
// link偏移范围
type LinkRange struct {
link Link
start int64
end int64
}
func NewLinkRange(link Link, a int64, b int64) *LinkRange {
if a < 0 || a > link.GetLength() {
slog.Error("创建link偏移范围失败: 超出link长度范围", slog.Int64("a", a))
return nil
} else if b < 0 || b > link.GetLength() {
slog.Error("创建link偏移范围失败: 超出link长度范围", slog.Int64("b", b))
return nil
}
var start int64
var end int64
if a > b {
start = b
end = a
} else {
start = a
end = b
}
return &LinkRange{
link: link,
start: start,
end: end,
}
}
// 是否相交
func (l *LinkRange) IsIntersect(other *LinkRange) bool {
if l.link != other.link {
return false
}
if l.start > other.end || other.start > l.end {
return false
}
return true
}
// 是否相交
func (l *LinkRange) IsIntersect2(a, b int64) bool {
var start int64
var end int64
if a > b {
start = b
end = a
} else {
start = a
end = b
}
if start > l.end || end < l.start {
return false
}
return true
}
// 是否在范围内
func (l *LinkRange) IsInRange(lo *LinkOffset) bool {
if lo.link != l.link {
return false
}
if lo.offset < l.start || lo.offset > l.end {
return false
}
return true
}
// 偏移坐标是否在范围内
func (l *LinkRange) IsInRange2(offset int64) bool {
if offset < l.start || offset > l.end {
return false
}
return true
}

6
modelrepo/model/psd.go
View File

@ -1,6 +0,0 @@
package model
// 站台屏蔽门
type Psd interface {
Model
}

32
modelrepo/model/relay.go
View File

@ -1,32 +0,0 @@
package model
// 继电器位置
type Relay_Position int
const (
// 继电器位置-后(表示落下/反位)
RelayPos_H Relay_Position = 0
// 继电器位置-前(表示吸起/定位)
RelayPos_Q Relay_Position = 1
)
// 继电器型号
type Relay_Model int
const (
RelayModel_JPXC_1000 Relay_Model = 1
RelayModel_JPXC_1700 Relay_Model = 2
RelayModel_JWJXC_480 Relay_Model = 3
RelayModel_JWJXC_H125_80 Relay_Model = 4
RelayModel_JWXC_1700 Relay_Model = 5
RelayModel_JWXC_H340 Relay_Model = 6
RelayModel_JYJXC_160_260 Relay_Model = 7
RelayModel_JZXC_H18 Relay_Model = 8
)
// 继电器
type Relay interface {
Model
Code()
Model() Relay_Model
}

21
modelrepo/model/section.go
View File

@ -1,21 +0,0 @@
package model
type Section interface {
Model
Code() string
// 所在Link范围
LinkRanges() []*LinkRange
}
// 物理区段(实际检测区段)
type PhysicalSection interface {
Section
LogicalSections() []LogicalSection
}
// 逻辑区段
type LogicalSection interface {
Section
// 物理区段
Parent() PhysicalSection
}

6
modelrepo/model/signal.go
View File

@ -1,6 +0,0 @@
package model
// 信号机
type Signal interface {
Model
}

48
modelrepo/model/station.go
View File

@ -1,48 +0,0 @@
package model
// 车站
type Station interface {
Model
// 车站名
Name() string
// 是否设备集中站
IsEcs() bool
// 获取IBP
GetIbp() Ibp
}
// 设备集中站(Equipment centralized station)
type EcStation interface {
Station
// 获取所有道岔
GetTurnouts() []Points
// 获取所有信号机
GetSignals() []Signal
// 获取所有站台屏蔽门
GetPsds() []Psd
// 获取所有物理检测区段
GetPhysicalSections() []PhysicalSection
// 获取联锁驱采表
GetCiQCTable()
}
// 联锁驱采表
type CiQCTable interface {
// 驱动码位表(每一位所驱动的继电器uid)
QD() []string
// 采集码位表(每一位所采集的继电器位置)
CJ() []CiCJ
}
// 联锁采集
type CiCJ interface {
CjPos() []CiCJPos
}
// 联锁采集继电器位置
type CiCJPos interface {
// 继电器uid
RelayId() string
// 继电器位置
Pos() Relay_Position
}

47
modelrepo/model/turnout.go
View File

@ -1,47 +0,0 @@
package model
// 道岔位置
type PointsPosition int
const (
// 失表
TPos_Lost PointsPosition = 0
// 定位
TPos_DW PointsPosition = 1
// 反位
TPos_FW PointsPosition = 2
)
// 道岔端口
type Turnout_Port int
const (
TPort_A Turnout_Port = 1
TPort_B Turnout_Port = 2
TPort_C Turnout_Port = 3
)
// 道岔牵引类型
type PointsTractionType int
const (
// ZDJ9单机牵引
PTT_ZDJ9_1 PointsTractionType = 1
// ZDJ9双机牵引
PTT_ZDJ9_2 PointsTractionType = 2
)
// 道岔
type Points interface {
Model
// 获取A方向连接的link端口
GetALinkPort() *LinkPort
// 获取B方向连接的link端口
GetBLinkPort() *LinkPort
// 获取C方向连接的link端口
GetCLinkPort() *LinkPort
// 获取牵引类型
GetTractionType() PointsTractionType
// 获取转辙机数量
GetZzjCount() int
}

72
modelrepo/model_impl/link.go
View File

@ -1,72 +0,0 @@
package modelimpl
import (
"sync/atomic"
"joylink.club/rtsssimulation/modelrepo/dto"
"joylink.club/rtsssimulation/modelrepo/model"
)
// link生成uid基础值
var link_uid_base = atomic.Uint32{}
var _link model.Link = (*Link)(nil)
// 轨道链路
type Link struct {
uid model.Uid
PaTurnout *Turnout // A端关联道岔,可能为nil
PbTurnout *Turnout // B端关联道岔,可能为nil
PaGlb dto.GLB // A端公里标
PbGlb dto.GLB // B端公里标
Length int64 // 长度
Models []model.Model // 关联的模型,从A到B排序
Sections []*PhysicalSection // 关联的物理区段(包含道岔物理区段),从A到B排序
}
// GetLength implements model.Link.
func (l *Link) GetLength() int64 {
return l.Length
}
// GetPaTurnout implements model.Link.
func (l *Link) GetPaTurnout() model.Points {
return l.PaTurnout
}
// GetPbTurnout implements model.Link.
func (l *Link) GetPbTurnout() model.Points {
return l.PbTurnout
}
// Next implements model.Link.
func (*Link) Next(port model.Link_Port, tpos model.PointsPosition) *model.LinkPort {
panic("unimplemented")
}
// Type implements model.Link.
func (l *Link) Type() model.ModelType {
return model.ModelType_Link
}
// Uid implements model.Link.
func (l *Link) Uid() model.Uid {
return l.uid
}
func NewLink() *Link {
return &Link{}
}
// link偏移
type LinkOffset struct {
link *Link
offset int64
}
// link偏移范围
type LinkRange struct {
link *Link
start int64
end int64
}

Some files were not shown because too many files have changed in this diff Show More