rts-sim-testing-service/third_party/train_pc_sim/train_pc_sim.go

package train_pc_sim

import (
	"context"
	"fmt"
	"joylink.club/bj-rtsts-server/config"
	"joylink.club/bj-rtsts-server/dto/state_proto"
	"joylink.club/bj-rtsts-server/third_party/message"
	"joylink.club/bj-rtsts-server/third_party/tcp"
	"joylink.club/bj-rtsts-server/third_party/tpapi"
	"joylink.club/ecs"
	"log/slog"
	"sync"
	"time"
)

type TrainControlEvent struct {
	Command byte
	Status  byte
}

var FireTrainControlEventType = ecs.NewEventType[TrainControlEvent]()

type TrainPcSim interface {
	Start(wd ecs.World, pcSimManage TrainPcSimManage)
	Stop()
	//发送驾驶端激活
	SendDriverActive(tc *state_proto.TrainConnState, vobc *state_proto.TrainVobcState)
	//发送牵引制动手柄
	SendHandleSwitch(oldTraction, oldBrakeForce int64, tc *state_proto.TrainConnState, vobc *state_proto.TrainVobcState)
	//发送应答器信息数据
	SendBaliseData(msgType uint16, data []byte)
	//发布列车控制的相关事件
	PublishTrainControlEvent(world ecs.World, events []TrainControlEvent)

	CreateOrRemoveSpeedPLace(train *state_proto.TrainState)

	CreateOrRemoveTrain(msgType byte, data []byte)
	tpapi.ThirdPartyApiService
}

type TrainPcSimManage interface {
	GetTrainPcSimConfig() config.VehiclePCSimConfig
	GetConnTrain() *state_proto.TrainState
	//4.4.1.	车载输出数字量信息报文内容
	TrainPcSimDigitalOutInfoHandle(data []byte)
	//4.4.2.	车载输出数字反馈量信息报文内容
	TrainPcSimDigitalReportHandle(data []byte)

	//门模式
	//TrainDoorModeHandle(state byte)
	//处理列车pc仿真模拟量数据
	TrainPcSimMockInfo(data []byte)
	//处理列车btm查询
	TrainBtmQuery(data []byte)
}

const Name = "车载pc仿真"

func (d *trainPcSimService) Name() string {
	return Name
}
func (d *trainPcSimService) State() tpapi.ThirdPartyApiServiceState {
	return d.state
}
func (d *trainPcSimService) updateState(state tpapi.ThirdPartyApiServiceState) {
	d.state = state
}

var (
	initLock  = &sync.Mutex{}
	singleObj *trainPcSimService
)

func Default() TrainPcSim {
	defer initLock.Unlock()
	initLock.Lock()
	if singleObj == nil {
		singleObj = &trainPcSimService{}
	}
	return singleObj
}

type trainPcSimService struct {
	state            tpapi.ThirdPartyApiServiceState
	pcSimClient      *tcp.TcpClient
	cancleContext    context.CancelFunc
	trainPcSimManage TrainPcSimManage
	speedPlace       *message.TrainSpeedPlaceReportMsg
}

// 接受来自pc仿真的消息
func (d *trainPcSimService) readError(err error) {
	slog.Error("连接车载pc仿真tcp服务断开", err)
	d.updateState(tpapi.ThirdPartyState_Broken)
	d.pcSimClient.Close()
}
func (d *trainPcSimService) Start(wd ecs.World, pcSimManage TrainPcSimManage) {
	config := pcSimManage.GetTrainPcSimConfig()
	if config.PcSimIp == "" || !config.Open {
		slog.Info("车载pc仿真配置未开启")
		return
	}

	client, err := tcp.StartTcpClient(fmt.Sprintf("%v:%v", config.PcSimIp, config.PcSimPort), d.reivceData, d.readError)
	if err != nil {
		slog.Error("连接车载pc平台失败", err)
		d.updateState(tpapi.ThirdPartyState_Broken)
		return
	}
	d.pcSimClient = client
	ctx, ctxFun := context.WithCancel(context.Background())
	d.cancleContext = ctxFun
	d.trainPcSimManage = pcSimManage

	FireTrainControlEventType.Subscribe(wd, d.trainControlEventHandle)
	d.updateState(tpapi.ThirdPartyState_Normal)
	go d.sendTrainLocationAndSpeedTask(ctx)

}
func (d *trainPcSimService) Stop() {
	d.updateState(tpapi.ThirdPartyState_Closed)
	if d.cancleContext != nil {
		d.cancleContext()

		d.cancleContext = nil
	}
	if d.pcSimClient != nil {
		//d.pcSimClient.
		d.pcSimClient.Close()
	}
}
func (d *trainPcSimService) CreateOrRemoveSpeedPLace(train *state_proto.TrainState) {
	if train.ConnState.Conn {
		train.PluseCount = &state_proto.SensorSpeedPulseCount{}
		d.speedPlace = &message.TrainSpeedPlaceReportMsg{TrainId: train.Id}
	} else {
		train.PluseCount = nil
		d.speedPlace = nil
	}
}
func (d *trainPcSimService) CreateOrRemoveTrain(msgType byte, data []byte) {
	msg := &message.TrainPcSimBaseMessage{Data: data, Type: uint16(msgType)}
	d.pcSimClient.Send(msg.Encode())
}

