rts-sim-module/repository/iscs_bas_dxt.go

package repository

import "joylink.club/rtsssimulation/repository/model/proto"

//ISCS BAS 大系统相关

// AirPavilion 风亭(排、送)
type AirPavilion struct {
	Identity
	Code         string
	PavilionType proto.AirPavilion_Type //风亭子类型
	PortA        DevicePort             //风亭A端口连接的设备
}

func NewAirPavilion(id string, code string, pavilionType proto.AirPavilion_Type) *AirPavilion {
	return &AirPavilion{
		Identity:     &identity{id: id, deviceType: proto.DeviceType_DeviceType_AirPavilion},
		Code:         code,
		PavilionType: pavilionType,
	}
}
func (p *AirPavilion) PortNum() int {
	return 1
}

// AirPavilionPort 风亭端口
//
// implement DevicePort
type AirPavilionPort struct {
	port   proto.Port
	device *AirPavilion
}

func (p *AirPavilionPort) Port() proto.Port {
	return p.port
}
func (p *AirPavilionPort) Device() PortedDevice {
	return p.device
}

///////////////////////////////////////////////////////////

// Valve 阀门(电动调节阀、电动风阀)
type Valve struct {
	Identity
	Code      string
	ValveType proto.Valve_Type //阀门子类型
	PortA     DevicePort       //阀门A端口连接的设备
	PortB     DevicePort       //阀门B端口连接的设备
}

func NewValve(id string, code string, valveType proto.Valve_Type) *Valve {
	return &Valve{
		Identity:  &identity{id: id, deviceType: proto.DeviceType_DeviceType_Valve},
		Code:      code,
		ValveType: valveType,
	}
}
func (p *Valve) PortNum() int {
	return 2
}

// ValvePort 阀门端口
//
// implement DevicePort
type ValvePort struct {
	port   proto.Port
	device *Valve
}

func (p *ValvePort) Port() proto.Port {
	return p.port
}
func (p *ValvePort) Device() PortedDevice {
	return p.device
}

//////////////////////////////////////////////////

// GasMixingChamber 混合室静压箱(气体)
// 有四个端口，ABC三个端口为输入口，D端口为输出口
type GasMixingChamber struct {
	Identity
	Code  string
	PortA DevicePort //A端口连接的设备
	PortB DevicePort //B端口连接的设备
	PortC DevicePort //C端口连接的设备
	PortD DevicePort //D端口连接的设备
}

func NewGasMixingChamber(id string, code string) *GasMixingChamber {
	return &GasMixingChamber{
		Identity: &identity{id: id, deviceType: proto.DeviceType_DeviceType_GasMixingChamber},
		Code:     code,
	}
}
func (p *GasMixingChamber) PortNum() int {
	return 4
}

// GasMixingChamberPort 混合室静压箱端口
//
// implement DevicePort
type GasMixingChamberPort struct {
	port   proto.Port
	device *GasMixingChamber
}

func (p *GasMixingChamberPort) Port() proto.Port {
	return p.port
}
func (p *GasMixingChamberPort) Device() PortedDevice {
	return p.device
}

////////////////////////////////////////////////

// CombinationAirConditioner 组合式空调
// 有四个端口，新风输入端口A,工作风输出端口B；
// 端口C输出风再通过端口D输入，通过C->D实现对风再处理。
type CombinationAirConditioner struct {
	Identity
	Code  string
	PortA DevicePort //新风输入A端口连接的设备
	PortB DevicePort //工作风输出B端口连接的设备
	PortC DevicePort //C端口连接的设备
	PortD DevicePort //D端口连接的设备
}

func NewCombinationAirConditioner(id string, code string) *CombinationAirConditioner {
	return &CombinationAirConditioner{
		Identity: &identity{id: id, deviceType: proto.DeviceType_DeviceType_CombinationAirConditioner},
		Code:     code,
	}
}
func (p *CombinationAirConditioner) PortNum() int {
	return 4
}
func (p *CombinationAirConditioner) Outputs() []DevicePort {
	var out []DevicePort
	if p.PortB != nil {
		out = append(out, p.PortB)
	}
	if p.PortC != nil {
		out = append(out, p.PortC)
	}
	return out
}
func (p *CombinationAirConditioner) Inputs() []DevicePort {
	var in []DevicePort
	if p.PortA != nil {
		in = append(in, p.PortA)
	}
	if p.PortD != nil {
		in = append(in, p.PortD)
	}
	return in
}

// CombinationAirConditionerPort 组合式空调端口
//
// implement DevicePort
type CombinationAirConditionerPort struct {
	port   proto.Port
	device *CombinationAirConditioner
}

func (p *CombinationAirConditionerPort) Port() proto.Port {
	return p.port
}
func (p *CombinationAirConditionerPort) Device() PortedDevice {
	return p.device
}

/////////////////////////////////////////////////////////////////

