[修改]人解进路功能增加关闭引导信号功能（成都三）

[新增]首区段占用时，办理引导进路延时15秒后关闭引导信号
列车运行图例，报错修复
2024-10-12 17:30:21 +08:00 · 2024-10-10 17:57:59 +08:00 · 2024-10-10 17:36:21 +08:00 · 2024-10-10 17:07:17 +08:00
8 changed files with 902 additions and 779 deletions
--- a/src/main/java/club/joylink/rtss/simulation/cbtc/ATS/data/SortDiagramStation.java
+++ b/src/main/java/club/joylink/rtss/simulation/cbtc/ATS/data/SortDiagramStation.java
@ -46,7 +46,14 @@ public class SortDiagramStation {


  private Station findNotDepotStation(boolean isRight, int index) {
-    Station station = stationList.get(index);
+    Station station = null;
+    if (index >= stationList.size()) {
+      station = stationList.get(stationList.size() - 1);
+    } else if (index <= 0) {
+      station = stationList.get(0);
+    } else {
+      station = stationList.get(index);
+    }
    while (station.isDepot()) {
      index += isRight ? -1 : 1;
      station = stationList.get(index);
--- a/src/main/java/club/joylink/rtss/simulation/cbtc/ATS/service/ars/AtsRouteSelectService.java
+++ b/src/main/java/club/joylink/rtss/simulation/cbtc/ATS/service/ars/AtsRouteSelectService.java
@ -32,6 +32,7 @@ public abstract class AtsRouteSelectService {
   * 查询需要触发的进路
   *
   * @param simulation
+   * @param targetList      运行计划中的计划区段（包含站后折返轨）
   * @param turnBackSection 站后折返的折返轨
   * @return
   */
@ -63,13 +64,18 @@ public abstract class AtsRouteSelectService {
    MapConfig config = repository.getConfig();
    if (!config.isSignalOpenAfterParking() || (headSection.equals(planSection)
        && trainInfo.isParking())) { //不需要停站就可以开放信号机或者已经在计划区段停站（可以继续向前办理进路）
-      if (nextPlanSection != null) { //计划区段路径未跑完
+      //根据车站折返策略处理
+      Station station = planSection.getStation();
+      if (station.getTbStrategyId() != null && Objects.equals(turnBackSection,
+          nextPlanSection)) { //有折返策略时按折返策略
+        return queryTriggerRoutes4TurnBack(simulation, planSection, turnBackSection, trainInfo);
+      } else if (nextPlanSection != null) { //无折返策略按计划
        routePaths = repository.queryRoutePaths(planSection, nextPlanSection);
        if (!CollectionUtils.isEmpty(routePaths)) {
          return this.queryTriggerRoutesOfRoutePath(repository, trainInfo, routePaths,
              nextPlanSection).getRoute();
        }
-      } else if (turnBackSection != null) { //站后折返
+      } else if (turnBackSection != null) {
        return queryTriggerRoutes4TurnBack(simulation, planSection, turnBackSection, trainInfo);
      }
    }
--- a/src/main/java/club/joylink/rtss/simulation/cbtc/ATS/service/stage/AtsPlanTrainStageService.java
+++ b/src/main/java/club/joylink/rtss/simulation/cbtc/ATS/service/stage/AtsPlanTrainStageService.java
@ -5,23 +5,26 @@ import club.joylink.rtss.simulation.cbtc.ATS.service.AtsStandService;
 import club.joylink.rtss.simulation.cbtc.ATS.service.AtsTrainService;
 import club.joylink.rtss.simulation.cbtc.Simulation;
 import club.joylink.rtss.simulation.cbtc.data.SimulationDataRepository;
-import club.joylink.rtss.simulation.cbtc.data.map.*;
+import club.joylink.rtss.simulation.cbtc.data.map.MapConfig;
+import club.joylink.rtss.simulation.cbtc.data.map.Route;
+import club.joylink.rtss.simulation.cbtc.data.map.Section;
+import club.joylink.rtss.simulation.cbtc.data.map.Signal;
+import club.joylink.rtss.simulation.cbtc.data.map.Stand;
 import club.joylink.rtss.simulation.cbtc.data.plan.StationPlan;
 import club.joylink.rtss.simulation.cbtc.data.plan.TripPlan;
 import club.joylink.rtss.simulation.cbtc.data.support.RoutePath;
 import club.joylink.rtss.simulation.cbtc.data.vo.TrainInfo;
 import club.joylink.rtss.simulation.cbtc.onboard.ATP.OnboardAtpApiService;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
-import org.springframework.util.CollectionUtils;
-
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.temporal.ChronoUnit;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.util.CollectionUtils;

 /**
 * 计划车阶段处理服务
@ -29,6 +32,7 @@ import java.util.Objects;
@Slf4j
@Component
 public class AtsPlanTrainStageService implements AtsStageService {
+
  @Autowired
  private AtsRealRunRecordService realRunRecordService;
  @Autowired
@ -39,9 +43,11 @@ public class AtsPlanTrainStageService implements AtsStageService {
  private AtsTrainService atsTrainService;

  @Override
-    public void handleTransferTrackParking(Simulation simulation, TrainInfo trainInfo, Section parkSection) {
+  public void handleTransferTrackParking(Simulation simulation, TrainInfo trainInfo,
+      Section parkSection) {
    SimulationDataRepository repository = simulation.getRepository();
-        TripPlan tripPlan = repository.getTripPlan(trainInfo.getServiceNumber(), trainInfo.getTripNumber());
+    TripPlan tripPlan = repository.getTripPlan(trainInfo.getServiceNumber(),
+        trainInfo.getTripNumber());
 //        List<RoutePath> routePathList = repository.queryRoutePathsByEnd(parkSection);
 //        if (routePathList.get(0).isRight() == trainInfo.getRight()) { //准备回库
 //            if (!parkSection.isTurnBackTrack()) { //针对上饶沙盘
@ -82,15 +88,18 @@ public class AtsPlanTrainStageService implements AtsStageService {
  }

  @Override
-    public void handleNormalStandParking(Simulation simulation, TrainInfo trainInfo, Section parkSection) {
+  public void handleNormalStandParking(Simulation simulation, TrainInfo trainInfo,
+      Section parkSection) {
    SimulationDataRepository repository = simulation.getRepository();
    MapConfig config = repository.getConfig();
    List<Stand> standList = parkSection.getStandList();
-        TripPlan tripPlan = repository.getTripPlan(trainInfo.getServiceNumber(), trainInfo.getTripNumber());
+    TripPlan tripPlan = repository.getTripPlan(trainInfo.getServiceNumber(),
+        trainInfo.getTripNumber());
    TripPlan nextTripPlan = null;
    StationPlan stationPlan = tripPlan.queryStationPlan(parkSection);
    if (config.isStandTbStrategyIsInvalid()) {
-            if (stationPlan != null && tripPlan.isLastPlan(stationPlan) && tripPlan.isFrontTurnBack()) { // 到达终点站了，判断站前折返还是站后折返
+      if (stationPlan != null && tripPlan.isLastPlan(stationPlan)
+          && tripPlan.isFrontTurnBack()) { // 到达终点站了，判断站前折返还是站后折返
        // 站前折返，查询下一车次计划
        nextTripPlan = repository.queryNextTripPlanOf(tripPlan);
      } else if (stationPlan == null && tripPlan.isLastPlanStation(parkSection.getStation())) {
@ -101,9 +110,12 @@ public class AtsPlanTrainStageService implements AtsStageService {
      }
      if (nextTripPlan != null) { // 站前折返，更新计划
        this.updateTripPlan(simulation, trainInfo, nextTripPlan);
-                BusinessExceptionAssertEnum.DATA_ERROR.assertEquals(nextTripPlan.getFirstStationPlan().getSection(), parkSection,
-                        String.format("下一车次计划[%s]第一站台轨和停靠站台轨不相同:[%s]", nextTripPlan.getStNumber(), parkSection.getName()));
-                this.updateNextPlan(simulation, trainInfo, nextTripPlan, nextTripPlan.getFirstStationPlan());
+        BusinessExceptionAssertEnum.DATA_ERROR.assertEquals(
+            nextTripPlan.getFirstStationPlan().getSection(), parkSection,
+            String.format("下一车次计划[%s]第一站台轨和停靠站台轨不相同:[%s]",
+                nextTripPlan.getStNumber(), parkSection.getName()));
+        this.updateNextPlan(simulation, trainInfo, nextTripPlan,
+            nextTripPlan.getFirstStationPlan());
      }
    } else {
      if (!CollectionUtils.isEmpty(standList)) {
@ -114,20 +126,24 @@ public class AtsPlanTrainStageService implements AtsStageService {
          case AUTO:
            if (stationPlan != null && tripPlan.isLastPlan(stationPlan)) { // 当前计划终点站
              if (Objects.equals(stand.isRight(), trainInfo.getRight())) {
-                                onboardAtpApiService.startTurnBack(simulation, trainInfo.getGroupNumber(), parkSection.getCode());
+                onboardAtpApiService.startTurnBack(simulation, trainInfo.getGroupNumber(),
+                    parkSection.getCode());
                nextTripPlan = repository.queryNextTripPlanOf(tripPlan);
                if (nextTripPlan != null) { // 站前折返，更新计划
                  this.updateTripPlan(simulation, trainInfo, nextTripPlan);
-                                    this.updateNextPlan(simulation, trainInfo, nextTripPlan, nextTripPlan.getSecondStationPlan());
+                  this.updateNextPlan(simulation, trainInfo, nextTripPlan,
+                      nextTripPlan.getSecondStationPlan());
                }
              }
            }
            break;
          default:
-                        if (stationPlan != null && tripPlan.isLastPlan(stationPlan) && tripPlan.isFrontTurnBack()) { // 到达终点站了，判断站前折返还是站后折返
+            if (stationPlan != null && tripPlan.isLastPlan(stationPlan)
+                && tripPlan.isFrontTurnBack()) { // 到达终点站了，判断站前折返还是站后折返
              // 站前折返，查询下一车次计划
              nextTripPlan = repository.queryNextTripPlanOf(tripPlan);
-                        } else if (stationPlan == null && tripPlan.isLastPlanStation(parkSection.getStation())) {
+            } else if (stationPlan == null && tripPlan.isLastPlanStation(
+                parkSection.getStation())) {
              if (config.isAtsAutoHandleManualFrontTurnBack()) {
                // 人工站前折返
                nextTripPlan = repository.queryNextTripPlanOf(tripPlan);
@ -135,9 +151,12 @@ public class AtsPlanTrainStageService implements AtsStageService {
            }
            if (nextTripPlan != null) { // 站前折返，更新计划
              this.updateTripPlan(simulation, trainInfo, nextTripPlan);
-                            BusinessExceptionAssertEnum.DATA_ERROR.assertEquals(nextTripPlan.getFirstStationPlan().getSection(), parkSection,
-                                    String.format("下一车次计划[%s]第一站台轨和停靠站台轨不相同:[%s]", nextTripPlan.getStNumber(), parkSection.getName()));
-                            this.updateNextPlan(simulation, trainInfo, nextTripPlan, nextTripPlan.getFirstStationPlan());
+              BusinessExceptionAssertEnum.DATA_ERROR.assertEquals(
+                  nextTripPlan.getFirstStationPlan().getSection(), parkSection,
+                  String.format("下一车次计划[%s]第一站台轨和停靠站台轨不相同:[%s]",
+                      nextTripPlan.getStNumber(), parkSection.getName()));
+              this.updateNextPlan(simulation, trainInfo, nextTripPlan,
+                  nextTripPlan.getFirstStationPlan());
            }
            break;
        }
@ -146,9 +165,11 @@ public class AtsPlanTrainStageService implements AtsStageService {
  }

  @Override
-    public void ready2DepartFromNormalStand(Simulation simulation, TrainInfo trainInfo, Section parkSection) {
+  public void ready2DepartFromNormalStand(Simulation simulation, TrainInfo trainInfo,
+      Section parkSection) {
    SimulationDataRepository repository = simulation.getRepository();
-        TripPlan tripPlan = repository.getTripPlan(trainInfo.getServiceNumber(), trainInfo.getTripNumber());
+    TripPlan tripPlan = repository.getTripPlan(trainInfo.getServiceNumber(),
+        trainInfo.getTripNumber());
    StationPlan stationPlan = tripPlan.queryStationPlan(parkSection);
    if (stationPlan == null) {
      // 非计划中的停靠站台轨，暂不处理
@ -168,7 +189,8 @@ public class AtsPlanTrainStageService implements AtsStageService {
        }
        // 到达终点站，准备折返
        log.debug(String.format("列车[%s]折返初始化", trainInfo.getGroupNumber()));
-                List<RoutePath> routePaths = repository.getRoutePaths(parkSection, tripPlan.getEndSection());
+        List<RoutePath> routePaths = repository.getRoutePaths(parkSection,
+            tripPlan.getEndSection());
        Signal signal = parkSection.getSignalOf(routePaths.get(0).isRight());
        if (signal.isMainAspect() || signal.isGuideAspect()) {
          Route lockedRoute = signal.getLockedRoute();
@ -190,7 +212,8 @@ public class AtsPlanTrainStageService implements AtsStageService {
    this.onboardAtpApiService.updateTripPlan(simulation, trainInfo.getGroupNumber(), nextTripPlan);
  }

-    public void updateNextPlan(Simulation simulation, TrainInfo trainInfo, TripPlan tripPlan, StationPlan nextStationPlan) {
+  public void updateNextPlan(Simulation simulation, TrainInfo trainInfo, TripPlan tripPlan,
+      StationPlan nextStationPlan) {
    if (nextStationPlan == null) {
      log.warn(String.format("列车[%s]下一计划到站为null", trainInfo.debugStr()));
      return;
@ -239,7 +262,8 @@ public class AtsPlanTrainStageService implements AtsStageService {
    }
    int planRunTime = (int) ChronoUnit.SECONDS.between(startTime, endTime);
    int adjustRunTime = planRunTime;
-        if (!turnBack && !outbound && config.isAdjustOperationAutomatically() && trainInfo.isAtsAutoAdjust()) {
+    if (!turnBack && !outbound && config.isAdjustOperationAutomatically()
+        && trainInfo.isAtsAutoAdjust()) {
      startTime = systemTime.toLocalTime();
      adjustRunTime = (int) ChronoUnit.SECONDS.between(startTime, endTime);
    }
@ -253,12 +277,17 @@ public class AtsPlanTrainStageService implements AtsStageService {
  }

  @Override
-    public void handleTurnBackTrackParking(Simulation simulation, TrainInfo trainInfo, Section parkSection) {
+  public void handleTurnBackTrackParking(Simulation simulation, TrainInfo trainInfo,
+      Section parkSection) {
    SimulationDataRepository repository = simulation.getRepository();
    LocalDateTime systemTime = simulation.getSystemTime();
-        TripPlan tripPlan = repository.getTripPlan(trainInfo.getServiceNumber(), trainInfo.getTripNumber());
-        if (tripPlan.getEndSection().equals(parkSection)
-                /*|| tripPlan.getEndSection().getStation().equals(parkSection.getStation())*/) {
+    TripPlan tripPlan = repository.getTripPlan(trainInfo.getServiceNumber(),
+        trainInfo.getTripNumber());
+
+    // 车次计划中的车站计划全部完成，并且当前折返轨与计划折返轨属于同一站，则认为车次计划完成
+    boolean completed = tripPlan.getPlanList().stream().allMatch(StationPlan::isFinished)
+        && tripPlan.getEndSection().getStation().equals(parkSection.getStation());
+    if (completed) {
      // 计划终端折返轨或和计划终端折返轨同站的折返轨,根据车次类型处理
      TripPlan nextTripPlan = repository.queryNextTripPlanOf(tripPlan);
      if (nextTripPlan == null) {
@ -268,15 +297,19 @@ public class AtsPlanTrainStageService implements AtsStageService {
        // 备用车
        if (systemTime.toLocalTime().plusMinutes(5).isAfter(nextTripPlan.getStartTime())) {
          this.updateTripPlan(simulation, trainInfo, nextTripPlan);
-                    BusinessExceptionAssertEnum.DATA_ERROR.assertNotEquals(parkSection, nextTripPlan.getFirstStationPlan().getSection());
-                    this.updateNextPlan(simulation, trainInfo, nextTripPlan, nextTripPlan.getFirstStationPlan());
+          BusinessExceptionAssertEnum.DATA_ERROR.assertNotEquals(parkSection,
+              nextTripPlan.getFirstStationPlan().getSection());
+          this.updateNextPlan(simulation, trainInfo, nextTripPlan,
+              nextTripPlan.getFirstStationPlan());
          return;
        }
      } else if (tripPlan.isTurnBack()) {
        // 折返计划
        this.updateTripPlan(simulation, trainInfo, nextTripPlan);
-                BusinessExceptionAssertEnum.DATA_ERROR.assertNotEquals(parkSection, nextTripPlan.getFirstStationPlan().getSection());
-                this.updateNextPlan(simulation, trainInfo, nextTripPlan, nextTripPlan.getFirstStationPlan());
+        BusinessExceptionAssertEnum.DATA_ERROR.assertNotEquals(parkSection,
+            nextTripPlan.getFirstStationPlan().getSection());
+        this.updateNextPlan(simulation, trainInfo, nextTripPlan,
+            nextTripPlan.getFirstStationPlan());
        return;
      }
    } else {
@ -317,7 +350,8 @@ public class AtsPlanTrainStageService implements AtsStageService {
      return;
    }
    SimulationDataRepository repository = simulation.getRepository();
-        TripPlan tripPlan = repository.getTripPlan(trainInfo.getServiceNumber(), trainInfo.getTripNumber());
+    TripPlan tripPlan = repository.getTripPlan(trainInfo.getServiceNumber(),
+        trainInfo.getTripNumber());
    StationPlan stationPlan = tripPlan.queryStationPlan(planStandTrack);
    Section section = repository.getByCode(planStandTrack, Section.class);
    //更新离站信息
--- a/src/main/java/club/joylink/rtss/simulation/cbtc/CI/CiApiServiceImpl2.java
+++ b/src/main/java/club/joylink/rtss/simulation/cbtc/CI/CiApiServiceImpl2.java
@ -246,12 +246,12 @@ public class CiApiServiceImpl2 implements CiApiService {
  @Override
  public void humanCancel(Simulation simulation, String routeCode) {
    Route route = simulation.getRepository().getByCode(routeCode, Route.class);
-//        if (simulation.getRepository().getConfig().isRailway()) {
-//            BusinessExceptionAssertEnum.OPERATION_FAIL.assertTrue(route.isApproachLock(),
-//                    "进路未接近锁闭，不能人解");
-//        }
+    if (route.getStart().isGuideAspect()) { // 根据成都三引导解锁逻辑修改
+      signalService.closeRoute(simulation, route.getStart());
+    } else {
      this.routeService.delayUnlockStart(simulation, route, route.getStart());
    }
+  }

  @Override
  public void sectionFaultUnlock(Simulation simulation, String sectionCode) {
@ -504,6 +504,10 @@ public class CiApiServiceImpl2 implements CiApiService {
        signal.guideDelayStart();
      }
    }
+    if (repository.getConfig().isGuideDelayCloseWhenFirstSectionOccupied()
+        && signal.isGuideAspect()) {
+      signal.guideDelayStart();
+    }
 //    if (signal.getGuideRemain() > 0) {
 //      signal.setGuideRemain(0);
 //    } else {
--- a/src/main/java/club/joylink/rtss/simulation/cbtc/data/map/MapConfig.java
+++ b/src/main/java/club/joylink/rtss/simulation/cbtc/data/map/MapConfig.java
@ -1,20 +1,22 @@
 package club.joylink.rtss.simulation.cbtc.data.map;

+import static club.joylink.rtss.simulation.cbtc.member.SimulationMember.Type.DISPATCHER;
+import static club.joylink.rtss.simulation.cbtc.member.SimulationMember.Type.ELECTRIC_DISPATCHER;
+import static club.joylink.rtss.simulation.cbtc.member.SimulationMember.Type.MAINTAINER;
+import static club.joylink.rtss.simulation.cbtc.member.SimulationMember.Type.STATION_SUPERVISOR;
+
 import club.joylink.rtss.simulation.cbtc.constant.RunLevel;
 import club.joylink.rtss.simulation.cbtc.member.SimulationMember;
 import club.joylink.rtss.vo.map.MapFunctionConfig;
 import club.joylink.rtss.vo.map.RealLineConfigVO;
-import lombok.Getter;
-import lombok.Setter;
-import org.springframework.util.CollectionUtils;
-import org.springframework.util.StringUtils;
-
 import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
-
-import static club.joylink.rtss.simulation.cbtc.member.SimulationMember.Type.*;
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.StringUtils;

 /**
 * 地图配置
@ -193,40 +195,64 @@ public class MapConfig {
   */
  private boolean holdCommandIgnoreControlMode;

-    /** 共享紧急关闭效果的车站 */
+  /**
+   * 共享紧急关闭效果的车站
+   */
  private Set<String> sharingECStations;

-    /** 取消联锁条件不满足的进路时需要延时解锁 */
+  /**
+   * 取消联锁条件不满足的进路时需要延时解锁
+   */
  private boolean delayWhenCancelRouteWithAbnormalInterlock;

-    /** 车次号的位数 */
+  /**
+   * 车次号的位数
+   */
  private int figuresOfTripNumber;

-    /** 服务号的位数 */
+  /**
+   * 服务号的位数
+   */
  private int figuresOfServiceNumber;

-    /** 设置头码车时检查方向 */
+  /**
+   * 设置头码车时检查方向
+   */
  private boolean checkDirectionWhenSetHead;

-    /** 转换轨进路只能通过故障解锁来取消 */
+  /**
+   * 转换轨进路只能通过故障解锁来取消
+   */
  private boolean transferRouteCanOnlyFaultUnlock;

-    /** 头码车抵达目的地后变为人工车 */
+  /**
+   * 头码车抵达目的地后变为人工车
+   */
  private boolean setManualWhenHeadTrainArriveTarget;

-    /** 进路默认开启冲突检测 */
+  /**
+   * 进路默认开启冲突检测
+   */
  private boolean routeDefaultCheckConflict;

-    /** 处理停车场/车辆段逻辑 */
+  /**
+   * 处理停车场/车辆段逻辑
+   */
  private boolean handleDepot;

-    /** 运行图中车次号是否唯一 */
+  /**
+   * 运行图中车次号是否唯一
+   */
  private boolean tripNumberIsUnique;

-    /** 站台折返策略不生效 */
+  /**
+   * 站台折返策略不生效
+   */
  private boolean standTbStrategyIsInvalid;

-    /** 根据服务号更新车次计划（西安三提出，抽线之后，后续列车还跑原来的服务，不会自动顶上） */
+  /**
+   * 根据服务号更新车次计划（西安三提出，抽线之后，后续列车还跑原来的服务，不会自动顶上）
+   */
  private boolean updateTripPlanByServiceNumber;

  /**
@ -236,8 +262,7 @@ public class MapConfig {
  /**
   * 对信号机封锁操作，是否影响信号显示
   * <p>
-     * true-封锁信号机，会使信号机显示禁止色<br>
-     * false-封锁信号机，不会影响信号机显示。 
+   * true-封锁信号机，会使信号机显示禁止色<br> false-封锁信号机，不会影响信号机显示。
   */
  private boolean signalBolckOptReflectSignal;

@ -260,8 +285,14 @@ public class MapConfig {
   */
  private boolean manualTrainDefaultStop;

+  /**
+   * 办理引导进路时，如果进路首区段占用，引导信号15秒后关闭
+   */
+  private boolean guideDelayCloseWhenFirstSectionOccupied;
+
  private Set<SimulationMember.Type> needConfirmConnectMembers =
-            Stream.of(DISPATCHER, STATION_SUPERVISOR, MAINTAINER, ELECTRIC_DISPATCHER).collect(Collectors.toSet());
+      Stream.of(DISPATCHER, STATION_SUPERVISOR, MAINTAINER, ELECTRIC_DISPATCHER)
+          .collect(Collectors.toSet());

  public MapConfig() {
    this.lockFirst = false;
@ -290,8 +321,10 @@ public class MapConfig {
      setParkingSM(configVO.getParkingSM());
      setRmAtpSpeed(configVO.getRmAtpSpeed() / 3.6f);
      setUrmAtpSpeed(configVO.getUrmAtpSpeed() / 3.6f);
-            setCancelAtsControlOfAllRoutesWhenCancelRoute(configVO.isCancelAtsControlOfAllRoutesWhenCancelRoute());
-            setSignalHumanControlBeforeSetAtsControlOrCIAutoTrigger(configVO.isSignalHumanControlBeforeSetAtsControlOrCIAutoTrigger());
+      setCancelAtsControlOfAllRoutesWhenCancelRoute(
+          configVO.isCancelAtsControlOfAllRoutesWhenCancelRoute());
+      setSignalHumanControlBeforeSetAtsControlOrCIAutoTrigger(
+          configVO.isSignalHumanControlBeforeSetAtsControlOrCIAutoTrigger());
      setAllowEarlyDepartureWhenHoldTrain(configVO.isAllowEarlyDepartureWhenHoldTrain());
      setEBWhenCancelRoute(configVO.isEBWhenCancelRoute());
      setAdjustOperationAutomatically(configVO.isAdjustOperationAutomatically());
@ -302,9 +335,11 @@ public class MapConfig {
      setBlockadeCommandOnlyValidInStandbyMode(configVO.isBlockadeCommandOnlyValidInStandbyMode());
 //            setSomeCommandNeedInit(configVO.isSwitchBlockadeCommandNeedInit());
      setStationPreResetBeforeAxlePreReset(configVO.isStationPreResetBeforeAxlePreReset());
-            setSwitchTurnOperationCanRecoverSplitFault(configVO.isSwitchTurnOperationCanRecoverSplitFault());
+      setSwitchTurnOperationCanRecoverSplitFault(
+          configVO.isSwitchTurnOperationCanRecoverSplitFault());
      setHoldCommandIgnoreControlMode(configVO.isHoldCommandIgnoreControlMode());
-            setDelayWhenCancelRouteWithAbnormalInterlock(configVO.isDelayWhenCancelRouteWithAbnormalInterlock());
+      setDelayWhenCancelRouteWithAbnormalInterlock(
+          configVO.isDelayWhenCancelRouteWithAbnormalInterlock());
      setFiguresOfTripNumber(configVO.getFiguresOfTripNumber());
      setFiguresOfServiceNumber(configVO.getFiguresOfServiceNumber());
      setCheckDirectionWhenSetHead(configVO.isCheckDirectionWhenSetHead());
@ -319,12 +354,15 @@ public class MapConfig {
      setSFUCanOnlyApplyForFaultLockSection(configVO.isSFUCanOnlyApplyForFaultLockSection());
      setRouteCanSetWhenSwitchFault(configVO.isRouteCanSetWhenSwitchFault());
      setManualTrainDefaultStop(configVO.isManualTrainDefaultStop());
+      setGuideDelayCloseWhenFirstSectionOccupied(
+          configVO.isGuideDelayCloseWhenFirstSectionOccupied());
    }
  }

  public void copyConfigBy(MapFunctionConfig mapFunctionConfig) {
-        if (mapFunctionConfig == null)
+    if (mapFunctionConfig == null) {
      return;
+    }
    this.hasCTC = mapFunctionConfig.isHasCTC();
    this.hasTDCS = mapFunctionConfig.isHasTDCS();
  }
@ -334,7 +372,8 @@ public class MapConfig {
      if (noParkingSM.contains("-")) {
        String[] split = noParkingSM.split("-");
        if (split.length == 2) {
-                    return Integer.parseInt(serviceNumber) >= Integer.parseInt(split[0]) && Integer.parseInt(serviceNumber) <= Integer.parseInt(split[1]);
+          return Integer.parseInt(serviceNumber) >= Integer.parseInt(split[0])
+              && Integer.parseInt(serviceNumber) <= Integer.parseInt(split[1]);
        }
      }
    }
@ -346,7 +385,8 @@ public class MapConfig {
      if (parkingSM.contains("-")) {
        String[] split = parkingSM.split("-");
        if (split.length == 2) {
-                    return Integer.parseInt(serviceNumber) >= Integer.parseInt(split[0]) && Integer.parseInt(serviceNumber) <= Integer.parseInt(split[1]);
+          return Integer.parseInt(serviceNumber) >= Integer.parseInt(split[0])
+              && Integer.parseInt(serviceNumber) <= Integer.parseInt(split[1]);
        }
      }
    }
@ -375,12 +415,14 @@ public class MapConfig {
  }

  public boolean isSharingECStation(String stationCode) {
-        if (CollectionUtils.isEmpty(this.sharingECStations))
+    if (CollectionUtils.isEmpty(this.sharingECStations)) {
      return false;
+    }
    for (String code : sharingECStations) {
-            if (code.equals(stationCode))
+      if (code.equals(stationCode)) {
        return true;
      }
+    }
    return false;
  }

@ -396,6 +438,7 @@ public class MapConfig {
    /**
     * 直接取消
     */
-        DIRECT,;
+    DIRECT,
+    ;
  }
 }
--- a/src/main/java/club/joylink/rtss/simulation/cbtc/robot/SimulationRobotService.java
+++ b/src/main/java/club/joylink/rtss/simulation/cbtc/robot/SimulationRobotService.java
@ -345,10 +345,15 @@ public class SimulationRobotService {
              || Objects.equals(vrSignal.getAspect(), signal.getGuideAspect())) { //引导信号
            if (!Objects.equals(signal, throughSignal) || !Objects.equals(vrSignal.getAspect(),
                throughAspect)) {
-              SectionPosition noPassPosition = CalculateService.calculateNextPositionByStartAndLen(
+              SectionPosition tempPosition;
+              if (section.isFunctionTrack()) { //解决福州一列车从车辆段开出来时，在转换轨停车位置有误，导致无法发车的问题
+                tempPosition = new SectionPosition(section, section.getStopPointByDirection(right));
+              } else {
+                tempPosition = CalculateService.calculateNextPositionByStartAndLen(
                    signalPosition, !right, 2, true);
-              if (targetPosition == null || noPassPosition.isAheadOf(targetPosition, right)) {
-                targetPosition = noPassPosition;
+              }
+              if (targetPosition == null || tempPosition.isAheadOf(targetPosition, right)) {
+                targetPosition = tempPosition;
              }
            }
          }
--- a/src/main/java/club/joylink/rtss/simulation/cbtc/work/MetroSimulationWorkServiceImpl.java
+++ b/src/main/java/club/joylink/rtss/simulation/cbtc/work/MetroSimulationWorkServiceImpl.java
@ -222,7 +222,7 @@ public class MetroSimulationWorkServiceImpl implements SimulationWorkService {
    faultGenerator.addJobs(simulation);
    atsMessageCollectAndDispatcher.addJobs(simulation);
    nccAlarmService.addJobs(simulation);
-    trainMessageDiagram.addJobs(simulation);
+//    trainMessageDiagram.addJobs(simulation); 逻辑报错，暂时注掉
  }

  @Override
--- a/src/main/java/club/joylink/rtss/vo/map/RealLineConfigVO.java
+++ b/src/main/java/club/joylink/rtss/vo/map/RealLineConfigVO.java
@ -10,7 +10,7 @@ import lombok.Setter;
 import org.springframework.util.StringUtils;

 /**
- *地图线路公共配置项
+ * 地图线路公共配置项
 */
@Getter
@Setter
@ -18,12 +18,12 @@ import org.springframework.util.StringUtils;
 public class RealLineConfigVO {

  /**
-     *上行是否右方向
+   * 上行是否右方向
   */
  private Boolean upRight = true;

  /**
-     *进路办理是否先锁闭——开始办理直接先锁闭区段（如福州一号线）
+   * 进路办理是否先锁闭——开始办理直接先锁闭区段（如福州一号线）
   */
  private Boolean lockFirst = false;

@ -38,76 +38,76 @@ public class RealLineConfigVO {
  private boolean routeSettingNoFail = false;

  /**
-     *是否列车停站开门后，才办理出站进路开放出站信号机
+   * 是否列车停站开门后，才办理出站进路开放出站信号机
   */
  private boolean signalOpenAfterParking = false;

  /**
-     *站台扣车是否关闭逻辑点灯的信号机
+   * 站台扣车是否关闭逻辑点灯的信号机
   */
  private boolean standHoldCloseLogicLight = false;

  /**
-     *ATS是否自动处理人工设置的站前折返自动更新车次
+   * ATS是否自动处理人工设置的站前折返自动更新车次
   */
  private boolean atsAutoHandleManualFrontTurnBack = false;

  /**
-     *CTC列车进路延续保护仅折返站处锁闭
+   * CTC列车进路延续保护仅折返站处锁闭
   */
  private boolean ctcOverlapOnlyTurnBackStationLock = false;

  /**
-     *引导办理是否需要先排列进路
+   * 引导办理是否需要先排列进路
   */
  private boolean guideNeedRouteSettingFirst = true;

  /**
-     *道岔区段状态改变按单个道岔处理
+   * 道岔区段状态改变按单个道岔处理
   */
  private Boolean switchSingleHandle = true;

  /**
-     *道岔正/反操是否联动
+   * 道岔正/反操是否联动
   */
  private Boolean switchNRTurnChain = false;

  /**
-     *道岔单解/锁是否联动
+   * 道岔单解/锁是否联动
   */
  private Boolean switchSingleLockChain = false;

  /**
-     *道岔故障失表是否联动
+   * 道岔故障失表是否联动
   */
  private Boolean switchLossChain = false;

  /**
-     *是否强制取消进路/在接近区段占用时是否依旧强制执行取消进路
+   * 是否强制取消进路/在接近区段占用时是否依旧强制执行取消进路
   */
  private MapConfig.ApproachLockCancel singleApproachLockCancelRoute = MapConfig.ApproachLockCancel.NOT;

  /**
-     *列车控制模式/级别
+   * 列车控制模式/级别
   */
  private String runMode = RunLevel.CBTC.name();

  /**
-     *不停站头码车服务号列表
+   * 不停站头码车服务号列表
   */
-    private String noParkingSM="";
+  private String noParkingSM = "";
  /**
-     *停站头码车服务号列表
+   * 停站头码车服务号列表
   */
-    private String parkingSM="";
+  private String parkingSM = "";

  /**
-     *RM模式下ATP防护速度（单位km/h）
+   * RM模式下ATP防护速度（单位km/h）
   */
  private float rmAtpSpeed = 25f;

  /**
-     *URM模式下ATP防护速度（单位km/h）
+   * URM模式下ATP防护速度（单位km/h）
   */
  private float urmAtpSpeed = 45f;

@ -186,34 +186,54 @@ public class RealLineConfigVO {
   */
  private boolean holdCommandIgnoreControlMode;

-    /** 取消联锁条件不满足的进路时需要延时解锁 */
+  /**
+   * 取消联锁条件不满足的进路时需要延时解锁
+   */
  private boolean delayWhenCancelRouteWithAbnormalInterlock;

-    /** 车次号的位数 */
+  /**
+   * 车次号的位数
+   */
  private int figuresOfTripNumber = 4;

-    /** 服务号的位数 */
+  /**
+   * 服务号的位数
+   */
  private int figuresOfServiceNumber = 3;

-    /** 设置头码车时检查方向 */
+  /**
+   * 设置头码车时检查方向
+   */
  private boolean checkDirectionWhenSetHead;

-    /** 转换轨进路只能通过故障解锁来取消 */
+  /**
+   * 转换轨进路只能通过故障解锁来取消
+   */
  private boolean transferRouteCanOnlyFaultUnlock;

-    /** 头码车抵达目的地后变为人工车 */
+  /**
+   * 头码车抵达目的地后变为人工车
+   */
  private boolean setManualWhenHeadTrainArriveTarget;

-    /** 进路默认开启冲突检测 */
+  /**
+   * 进路默认开启冲突检测
+   */
  private boolean routeDefaultCheckConflict;

-    /** 运行图中车次号是否唯一 */
+  /**
+   * 运行图中车次号是否唯一
+   */
  private boolean tripNumberIsUnique;

-    /** 站台折返策略不生效 */
+  /**
+   * 站台折返策略不生效
+   */
  private boolean standTbStrategyIsInvalid;

-    /** 根据服务号更新车次计划 */
+  /**
+   * 根据服务号更新车次计划
+   */
  private boolean updateTripPlanByServiceNumber;

  /**
@ -223,10 +243,9 @@ public class RealLineConfigVO {
  /**
   * 对信号机封锁操作，是否影响信号显示
   * <p>
-     * true-封锁信号机，会使信号机显示禁止色<br>
-     * false-封锁信号机，不会影响信号机显示。 
+   * true-封锁信号机，会使信号机显示禁止色<br> false-封锁信号机，不会影响信号机显示。
   */
-    private boolean signalBolckOptReflectSignal=true;
+  private boolean signalBolckOptReflectSignal = true;


  /**
@ -245,6 +264,11 @@ public class RealLineConfigVO {
   */
  private boolean manualTrainDefaultStop;

+  /**
+   * 办理引导进路时，如果进路首区段占用，引导信号15秒后关闭
+   */
+  private boolean guideDelayCloseWhenFirstSectionOccupied;
+
  public static RealLineConfigVO parseJsonStr(String configData) {
    if (StringUtils.hasText(configData)) {
      return JsonUtils.read(configData, RealLineConfigVO.class);
Author	SHA1	Message	Date
thesai	508b8fa086	[修改]人解进路功能增加关闭引导信号功能（成都三） CI / Docker-Build (push) Successful in 2m14s Details [新增]首区段占用时，办理引导进路延时15秒后关闭引导信号	2024-10-12 17:30:21 +08:00
tiger_zhou	3c9aeb82f6	列车运行图例，报错修复 CI / Docker-Build (push) Successful in 4m35s Details	2024-10-10 17:57:59 +08:00
thesai	81074bbb2a	[修改]使车站折返策略生效；修改车次计划更新逻辑以消除折返策略导致的列车行驶到非计划折返轨的情况	2024-10-10 17:36:21 +08:00
thesai	82682452a1	[修改]列车在功能轨上时，会优先停在轨道的停车点上	2024-10-10 17:07:17 +08:00