// 依据文档80ms发送列车速度位置
func (d *trainPcSimService) sendTrainLocationAndSpeedTask(ctx context.Context) {
	for {
		select {
		case <-ctx.Done():
			return
		default:
		}
		train := d.trainPcSimManage.GetConnTrain()
		if train != nil && train.ConnState.Conn {
			s1, s2 := train.PluseCount.PulseCount1, train.PluseCount.PulseCount2
			d.speedPlace.ParsePulseCount1(s1, s2)
			data := d.speedPlace.Encode(train.RunDirection, s1, s2)
			bm := &message.TrainPcSimBaseMessage{Type: SENDER_TRAIN_LOCATION_INFO, Data: data}
			train.PluseCount.PulseCount1 = 0
			train.PluseCount.PulseCount2 = 0
			d.pcSimClient.Send(bm.Encode())
		} /*else {
			m1 := "未找到对应连接车载pc仿真的列车"
			if train != nil {
				m1 = fmt.Sprintf("对应的列车没有连接上车载pc仿真，列车ID：%v", train.Id)
			}
			slog.Info(m1)
		}*/
		time.Sleep(time.Millisecond * 80)
	}
}

// 发送驾驶激活
func (d *trainPcSimService) SendDriverActive(tc *state_proto.TrainConnState, vobc *state_proto.TrainVobcState) {
	if tc.Conn && tc.ConnType == state_proto.TrainConnState_PC_SIM {
		defulatBuf := make([]byte, 0)
		msg := &message.TrainPcSimBaseMessage{Data: defulatBuf}
		if vobc.Tc1Active || vobc.Tc2Active {
			msg.Type = SENDER_TRAIN_TC_ACTIVE
		} else if vobc.Tc1Active == false && vobc.Tc2Active == false {
			msg.Type = SENDER_TRAIN_TC_NOT_ACTIVE
		}
		d.pcSimClient.Send(msg.Encode())
	}
}
func (d *trainPcSimService) SendHandleSwitch(oldTraction, oldBrakeForce int64, tc *state_proto.TrainConnState, vobc *state_proto.TrainVobcState) {
	if tc.Conn && tc.ConnType == state_proto.TrainConnState_PC_SIM {
		msg := &message.TrainPcSimBaseMessage{}
		newTraction := vobc.TractionForce
		newBrake := vobc.BrakeForce
		if newTraction <= oldTraction && newTraction == 0 {
			//手柄取消前进
			msg.Type = RECIVE_TRAIN_HAND_KEY_CANCLE_FORWARD
		} else if newTraction > oldTraction {
			//手柄前进
			msg.Type = SENDER_TRAIN_HAND_KEY_FORWARD
		} else if newBrake >= oldBrakeForce && newBrake == 0 {
			//手柄取消后退
			msg.Type = RECIVE_TRAIN_HAND_KEY_CACLE_BACKWARD
		} else if newBrake < oldBrakeForce {
			//手柄后退
			msg.Type = RECIVE_TRAIN_HAND_KEY_BACKWARD
		} else {
			slog.Error("")
			return
		}
		d.pcSimClient.Send(msg.Encode())
	}
}

func (d *trainPcSimService) SendBaliseData(msgType uint16, data []byte) {
	msg := &message.TrainPcSimBaseMessage{}
	msg.Type = msgType
	msg.Data = data
	d.pcSimClient.Send(msg.Encode())
}

func (d *trainPcSimService) trainControlEventHandle(w ecs.World, event TrainControlEvent) {
	fmt.Println(event.Status)
	msg := &message.TrainPcSimBaseMessage{}
	msg.Type = SENDER_TRAIN_OUTR_INFO
	data := []byte{event.Command, event.Status}
	msg.Data = data
	d.pcSimClient.Send(msg.Encode())
}
func (d *trainPcSimService) PublishTrainControlEvent(world ecs.World, events []TrainControlEvent) {
	if len(events) <= 0 {
		slog.Warn("发布事件数量为空")
		return
	}
	for _, event := range events {
		FireTrainControlEventType.Publish(world, &event)
	}
}

// 接受来自pc仿真的消息
func (d *trainPcSimService) reivceData(len int, data []byte) {
	baseMsg := &message.TrainPcSimBaseMessage{}
	err := baseMsg.Decode(data)
	if err != nil {
		slog.Error("车载pc仿真接受数据解析失败 ")
		return
	}

	switch baseMsg.Type {
	//case RECIVE_TRAIN_CREATE_REMOVE:
	//	pc.trainPcSimManage.TrainPcSimConnOrRemoveHandle(baseMsg.Data[0])
	case RECIVE_TRAIN_INTERFACE_CABINET_OUTR:
		d.trainPcSimManage.TrainPcSimDigitalOutInfoHandle(baseMsg.Data)
	case RECIVE_TRAIN_INTERFACE_CABINET_OUTR_BACK:
		d.trainPcSimManage.TrainPcSimDigitalReportHandle(baseMsg.Data)
	case RECIVE_TRAIN_QUERY_STATUS:
		d.trainPcSimManage.TrainBtmQuery(baseMsg.Data)
	case RECIVE_TRAIN_MOCK_DATA:
		d.trainPcSimManage.TrainPcSimMockInfo(baseMsg.Data)
		//case RECIVE_TRAIN_DOOR_MODE:
		//	pc.trainPcSimManage.TrainDoorModeHandle(baseMsg.Data[0])
	}
}