// AirPurificationDevice 净化装置(对组合式空调B端口输出的工作风进行净化)
// 有两个端口，端口A输入，端口B输出
type AirPurificationDevice struct {
	Identity
	Code  string
	PortA DevicePort //A端口连接的设备
	PortB DevicePort //B端口连接的设备
}

func NewAirPurificationDevice(id string, code string) *AirPurificationDevice {
	return &AirPurificationDevice{
		Identity: &identity{id: id, deviceType: proto.DeviceType_DeviceType_AirPurificationDevice},
		Code:     code,
	}
}
func (p *AirPurificationDevice) PortNum() int {
	return 2
}

// AirPurificationDevicePort 净化装置端口
//
// implement DevicePort
type AirPurificationDevicePort struct {
	port   proto.Port
	device *AirPurificationDevice
}

func (p *AirPurificationDevicePort) Port() proto.Port {
	return p.port
}
func (p *AirPurificationDevicePort) Device() PortedDevice {
	return p.device
}

/////////////////////////////////////////////////////////

// AirCurtain 空气幕
type AirCurtain struct {
	Identity
	Code string
}

func NewAirCurtain(id string, code string) *AirCurtain {
	return &AirCurtain{
		Identity: &identity{id: id, deviceType: proto.DeviceType_DeviceType_AirCurtain},
		Code:     code,
	}
}

//////////////////////////////////////////////////////////

// Fan 风机
type Fan struct {
	Identity
	Code    string
	FanType proto.Fan_Type
	*fanRunningModel
	PortA DevicePort //A端口连接的设备，风机出风口即排风口,输出端口
	PortB DevicePort //B端口连接的设备，风机进风口，输入端口
}

func NewFan(id string, code string, fanType proto.Fan_Type) *Fan {
	return &Fan{
		Identity:        &identity{id: id, deviceType: proto.DeviceType_DeviceType_Fan},
		Code:            code,
		FanType:         fanType,
		fanRunningModel: newFanRunningModel(fanType),
	}
}
func (p *Fan) PortNum() int {
	return 2
}
func (p *Fan) Outputs() []DevicePort {
	if p.PortA == nil {
		return nil
	}
	return []DevicePort{p.PortA}
}
func (p *Fan) Inputs() []DevicePort {
	if p.PortB == nil {
		return nil
	}
	return []DevicePort{p.PortB}
}

// FanPort 风机端口
//
// implement DevicePort
type FanPort struct {
	port   proto.Port
	device *Fan
}

func (p *FanPort) Port() proto.Port {
	return p.port
}
func (p *FanPort) Device() PortedDevice {
	return p.device
}

type fanRunningModel struct {
	maxSpeed float32
	acTime   uint16
}

func (m *fanRunningModel) MotorMaxSpeed() float32 {
	return m.maxSpeed
}
func (m *fanRunningModel) MotorAcTime() uint16 {
	return m.acTime
}
func newFanRunningModel(fanType proto.Fan_Type) *fanRunningModel {
	switch fanType {
	case proto.Fan_CommonFan:
		return &fanRunningModel{maxSpeed: 3000, acTime: 2000}
	case proto.Fan_HighLowSpeedFan:
		return &fanRunningModel{maxSpeed: 6000, acTime: 4000}
	case proto.Fan_FcBypassFan:
		return &fanRunningModel{maxSpeed: 6000, acTime: 3000}
	case proto.Fan_SoftStartFan:
		return &fanRunningModel{maxSpeed: 100, acTime: 4000}
	default:
		return &fanRunningModel{maxSpeed: 3000, acTime: 2000}
	}
}

////////////////////////////////////////////////

// GasEnvironment 气体环境(正常空气+有害烟雾)
// 有多个输入口，统一为端口A，用来为环境补充新鲜空气；
// 有多个输出口，统一为端口B，用户将环境的混浊气体排除；
// 排出气体动力源为该环境。
type GasEnvironment struct {
	Identity
	Code   string
	PortsA []DevicePort // 有多个输入口，统一为端口A，用来为环境补充新鲜空气；
	PortsB []DevicePort // 有多个输出口，统一为端口B，用户将环境的混浊气体排除；
}

func NewGasEnvironment(id string, code string) *GasEnvironment {
	return &GasEnvironment{
		Identity: &identity{id: id, deviceType: proto.DeviceType_DeviceType_GasEnvironment},
		Code:     code,
	}
}
func (p *GasEnvironment) PortNum() int {
	return len(p.PortsA) + len(p.PortsB)
}

// GasEnvironmentPort 气体环境端口
//
// implement DevicePort
type GasEnvironmentPort struct {
	port   proto.Port
	device *GasEnvironment
}

func (p *GasEnvironmentPort) Port() proto.Port {
	return p.port
}
func (p *GasEnvironmentPort) Device() PortedDevice {
	return p.device
}